A terminal command string that requires parameters contains special
character sequences starting with ``%'` to say how to encode the
parameters. These sequences control the actions of `tparam`

and
`tgoto`

.

The parameters values passed to `tparam`

or `tgoto`

are
considered to form a vector. A pointer into this vector determines
the next parameter to be processed. Some of the ``%'`-sequences
encode one parameter and advance the pointer to the next parameter.
Other ``%'`-sequences alter the pointer or alter the parameter
values without generating output.

For example, the ``cm'` string for a standard ANSI terminal is written
as ``\E[%i%d;%dH'`. (``\E'` stands for `ESC`.) ``cm'` by
convention always requires two parameters, the vertical and horizontal goal
positions, so this string specifies the encoding of two parameters. Here
``%i'` increments the two values supplied, and each ``%d'` encodes
one of the values in decimal. If the cursor position values 20,58 are
encoded with this string, the result is ``\E[21;59H'`.

First, here are the ``%'`-sequences that generate output. Except for
``%%'`, each of them encodes one parameter and advances the pointer
to the following parameter.

``%%'`-
Output a single
``%'`. This is the only way to represent a literal``%'`in a terminal command with parameters.``%%'`does not use up a parameter. ``%d'`-
As in
`printf`

, output the next parameter in decimal. ``%2'`-
Like
``%02d'`in`printf`

: output the next parameter in decimal, and always use at least two digits. ``%3'`-
Like
``%03d'`in`printf`

: output the next parameter in decimal, and always use at least three digits. Note that``%4'`and so on are*not*defined. ``%.'`-
Output the next parameter as a single character whose ASCII code is
the parameter value. Like
``%c'`in`printf`

. ``%+``char`'-
Add the next parameter to the character
`char`, and output the resulting character. For example,``%+ '`represents 0 as a space, 1 as``!'`, etc.

The following ``%'`-sequences specify alteration of the parameters
(their values, or their order) rather than encoding a parameter for output.
They generate no output; they are used only for their side effects
on the parameters. Also, they do not advance the "next parameter" pointer
except as explicitly stated. Only ``%i'`, ``%r'` and ``%>'` are
defined in standard Unix termcap. The others are GNU extensions.

``%i'`-
Increment the next two parameters. This is used for terminals that
expect cursor positions in origin 1. For example,
``%i%d,%d'`would output two parameters with``1'`for 0,``2'`for 1, etc. ``%r'`- Interchange the next two parameters. This is used for terminals whose cursor positioning command expects the horizontal position first.
``%s'`- Skip the next parameter. Do not output anything.
``%b'`-
Back up one parameter. The last parameter used will become once again
the next parameter to be output, and the next output command will use
it. Using
``%b'`more than once, you can back up any number of parameters, and you can refer to each parameter any number of times. ``%>``c1``c2`'-
Conditionally increment the next parameter. Here
`c1`and`c2`are characters which stand for their ASCII codes as numbers. If the next parameter is greater than the ASCII code of`c1`, the ASCII code of`c2`is added to it. ``%a``op``type``pos`'-
Perform arithmetic on the next parameter, do not use it up, and do not
output anything. Here
`op`specifies the arithmetic operation, while`type`and`pos`together specify the other operand. Spaces are used above to separate the operands for clarity; the spaces don't appear in the data base, where this sequence is exactly five characters long. The character`op`says what kind of arithmetic operation to perform. It can be any of these characters:``='`- assign a value to the next parameter, ignoring its old value. The new value comes from the other operand.
``+'`- add the other operand to the next parameter.
``-'`- subtract the other operand from the next parameter.
``*'`- multiply the next parameter by the other operand.
``/'`- divide the next parameter by the other operand.

`type`says which. It can be:``p'`-
Use another parameter. The character
`pos`says which parameter to use. Subtract 64 from its ASCII code to get the position of the desired parameter relative to this one. Thus, the character``A'`as`pos`means the parameter after the next one; the character``?'`means the parameter before the next one. ``c'`-
Use a constant value. The character
`pos`specifies the value of the constant. The 0200 bit is cleared out, so that 0200 can be used to represent zero.

The following ``%'`-sequences are special purpose hacks to compensate
for the weird designs of obscure terminals. They modify the next parameter
or the next two parameters but do not generate output and do not use up any
parameters. ``%m'` is a GNU extension; the others are defined in
standard Unix termcap.

``%n'`- Exclusive-or the next parameter with 0140, and likewise the parameter after next.
``%m'`- Complement all the bits of the next parameter and the parameter after next.
``%B'`-
Encode the next parameter in BCD. It alters the value of the
parameter by adding six times the quotient of the parameter by ten.
Here is a C statement that shows how the new value is computed:
`parm`= (`parm`/ 10) * 16 +`parm`% 10; ``%D'`-
Transform the next parameter as needed by Delta Data terminals.
This involves subtracting twice the remainder of the parameter by 16.
`parm`-= 2 * (`parm`% 16);

Go to the first, previous, next, last section, table of contents.