TR is used to
translate one string of characters to another string of characters based on a
translate table which defines the substitutions which should occur. For instance, TR could be used to convert a string of characters from lower case
to upper case, or from ASCII to EBCDIC.
Operand 1 designates a string contain in memory which is to be
translated. Operand 2 designates the
translate table. This table is also
called a “table of functions”. TR translates one byte at a time,
starting with the leftmost byte of Operand 1, proceding from left to right.
Each byte that is translated is used as a displacement into the table. The “function byte” that is found in the
table is substituted for the byte in Operand 1. Since a byte can contain any value from X’00’ to X’FF’, the table
of functions is usually 256 bytes long to accommodate the range of addresses
from table + X’00’ to table + X’FF’.
Let us consider how a particular byte is translated using a
table of functions called “TABLE”. For
example, how would a byte containing X’A2’ be translated? Since X’A2’ = 162 in base 10, X’A2’ would be
replaced by the byte at address “TABLE+162”.
In other words, the byte we are translating acts as a displacement into
the table, and is replace by the table byte in that position.
Consider the following example.
To keep things simple, we begin with a small ( 5 bytes ) table and
assume that the bytes in the string which is being translated generate displacements
that stay inside the table. ( For safety, most TR tables are 256 bytes in length. ) We assume the following
definitions.
STRING DC
X’030201’
TABLE DC
X’FF01AABB00’
We issue the following
command.
TR
STRING,TABLE
The execution of this instruction is graphically illustrated on
the next page. Let us consider a byte
by byte description of the execution of TR. The first byte of String, x’03’, is used as a displacement into TABLE. The byte at address TABLE+3, which is X’BB’, replaces the first byte in
STRING. This means the string
temporarily looks like X’BB0200’. Next,
the second byte of STRING, X’02’, is used as a displacement into the
table. As a result the byte at TABLE+2,
which is X’AA’, replaces X’02’ in string. Finally, the third byte in STRING, X’01’, is
used as a displacement into the table and the byte at TABLE+1, X’01’, replaces
X’01’ in STRING. After the TR has
executed, STRING contains X’BBAA01’.
To be safe when using TR you
should always code a translate table that is 256 bytes long so that you can
handle any possible displacement that might be used in the translation. The only exception to this rule occurs when
you are sure that the bytes you are translating fall within a specified
range.
How could you define a translate table that translates every
character to itself? Since each
character would be used as a displacement to itself, a translate table of this
type would look like X’000102030405060708090A0B0C0D0E0F10...’. There is an easy way to construct such a
table: TABLE
DC 256AL1(*-TABLE)
This technique works by
defining 256 byte address constants of length 1. When defining the first byte in the table the asterisk refers to
the same address as TABLE, and so *-TABLE is 0. After defining the first byte the location counter advances and
*-TABLE is 1 when defining the second byte.
Continuing in this fashion, the expression “*-TABLE” takes on all the
values from 0 to 256. As a result, we create a table that translates every
character to itself. This is important
because in many applications, most of the characters we encounter are left
unchanged by TR.
For example, suppose we want to translate lower case letters to
upper case. To do this we use the
following table definition.
TABLE
DC 256AL1(*-TABLE)
ORG TABLE+C’a’
DC C’ABCDEFGHI’
ORG TABLE+C’j’
DC C’JKLMNOPQR’
ORG TABLE+C’s’
DC C’STUVWXYZ’
ORG
Notice that most bytes
translate to themselves. An originate
directive is used to position to the table position that contains a lower case “a”. This is followed by a DC that defines the
upper case letters A - I. This
technique is repeated for “j” and “s”. Since
the lower case letters occur in 3 blocks ( A - I, J - R, and S - Z ) the DC’s above
provide for the conversion from lower to upper case.
Some Unrelated TR’s:
TABLE DC
X’0302010300’ VERY SMALL
TRANSLATE TABLE
A
DC X’040404’
B
DC X’000003020201’
C
DC X’00000000’
D
DC X’01010101’
E
DC X’020202’
F
DC X’010203’
... Result:
TR A,TABLE A = X’000000’
TR B,TABLE B = X’03030301010102’
TR C,TABLE C = X’03030303’
TR D,TABLE D = X’02020202’
TR E,TABLE E = X’010101’
TR F,TABLE F = X’020103’
1. Start with a table that translates each byte to itself (
TABLE DC 256AL1(*-TABLE) ). Use “ORG”
to position yourself to an appropriate character ( ORG TABLE+C’X’ positions you at ‘X’.) Redefine the area with a ‘DC’.
2. Avoid translation errors by defining all translate tables with
256 bytes.