Ubuntu Manpage: tbl - prepare tables for groff documents

Provided by: groff-base_1.23.0-3build2_amd64

Name

       tbl - prepare tables for groff documents

Synopsis

       tbl [-C] [file ...]

       tbl --help

       tbl -v
       tbl --version

Description

The GNU implementation of tbl is part of the groff(1) document formatting system. tbl is
a troff(1) preprocessor that translates descriptions of tables embedded in roff(7) input
files into the language understood by troff. 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, tbl 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 “-”, tbl reads the standard input stream.

Overview
tbl 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 tbl 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 tbl 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. tbl 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.

Region options
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.

allbox Enclose each table entry in a box; implies box.

box Enclose the entire table region in a box. As a GNU extension, the alternative
option name frame is also recognized.

center Center the table region with respect to the current indentation and line length;
the default is to left-align it. As a GNU extension, the alternative option name
centre is also recognized.

decimalpoint(c)
Recognize character c as the decimal separator in columns using the N (numeric)
classifier (see subsection “Column classifiers” below). This is a GNU extension.

delim(xy)
Recognize characters x and y as start and end delimiters, respectively, for eqn(1)
input, and ignore input between them. x and y need not be distinct.

doublebox
Enclose the entire table region in a double box; implies box. As a GNU extension,
the alternative option name doubleframe is also recognized.

expand Spread the table horizontally to fill the available space (line length minus
indentation) by increasing column separation. Ordinarily, a table is made only as
wide as necessary to accommodate the widths of its entries and its column
separations (whether specified or default). When expand applies to a table that
exceeds the available horizontal space, column separation is reduced as far as
necessary (even to zero). tbl produces groff input that issues a diagnostic if
such compression occurs. The column modifier x (see below) overrides this option.

linesize(n)
Draw lines or rules (e.g., from box) with a thickness of n points. The default is
the current type size when the region begins. This option is ignored on terminal
devices.

nokeep Don't use roff diversions to manage page breaks. Normally, tbl employs them to
avoid breaking a page within a table row. This usage can sometimes interact badly
with macro packages' own use of diversions—when footnotes, for example, are
employed. This is a GNU extension.

nospaces
Ignore leading and trailing spaces in table entries. This is a GNU extension.

nowarn Suppress diagnostic messages produced at document formatting time when the line or
page lengths are inadequate to contain a table row. This is a GNU extension.

tab(c) Use the character c instead of a tab to separate entries in a row of table data.

Table format specification
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.

Column classifiers
The L, R, and C classifiers are the easiest to understand and use.

A, a Center longest entry in this column, left-align remaining entries in the column
with respect to the centered entry, then indent all entries by one en. Such
“alphabetic” entries (hence the name of the classifier) can be used in the same
column as L-classified entries, as in “LL,AR.”. The A entries are often termed
“sub-columns” due to their indentation.

C, c Center entry within the column.

L, l Left-align entry within the column.

N, n Numerically align entry in the column. tbl aligns columns of numbers vertically at
the units place. If multiple decimal separators are adjacent to a digit, it uses
the rightmost one for vertical alignment. If there is no decimal separator, the
rightmost digit is used for vertical alignment; otherwise, tbl centers the entry
within the column. The roff dummy character \& in an entry marks the glyph
preceding it (if any) as the units place; if multiple instances occur in the data,
the leftmost is used for alignment.

If N-classified entries share a column with L or R entries, tbl centers the widest
N entry with respect to the widest L or R entry, preserving the alignment of
N entries with respect to each other.

The appearance of eqn equations within N-classified columns can be troublesome due
to the foregoing textual scan for a decimal separator. Use the delim region option
to make tbl ignore the data within eqn delimiters for that purpose.

R, r Right-align entry within the column.

S, s Span previous entry on the left into this column.

^ Span entry in the same column from the previous row into this row.

_, - Replace table entry with a horizontal rule. An empty table entry is expected to
correspond to this classifier; if data are found there, tbl issues a diagnostic
message.

= Replace table entry with a double horizontal rule. An empty table entry is
expected to correspond to this classifier; if data are found there, tbl issues a
diagnostic message.

| Place a vertical rule (line) on the corresponding row of the table (if two of these
are adjacent, a double vertical rule). This classifier does not contribute to the
column count and no table entries correspond to it. A | to the left of the first
column descriptor or to the right of the last one produces a vertical rule at the
edge of the table; these are redundant (and ignored) in boxed tables.

To change the table format within a tbl 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.

Column modifiers
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.

b, B Typeset entry in boldface, abbreviating f(B).

d, D Align a vertically spanned table entry to the bottom (“down”), instead of the
center, of its range. This is a GNU extension.

e, E Equalize the widths of columns with this modifier. The column with the largest
width controls. This modifier sets the default line length used in a text block.

f, F Select the typeface for the table entry. This modifier must be followed by a font
or style name (one or two characters not starting with a digit), font mounting
position (a single digit), or a name or mounting position of any length in
parentheses. The last form is a GNU extension. (The parameter corresponds to that
accepted by the troff ft request.) A one-character argument not in parentheses
must be separated by one or more spaces or tabs from what follows.

i, I Typeset entry in an oblique or italic face, abbreviating f(I).

m, M Call a groff macro before typesetting a text block (see subsection “Text blocks”
below). This is a GNU extension. This modifier must be followed by a macro name
of one or two characters or a name of any length in parentheses. A one-character
macro name not in parentheses must be separated by one or more spaces or tabs from
what follows. The named macro must be defined before the table region containing
this column modifier is encountered. The macro should contain only simple groff
requests to change text formatting, like adjustment or hyphenation. The macro is
called after the column modifiers b, f, i, p, and v take effect; it can thus
override other column modifiers.

p, P Set the type size for the table entry. This modifier must be followed by an
integer n with an optional leading sign. If unsigned, the type size is set to
n scaled points. Otherwise, the type size is incremented or decremented per the
sign by n scaled points. The use of a signed multi-digit number is a GNU
extension. (The parameter corresponds to that accepted by the troff ps request.)
If a type size modifier is followed by a column separation modifier (see below),
they must be separated by at least one space or tab.

t, T Align a vertically spanned table entry to the top, instead of the center, of its
range.

u, U Move the column up one half-line, “staggering” the rows. This is a GNU extension.

v, V Set the vertical spacing to be used in a text block. This modifier must be
followed by an integer n with an optional leading sign. If unsigned, the vertical
spacing is set to n points. Otherwise, the vertical spacing is incremented or
decremented per the sign by n points. The use of a signed multi-digit number is a
GNU extension. (This parameter corresponds to that accepted by the troff vs
request.) If a vertical spacing modifier is followed by a column separation
modifier (see below), they must be separated by at least one space or tab.

w, W Set the column's minimum width. This modifier must be followed by a number, which
is either a unitless integer, or a roff horizontal measurement in parentheses.
Parentheses are required if the width is to be followed immediately by an explicit
column separation (alternatively, follow the width with one or more spaces or
tabs). If no unit is specified, ens are assumed. This modifier sets the default
line length used in a text block.

x, X Expand the column. After computing the column widths, distribute any remaining
line length evenly over all columns bearing this modifier. Applying the x modifier
to more than one column is a GNU extension. This modifier sets the default line
length used in a text block.

z, Z Ignore the table entries corresponding to this column for width calculation
purposes; that is, compute the column's width using only the information in its
descriptor.

n A numeric suffix on a column descriptor sets the separation distance (in ens) from
the succeeding column; the default separation is 3n. This separation is
proportionally multiplied if the expand region option is in effect; in the case of
tables wider than the output line length, this separation might be zero. A
negative separation cannot be specified. A separation amount after the last column
in a row is nonsensical and provokes a diagnostic from tbl.

Table data
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. tbl 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.

• If a table row contains only an underscore or equals sign (_ or =), a single or double
horizontal rule (line), respectively, is drawn across the table at that point.

• A table entry containing only _ or = on an otherwise populated row is replaced by a
single or double horizontal rule, respectively, joining its neighbors.

• Prefixing a lone underscore or equals sign with a backslash also has meaning. If a
table entry consists only of \_ or \= on an otherwise populated row, it is replaced by a
single or double horizontal rule, respectively, that does not (quite) join its
neighbors.

• A table entry consisting of \Rx, where x is any roff ordinary or special character, is
replaced by enough repetitions of the glyph corresponding to x to fill the column,
albeit without joining its neighbors.

• On any row but the first, a table entry of \^ causes the entry above it to span down
into the current one.

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 \&.

Text blocks
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.

tbl 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.

roff interface
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.

tbl also defines a macro T# to produce the bottom and side lines of a boxed table. While
tbl 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.

Interaction with eqn
tbl should always be called before eqn(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 tbl will recognize
them.

GNU tbl enhancements
In addition to extensions noted above, GNU tbl removes constraints endured by users of
AT&T tbl.

• Region options can be specified in any lettercase.

• There is no limit on the number of columns in a table, regardless of their
classification, nor any limit on the number of text blocks.

• All table rows are considered when deciding column widths, not just those occurring in
the first 200 input lines of a region. Similarly, table continuation (.T&) tokens are
recognized outside a region's first 200 input lines.

• Numeric and alphabetic entries may appear in the same column.

• Numeric and alphabetic entries may span horizontally.

Using GNU tbl within macros
You can embed a table region inside a macro definition. However, since tbl 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 tbl features can be exercised from such macros because tbl is a roff preprocessor:
it sees the input earlier than troff does. For example, vertically aligning decimal
separators fails if the numbers containing them occur as macro or string parameters; the
alignment is performed by tbl itself, which sees only \$1, \$2, and so on, and therefore
can't recognize a decimal separator that only appears later when troff interpolates a
macro or string definition.

Using tbl macros within conditional input (that is, contingent upon an if, ie, el, or
while request) can result in misleading line numbers in subsequent diagnostics. tbl
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 tbl 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.

Options

       --help displays a usage message, while -v and --version show version information; all exit
       afterward.

       -C     Enable AT&T compatibility mode: recognize .TS and  .TE  even  when  followed  by  a
              character  other  than  space or newline.  Furthermore, interpret the uninterpreted
              leader escape sequence \a.

Limitations

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.

Examples