Trailing-Edge
-
PDP-10 Archives
-
decuslib10-02
-
43,50250/tbltrn.lst
There are no other files named tbltrn.lst in the archive.
TTTTTTTTT BBBBBBBBB LLL TTTTTTTTT RRRRRRRRR NNN NNN
TTT BBB BBB LLL TTT RRR RRR NNNN NNN
TTT BBBBBBB LLL TTT RRRRRRR NNN N NNN
TTT BBB BBB LLL TTT RRR RRR NNN NNNN
TTT BBBBBBBBB LLLLLLLL TTT RRR RRR NNN NNN
TBLTRN Instruction Manual
A Symbolic Table Assembler Written in FORTRAN
Table of Contents
Operating Procedures Manual
Operating Procedures . . . . . . . . . . . . . . . . 1
Testing TBLTRN . . . . . . . . . . . . . . . . . . . 4
Adapting TBLTRN to Other Computers . . . . . . . . . 4
Adapting TBLTRN to Batch Mode or to Other Computers . 6
Maximum TBLTRN Table and/or Dictionary Size . . . . . 7
Language Specification Manual
An Introduction to the TBLTRN Language . . . . . . . 8
Symbol and Statement Termination . . . . . . . . . . 20
Character Classes . . . . . . . . . . . . . . . . . . 20
Symbol Types . . . . . . . . . . . . . . . . . . . . 23
Radices for Integer Evaluation . . . . . . . . . . . 28
Parenthetical Expressions . . . . . . . . . . . . . . 29
Entering Multiple Constants into a Single Byte . . . 31
Using Multiple Constants Instead of Integer Prefix . 32
Stack Construction and Use . . . . . . . . . . . . . 33
User Interaction with Assemblies . . . . . . . . . . 36
Conditional Assembly Capability . . . . . . . . . . . 37
Data Statement Output . . . . . . . . . . . . . . . . 39
Construction of Test Tables . . . . . . . . . . . . . 41
User Defined Functions . . . . . . . . . . . . . . . 42
Pre-execution Assembly of User Defined Functions . . 49
Query Operators . . . . . . . . . . . . . . . . . . . 51
Programmed Operators . . . . . . . . . . . . . . . . 56
Symbol Definitions . . . . . . . . . . . . . . . . . 101
Table Entry Definitions . . . . . . . . . . . . . . . 109
Principles of Operation Manual
Input Text String Buffer Structure . . . . . . . . . 114
Symbol Selection from Text Buffer . . . . . . . . . . 121
Symbol Dictionary Structure . . . . . . . . . . . . . 123
Symbol Construction by Stack Operators . . . . . . . 136
Index . . . . . . . . . . . . . . . . . . . . . . . . . 139
Operating Procedures
--------- ----------
TBLTRN is an assembler written in FORTRAN for symbolic
tables which are to control other programs. The language in
which these tables are written is established by the user
through association of either single or multiple precision
values with the words of a vocabulary. Such values can be
assembled with byte and/or location offset as defined by
packing templates also specified by the user. In addition,
95 programmed operators are available.
TBLTRN was originally written for use on a PDP-10 computer
and the following operating instructions are for that
computer. The TBLTRN system is distributed on two DECtapes,
the first containing this documentation to be printed in
upper and lower case, and the second containing the FORTRAN
and assembly language source routines, a command file
containing the names of these source routines, and a group
of test tables. TBLTRN should be loaded by transferring the
F4, MAC and CMD files from the second tape to the disk, then
issuing the commands
LOAD @TBL
and
SAVE DSK:TBLTRN
so that the core image can be stored for future runs.
When started, TBLTRN will ask the user to supply the names
and unit numbers for the input file containing the source
table, and for the other files which will be necessary
during the assembly. These files must all have names of 5
or less characters and the name extension DAT. If the tab
character is used in the input file as equivalent to a
blank, it must be declared as such by the ACC (Alter
Character Class) operator. As a simple example of the
specification of these files, a table begun by the line
A==,B==
in file INPUT.DAT, and terminated by the line
A,B FIN
in the file FINAL.DAT could be assembled by the following
dialogue between the user and TBLTRN.
RUN DSK:TBLTRN
TBLTRN: Operating Procedures Manual Page 2
Operating Procedures
TBLTRN (06/72)
INPUT UNIT NUMBER = 1
INPUT FILE NAME = INPUT
OUTPUT UNIT NUMBER = 20
OUTPUT FILE NAME = OUTPU
LISTER UNIT NUMBER = 21
LISTER FILE NAME = LIST
PLEASE TYPE DEFINITION FOR SYMBOL A
11,
CONSTANT 4431 WRD 1 OCT 13 11 A
PLEASE TYPE DEFINITION FOR SYMBOL B
22,
CONSTANT 4427 WRD 1 OCT 26 22 B
END-OF-FILE READ ON UNIT 1
IS THERE MORE INPUT (Y OR N) Y
INPUT UNIT NUMBER = 1
INPUT FILE NAME = FINAL
STORAGE SUMMARY
ENTRIES 2
OPERATORS 578
LABELS 0
EXCESS 4420 (CURRENT)
4420 (MINIMUM)
CPU TIME: 0.45 ELAPSED TIME: 1:15.25
NO EXECUTION ERRORS DETECTED
EXIT
^C
.
In the above example, the following text was typed by the
user on the teletype.
RUN DSK:TBLTRN
1
INPUT
20
OUTPU
21
LIST
11,
22,
Y
1
FINAL
TBLTRN: Operating Procedures Manual Page 3
Operating Procedures
Default answers are assumed if a zero or blank response is
given to a request for a unit number or if a blank response
is given to a request for a file name or for whether more
input is to follow after the reading of an end-of-file. The
values of these defaults as supplied by subroutine TBLNMB
are as follow.
INPUT UNIT NUMBER = 1
INPUT FILE NAME = INPUT
OUTPUT UNIT NUMBER = 20
OUTPUT FILE NAME = OUTPU
LISTER UNIT NUMBER = 21
LISTER FILE NAME = LIST
IS THERE MORE INPUT (Y OR N) Y
A negative answer (note that -0 is not negative), to a
request for a unit number, invokes the default responses for
that request and for the remaining unit number and file name
requests which are then suppressed. Since the user in the
above dialogue issued what would have been assumed as the
default responses to the first 6 questions, he could instead
have typed only the following text.
RUN DSK:TBLTRN
-1
11,
22,
Y (or carriage return)
0 (or carriage return)
FINAL
If the teletype unit number (defined at ITTY the first time
TBLNMB is called) is given as the response to a request for
a unit number, the remaining requests are suppressed and all
the remaining unit numbers, if any, are assumed to be the
teletype unit number. The question
BACKUP UNIT NUMBER (NO BACKUP IF ZERO) =
is asked when the teletype is specified as the input unit
(either initially, or after an end-of-file is read if backup
copying has not already been selected). A non-zero response
causes teletype input to be copied into a backup file. The
default unit number 22 and default file name BACKU.DAT are
invoked if the answer was negative. If the answer was
positive, the question
BACKUP FILE NAME =
is also asked and can be answered with a blank response to
invoke the BACKU.DAT default file name. Once selected,
copying of teletype input into the backup file cannot be
terminated.
TBLTRN: Operating Procedures Manual Page 4
Testing TBLTRN
Testing TBLTRN
------- ------
The supplied data files such as TEST1.DAT and TEST2.DAT each
contain a collection of 25 tables which exercise the TBLTRN
grammar. The numeric name of the test table and an error
summary consisting of the incorrect entries compared with
the expected results are written into the listing file for
each test table. These tables should be tried if simple
tables seem to be giving the expected results and if the
sample test table given in the later section "Construction
of Test Tables" produces the listing also given in that
section.
Adapting TBLTRN to Other Computers
-------- ------ -- ----- ---------
Although TBLTRN is largely written in machine independent
FORTRAN, 5 simple assembly language or machine-tailored
FORTRAN functions are necessary. These functions are the
following.
ITBAND returns as its value the logical AND of its 2
arguments (the result has a particular bit turned on
only if the corresponding bit was turned on in both
of the arguments).
ITBMOV returns as its value the value of its first argument
shifted the number of bits indicated by its second
argument. The shift is to the left if the second
argument is positive, to the right if the second
argument is negative. Bits shifted beyond the word
boundaries are lost.
ITBOR returns as its value the inclusive OR of its 2
arguments (the result has a particular bit turned on
if the corresponding bit was turned on in either or
both of the arguments).
ITBSIN returns as its value the number which has the sign
bit turned on (one) and all other bits off (zero).
This function is called only when the symbol
dictionary is constructed from the ISTORE array at
the start of the first table or when the BLK
operator prepares for the following table.
ITBXOR returns as its value the exclusive OR of its 2
arguments (the result has a particular bit turned on
only if the corresponding bit was turned on in one
but not both of the arguments).
ITBMOV can be written in FORTRAN if the number to be shifted
is positive, and if the number is not shifted into the sign
bit. The following routine accomplishes such bit shifting
by multiplication.
TBLTRN: Operating Procedures Manual Page 5
Adapting TBLTRN to Other Computers
FUNCTION ITBMOV(I,J)
C
C FORTRAN FUNCTION TO SIMULATE SHIFT OPERATOR
C DOES NOT WORK FOR NEGATIVE VALUE OF I
C
C I=ITEM TO BE SHIFTED
C J=NUMBER OF BITS TO BE SHIFTED
C
IF(J.EQ.0)GO TO 4
IF(I.LT.0)GO TO 2
IF(J.LT.0)GO TO 1
ITBMOV=I*(2**J)
GO TO 5
1 K=-J
ITBMOV=I/(2**K)
GO TO 5
2 WRITE(5,3)
3 FORMAT(34H SHIFT OF NEGATIVE VALUE ATTEMPTED)
4 ITBMOV=I
5 RETURN
END
ITBOR can be written in FORTRAN if the FORTRAN .OR. operator
returns the inclusive OR of all bits of the numbers being
operated upon. FORTRAN language specifications require only
that the OR be of the sign bit. All bits will usually be
returned though, since this is easier. The following
routine performs correctly on the PDP-10.
FUNCTION ITBOR(I,J)
C
C MACHINE DEPENDENT ROUTINE FOR TBLTRN
C
C RETURNS INCLUSIVE OR OF 2 ARGUMENTS
C
ITBOR=I.OR.J
RETURN
END
ITBAND and ITBXOR can similarly be written in FORTRAN if the
FORTRAN .AND. and .XOR. operators return as results the
respective operations applied to all bits of the arguments.
ITBSIN can be written in FORTRAN, but the octal or
hexadecimal representation will depend both upon the number
of bits per word and the manner in which these can be
accessed in the particular FORTRAN used. ITBSIN can be
merely a dummy routine if the NEG operator (really a
constant) is not necessary. The following routine uses the
double quote octal notation to specify all 36 bits of a
PDP-10 word.
TBLTRN: Operating Procedures Manual Page 6
Adapting TBLTRN to Other Computers
FUNCTION ITBSIN(I)
C
C MACHINE DEPENDENT ROUTINE FOR TBLTRN
C
C RETURNS SIGN BIT ON AND ALL OTHER BITS ZEROED
C
ITBSIN="400000000000
RETURN
END
TBLTRN can at most access 50 bits per word. When used on
computers with larger word sizes than this, either the
excess bits will have to be ignored, or the internal packing
for storage of reduced byte shifts for packing pattern
arguments and of reduced byte shifts for references of
unknown address labels by the LOC and BIT operators will
have to be changed. Similarly, TBLTRN cannot be run on a
computer which cannot store the number 8080 within a single
word. This is the maximum number needed to pack shift, sign
and reduced byte size within the data cells in the symbol
dictionary. If a single computer word can contain the
number 8080 but cannot contain the dimension of the MASTER
array times 8080, the test
IF(LOCK.EQ.0)GO TO XX
(where XX is a statement number) must be removed from the
section of the routine TBLOPR which processes symbols within
the range of the LOC operator. This statement determines
whether a chain of unknown address label references is to be
threaded into the assembled table. The statement is
indicated by comment cards within the program.
Adapting TBLTRN to Batch Mode or to Other Computers
-------- ------ -- ----- ---- -- -- ----- ---------
Routine TBLNMB is called prior to the assembly of the first
table to interrogate the user for the various input and
output unit numbers and to open named files if necessary.
The teletype unit number, stored as ITTY, is defined without
consulting the user the first time TBLNMB is called. The
other default unit numbers and file names are specified by a
DATA statement at the start of the routine. TBLNMB is also
called after an end-of-file is read on the input device to
determine if there is to be additional input and, if so, to
open the new file. TBLNMB identifies the end-of-file call
by the line count ILINE being non-zero, and zeroes this line
count if there is to be further input. For batch mode,
TBLNMB will have to be hard-coded to return the following
unit numbers to the main program.
TBLTRN: Operating Procedures Manual Page 7
Adapting TBLTRN to Batch Mode or to Other Computers
ITTY = Output unit onto which are generated all error
messages, all query operator messages, and those
TEL operator messages for which a 0 has not
appeared within the range of the TEL operator.
Also receives text within the range of the ''
(double apostrophe) operator which is not within
the range of an operator which allows a text string
as an argument.
= Input unit from which definitions requested by the
== operator are read, and from which all input is
read if the TTY operator is encountered within the
input file.
IREAD = Input unit from which the table is read.
IWRITE = Output unit onto which the assembled table is
written. Also contains text within the range of
the ' (single quote) operator which is not within
the range of an operator which allows a text string
as an argument.
ILPT = Output unit onto which is generated debugging
output of the DBG, DMP and LST operators and output
of the TEL operator when a 0 has appeared within
the range of the TEL operator. Also receives a
summary of all text replacements when the LMT
operator has been issued with a negative value, and
a summary of assembly errors within a test table.
IOUT = Output unit onto which is copied an input table
read from the teletype. Normally IOUT is equal to
ITTY and no copy is kept.
Maximum TBLTRN Table and/or Dictionary Size
------- ------ ----- ------ ---------- ----
The assembled table entries are stacked into the bottom of
the MASTER array, and the symbol dictionary is hung from the
location within this same array having the subscript which
is stored as the variable MAX. In the distributed version
of TBLTRN which uses 24K of core on a PDP-10, MAX is defined
in the BLOCK DATA routine to be 5000, and the dimension of
the MASTER array within the labeled COMMON/TBLTRN/ is also
5000. Whether this size of array will be sufficient for a
particular table will largely depend upon the size of the
symbol dictionary defined by the user. The available
working space can be changed by replacing all appearances of
the number 5000 with the desired dimension.
TBLTRN: Language Specification Manual Page 8
An Introduction to the TBLTRN Language
An Introduction to the TBLTRN Language
-- ------------ -- --- ------ --------
When constructing symbolic tables which are to be processed
by TBLTRN, the programmer specifies the table entry (word)
into which an item is to be inserted, the position (byte) in
this word, and how the item is to be inserted (sign). The 3
properties of word, byte and sign can be specified in any
order immediately before the item to be inserted. If not
specifed, default values are assumed for these properties.
The item itself can be an integer specified in any radix
from binary to hexadecimal, a symbol which has been defined
as a single or multiple entry constant, or an address label
preceded by the location operator LOC. As a very elementary
example, the statements
2
4
6
8
10
would assemble 5 table entries containing the even values 2,
4, 6, 8 and decimal 10. Since statements which appear on
the same line can be separated by single commas, this could
also be written as
2,4,6,8,10
These same statements could be written in symbolic form if
symbols are first defined to have the necessary values by
the use of the = operator. The same table entries would be
assembled by the statements
TWO=2,FOUR=4,SIX=6,EIGHT=8,TEN=10
TWO,FOUR,SIX,EIGHT,TEN
A single statement can, however, specify the contents of
several table entries. For this purpose, the WRD operator
is used prior to the appearance of the constant to which it
applies. The word count, considering the initial word
generated by the statement to be word 1, is indicated by a
decimal integer prefix of the WRD operator, or by a constant
or parenthetical expression immediately following the WRD
operator. The single statements
1WRD TWO 2WRD FOUR 3WRD SIX 4WRD EIGHT 5WRD TEN
or
TWO WRD TWO FOUR WRD 3 SIX WRD(FOUR)EIGHT WRD(5)TEN
TBLTRN: Language Specification Manual Page 9
An Introduction to the TBLTRN Language
or
TWO WRD(FOUR-2)4 WRD(5-TWO)6 WRD(2+2)8 WRD(5)10
would likewise assemble the same table entries as before.
In even these simple examples, however, the items being
packed have become lost within the assembly directions.
This can be partially overcome by the definition of the
constants as multiple precision integers again through use
of the WRD operator. For example, the statements could be
written
TWO=2,FOUR=WRD TWO 4,SIX=3WRD 6
EIGHT=WRD(TWO+TWO)8,TEN=WRD 5 10
TWO FOUR SIX EIGHT TEN
or
TOTAL=2 2WRD 4 3WRD 6 4WRD 8 5WRD 10
TOTAL
Items defined in this manner cannot result in table entries
in any other order. The symbol EIGHT will always be
deposited into the fourth table entry being currently
constructed regardless of this symbol's position in the
statement. If, on the other hand, an item's position within
a statement indicates how and where it is to be packed, a
packing pattern or byte template can be used. Specified in
the template's definition are the sign with which and the
byte and offset of the word into which each of the
template's arguments is to be assembled. The sign can be
either + (addition), - (subtraction), IOR (inclusive OR),
XOR (exclusive OR), or AND (logical AND). Such
specifications are optional and can be given in any order.
The default values are zero for shift, one for word count
and inclusive OR for sign if the byte size is 2 raised to
some power, or addition otherwise. To again obtain the
assembled values of 2, 4, 6, 8 and 10, the following
statements might be used.
TWO=2,FOUR=4,SIX=6,EIGHT=8,TEN=10
TEMPLATE=MSK ARG 2WRD ARG 3WRD ARG,,,
4WRD ARG 5WRD ARG
TEMPLATE TWO FOUR SIX EIGHT TEN
Templates must always be defined by appending to, or in
terms of, the definitions of existing templates, such as the
null template MSK. The ARG operator terminates the
specification of a single argument of the template. The
three commas are used in the template's definition to
indicate that the definition continues on the following
line. The template is employed by stating its name followed
by the items to which it is to apply.
TBLTRN: Language Specification Manual Page 10
An Introduction to the TBLTRN Language
Since computer memory is a vital resource, it is often not
economical to store many small numbers in individual words.
The alternative is to pack several of the smaller items into
a much larger number still smaller than the maximum the
computer word can contain. For example, if the numbers
represented by CC, DD and EE range from 0 through 99, these
can be packed into a single integer of 6 decimal digits by
the operations
1. Multipy number CC by 10000 and place the result into the
storage word.
2. Multiply number DD by 100 and add the result to the
current contents of the storage word.
3. Add number EE to the current contents of the storage
word.
In the above example, the byte size is really decimal 100
with number CC being shifted two bytes. The shift is done
by a logical bit shift if the byte size is 2 raised to some
power, and otherwise is done by multiplication if the shift
is to the left, or by division if the shift is to the right,
by the byte size raised to the power indicated as the shift.
The results from logical shifting and multiplication or
division are identical for a positive number which is not
shifted into the sign bit. In the TBLTRN language, the byte
size would be indicated either by use of the SIZ operator
with a decimal integer prefix as in
100SIZ
or by following the SIZ operator with a integer to be
interpreted under the current radix (decimal unless changed
temporarily by the OCT octal operator or DEC decimal
operator, or unless changed locally within a particular
symbol definition by the SRX operator, or unless changed
permanently for table entry definitions by the TRX operator
issued outside a symbol definition, or unless changed
permanently for symbol definitions by the SRX operator
issued outside a symbol definition) as in the statements
SIZ 100
or
SIZ OCT 144
or
SIZ 8TRX 144
TBLTRN: Language Specification Manual Page 11
An Introduction to the TBLTRN Language
or
8TRX SIZ 144
or by defining a symbol as the constant decimal 100 by a
statement of the form
I100=100
or, if the octal representation 144 is used, by a statement
of the form
I100=OCT 144
or
I100=8SRX 144
or
I100=SRX DEC 8 144
or
I100=SRX(4+4)144
and then using this constant after the SIZ operator in the
following manner.
SIZ I100
The table entry can then be constructed using the left shift
operator LFT by a statement of the form
100SIZ+2LFT CC+1LFT DD+EE
or
100SIZ 2LFT+CC 1LFT+DD+EE
or
+2LFT 100SIZ CC+1LFT DD+EE
or
2LFT+100SIZ CC+1LFT DD+EE
or
SIZ 100+LFT 2 CC+LFT 1 DD+EE
TBLTRN: Language Specification Manual Page 12
An Introduction to the TBLTRN Language
or
SIZ 100 LFT 2+CC LFT 1+DD+EE
or, if I1 has been defined as 1, I2 as 2, and I100 as
decimal 100, by a statement of the form
SIZ I100+LFT I2 CC+LFT I1 DD+EE
or
SIZ I100 LFT I2+CC LFT I1+DD+EE
The number of byte shifts, the size of these bytes, and the
sign must be specified before the constant to which these
apply, but can be written in any desired order. Like the
word count operator WRD, the number of bytes indicated by
the left shift operator LFT and by the right shift operator
RIT are specified by a decimal integer prefix of the
operator or by a constant or parenthetical expression
immediately following. Actually, in the above examples, the
plus signs are not really necessary, since addition is
assumed as default if the byte size is not a number (such as
2, 4, 8, 16 etc.) which has the base 2, otherwise the
default sign would be inclusive OR. Also, once set outside
a symbol definition, the byte size does not have to be
respecified for each new word. However, a packing pattern
can be used to supply all of this information. Such a
pattern could be defined for the above packing example by
the statement
TEMPLATE=MSK 100SIZ+2LFT ARG+1LFT ARG+ARG
or
TEMPLATE=MSK 100SIZ 2LFT ARG 1LFT ARG ARG
In the above examples, the relative ordering of signs and
shifts is arbitrary. The byte size would not have to be
stated if it is to be the same as the byte size previously
set outside a symbol definition. The default byte size at
the start of each table is 2.
The pattern could then be used to pack items CC, DD, and EE
in a statement of the form
TEMPLATE CC DD EE
If an additional packing pattern would be defined by a
statement such as
PATTERN=MSK 100SIZ 4LFT ARG 3LFT ARG
TBLTRN: Language Specification Manual Page 13
An Introduction to the TBLTRN Language
then 5 items might be packed by a statement similar to
PATTERN AA BB TEMPLATE CC DD EE
or a pattern with more arguments might be created by a
statement such as
MORE=MSK 100SIZ 4LFT ARG 3LFT ARG 2LFT ARG 1LFT,,,
ARG ARG
or
MORE=PATTERN TEMPLATE
or
MORE=MSK 100SIZ 4LFT ARG 3LFT ARG TEMPLATE
or
MORE=PATTERN 100SIZ 2LFT ARG 1LFT ARG ARG
and then the packing could be accomplished by simply stating
MORE AA BB CC DD EE
It should be noted that in the last of the above definitions
of MORE, a byte size specification such as 100SIZ is
necessary since the byte size used during the definition of
PATTERN applies only to its arguments. When items appear in
the table entry to the right of the number of arguments for
which the packing pattern is specified, these items are not
arguments and will be entered with the default sign and no
shift unless such are stated. Therefore, the packing could
also be accomplished by the statement
PATTERN AA BB 100SIZ 2LFT CC 1LFT DD EE
Packing patterns can similarly be used to specify the
construction of constants. For example, any of the
following statements could be used to define a constant
called ABC having packed as its value the constants AA
through EE.
ABC=100SIZ+4LFT AA+3LFT BB+2LFT CC+1LFT DD+0LFT EE
ABC=100SIZ 4LFT AA 3LFT BB 2LFT CC 1LFT DD 0LFT EE
ABC=100SIZ+4LFT AA+3LFT BB+2LFT CC+1LFT DD+ EE
ABC=100SIZ 4LFT AA 3LFT BB 2LFT CC 1LFT DD EE
TBLTRN: Language Specification Manual Page 14
An Introduction to the TBLTRN Language
ABC=100SIZ+4LFT AA+3LFT BB TEMPLATE CC DD EE
ABC=100SIZ 4LFT AA 3LFT BB TEMPLATE CC DD EE
ABC=PATTERN AA BB 100SIZ+2LFT CC+1LFT DD+0LFT EE
ABC=PATTERN AA BB 100SIZ 2LFT CC 1LFT DD 0LFT EE
ABC=PATTERN AA BB 100SIZ+2LFT CC+1LFT DD+ EE
ABC=PATTERN AA BB 100SIZ 2LFT CC 1LFT DD EE
ABC=PATTERN AA BB TEMPLATE CC DD EE
ABC=MORE AA BB CC DD EE
If the same packing pattern applies to several successive
entries, it may be set at the start of the series by the TON
operator, then assumed to be in effect until turned off by
the appearance of the null packing pattern MSK (or any other
symbol defined as equal to MSK only). For example, items AA
through OO could be packed into 3 storage words by the set
of statements
TON MORE AA BB CC DD EE
FF GG HH II JJ
KK LL MM NN OO MSK
The . (period) operator can be used in the definition of a
packing pattern to specify the point in the argument list at
which the origin of the word count is to be incremented by
one. For example, the statement
MASK=MSK 1000SIZ 1LFT ARG ARG.64SIZ 1LFT ARG ARG
defines a packing pattern named MASK which will perform the
following operations.
1. Multiply its first argument by 1000 before adding it
into the first table entry.
2. Add its second argument without shifting to the first
table entry.
3. Advance the table entry origin to the second table entry
if a third argument is encountered.
4. Shift its third argument left 6 bits before inclusive
ORing it into the second table entry.
5. Inclusive OR its fourth argument without shifting into
the second table entry.
TBLTRN: Language Specification Manual Page 15
An Introduction to the TBLTRN Language
The statement sequence
TON MASK
1 2 3 4
4 3 2 1
would then assemble the table entries
1002 = 1*1000 + 2
196 = 3*64 OR 4
4003 = 4*1000 + 3
129 = 2*64 OR 1
If instead, the definition was given as
MASK=MSK 1000SIZ 1LFT ARG ARG. .,,,
64SIZ 1LFT ARG ARG. .
or
MASK=MSK 1000SIZ 1LFT ARG ARG 2WRD.,,,
64SIZ 1LFT ARG ARG 2WRD.
then the same statement sequence would assemble the entries
1002
0
196
4003
0
129
Each statement in the above example produces a single zero
entry since the origin is incremented twice before the third
argument is assembled. If encountered, a fifth constant
would have been assembled into a new table entry following a
second zero entry using the default sign appropriate for the
default byte size and without shift, unless sign, shift or
word count are stated before this fifth constant.
The packing pattern can also specify zeroed entries prior to
the entry into which the first argument is assembled. For
example, the statements
MASK=MSK.1000SIZ 1LFT ARG ARG. .64SIZ 1LFT ARG ARG
TON MASK 1 2 3 4,4 3 2 1
would assemble the following table entries.
0
1002
0
196
TBLTRN: Language Specification Manual Page 16
An Introduction to the TBLTRN Language
0
4003
0
129
An origin increment specified by a packing pattern is
performed if either of the following is true.
1. The present packing pattern has a following argument
specification which is fulfilled either automatically
(see definition of ARG operator in section titled
"Programmed Operators") or explicitly. Performance of
an origin increment can be forced by following its
specification in the packing pattern definition by one
of the sequences ARG 0, ARG NUL, ARG() or ARG(NUL) which
would specify an automatic single precision zero
argument.
2. All the argument specifications, if any, of the present
packing pattern have been fulfilled either automatically
or explicitly, and within the statement in which the
packing pattern is used another packing pattern is not
selected before processing of the next constant or
address label or a BIT operator with the destination
being indicated by the single period operator as the
incremented table entry origin or a BIT operator with
the destination being a known address label of a table
entry already assembled by the current statement (BIT
possibly preceded, regardless of whether the destination
is indicated as period or label, by the WRD operator).
The table entry origin offset is not performed if there
does not remain unprocessed within the statement such a
constant or address label or BIT deposit.
For example, the statements
MASK MASK 1 2 3 4,MASK 4 3 2 1 MASK
would assemble the same table entries as the previous
example.
The DUP (DUPlicate) operator, used with either decimal
integer prefix or followed immediately by a constant or
parenthetical expression, specifies that the table entry or
entries assembled by the present (or following) statement
are to be duplicated as a set to form the number of sets
specified by the integer, constant or parenthetical
expression. The BIT operator turns on a specified bit in a
selected table entry. Table entries which are BIT operator
destinations and which are within the range of a DUP
operator are duplicated correctly regardless of the
placement of the statement which defines these entries with
respect to the BIT operator. For example, with MASK given
TBLTRN: Language Specification Manual Page 17
An Introduction to the TBLTRN Language
the last definition above, the statement
2DUP MASK 1 2 3 4
would assemble the following table entries.
0
1002
0
196
0
1002
0
196
Similarly, the statements
TWO=2,FOUR=4,SIX=6,EIGHT=8,TEN=10
TEMPLATE=MSK ARG.ARG.ARG 2WRD ARG. .ARG
2DUP TEMPLATE TWO FOUR SIX EIGHT TEN
would assemble the following table entries
2
4
6
8
10
2
4
6
8
10
Individual table entries can be assigned symbolic names
(address labels). Any undefined symbol not in the range of
an operator, in a statement which defines a table entry
prior to the actual specification of the contents of that
table entry (either at the start of the statement or after
increment of the table entry origin as specified by a
packing pattern), is taken as the address label of the table
entry origin offset by 1 less than the word count if such
appears before the label. For example, in the following
statements, the symbols ADDRESS1, ADDRESS2 etc. are address
labels.
ADDRESS1 3
MASK=MSK ARG.ARG.
ADDRESS2 MASK ADDRESS3 2 ADDRESS4 1 ADDRESS5
The above example assembles the table entries
TBLTRN: Language Specification Manual Page 18
An Introduction to the TBLTRN Language
3
2
1
0
The terminal zero entry in the above example results from
the performance of the last origin increment specified by
the packing pattern MASK. Performance of this origin
increment is forced by the appearance of the address label
ADDRESS5.
The origin of the table entry word count can always be
referenced by the . (single period) operator. The following
examples illustrate how address labels are applied to
multiple precision entries. The LOC operator precedes an
address label to be used as a constant having as its value
the location within the table of the named entry. The BIT
operator similarly precedes the address label of the entry
in which is to be turned on (set to 1) the bit (binary
digit) specified either by a decimal integer prefix of the
BIT operator or by a a constant or parenthetical expression
which immediately follows the BIT operator.
3WRD 5BIT.
turns on the 5th bit from the right in the 2nd table entry
above the current table entry origin. If this appears as
the only contents of the statement, 3 words would be
assembled with the values 0, 0 and 16 respectively.
3WRD 5BIT ADDRESS
turns on the 5th bit from the right in the 2nd table entry
above the table entry named ADDRESS. If the table entry
named ADDRESS is currently unknown, at least 3 table entries
will be assembled when it is later located, with the 5th bit
from the right turned on in the upper of these three. It is
usually advisable to allocate sufficient room to contain the
range of bits turned on through use of a construction such
as ADDRESS 3WRD NUL for such a multiple entry bit
destination.
3WRD LOC.
or
3WRD.
assembles into the 2nd table entry above the current table
entry origin the address (relative to the start of the
table) of the 2nd table entry above the current table entry
origin.
TBLTRN: Language Specification Manual Page 19
An Introduction to the TBLTRN Language
3WRD LOC ADDRESS
assembles into the 2nd table entry above the current table
entry origin the address of the table entry named ADDRESS.
3WRD ADDRESS
assigns the address label ADDRESS to the 2nd table entry
above the current table entry origin. The statement
containing the construction 3WRD ADDRESS will assemble at
least 2 entries above the table entry origin, and these will
contain zeroes if nothing else is deposited into them.
3WRD ADDRESS 2WRD 5BIT ADDRESS
turns on the 5th bit in the first table entry above the
table entry named ADDRESS, itself the 2nd table entry above
the current table entry origin. If this appears as the only
contents of the statement, 4 words would be assembled with
the values 0, 0, 0 and 16 respectively.
ADDRESS1 2WRD ADDRESS2 2BIT ADDRESS2 2WRD 1BIT.
assigns the address label ADDRESS1 to the current table
entry origin and the address label ADDRESS2 to the word
above the current table entry origin. The values which are
assembled for these two table entries are 0 and 3 (bits 1
and 2) respectively.
A few final notes
1. The packing pattern, if any, selected by the TON
operator and the byte size in effect prior to a symbol
definition are restored after the definition.
2. No packing pattern is assumed to be in effect at the
start of a symbol definition even if the TON operator
has placed one in effect for the statements which define
table entries.
3. The byte size in effect after the previous statement is
assumed to be in effect at the start of a symbol
definition and is restored after the definition.
4. The byte size in effect prior to the use of a packing
pattern is restored after the final argument of the
pattern. Sign and shift do not survive.
5. Any packing pattern appearing outside a symbol
definition while the TON operator has selected a packing
pattern will itself become the packing pattern selected
by the TON operator.
TBLTRN: Language Specification Manual Page 20
Symbol and Statement Termination
Symbol and Statement Termination
------ --- --------- -----------
Statement length is independent of line length. Several
statements can be packed within a line, or a single
statement can extend across several lines, some of which can
contain merely comments. Continuation of a statement across
a line break is indicated by the ,, (double comma) operator
at the start of the continuation line, or by the ,,, (triple
comma) operator at the right end (exclusive of comment if
any) of the line being continued, or by the use of the
triple comma operator at the start of an intervening comment
line. Over-specification of continuation causes no harm. A
statement is terminated by the , (single comma) operator, by
the END operator to terminate the range of an IF class
operator, or by the subsequent appearance of a statement
line not tied to the present line by the double or triple
comma operators. The BAC (Begin Automatic Continuation)
operator can make the continuation of statements across the
ends of lines be automatic. This automatic continuation is
terminated by the EAC (End Automatic Continuation) operator.
The maximum length of a single input line is 80 characters.
A warning is output on the teletype if the statement
exclusive of comment extends beyond 75 characters. When
text replacement is used, the warning is instead issued if
at any time more than 160 characters remain unprocessed.
Overflow is discarded in either case.
Symbols must be separated by blanks unless they are formed
from characters of different classes (see next section).
The 8 characters ( ) + - . , ' = are each in a separate
class. The symbol ,,,, (4 commas) is not equivalent to
, ,,, (single comma, blank and 3 commas) and is undefined
unless the programmer specifies otherwise. Such a symbol
can, however, be defined as either a constant or an address
label or both, since there is no correspondence between
character class and function except for the blank and dollar
sign characters and except for the asterisk character with
decimal integer prefix. Although the character classes of
the initially defined symbols were chosen so as to free the
programmer from the use of blanks where he would not
normally use them in the writing of English text, such a
convenience need not be maintained.
Character Classes
--------- -------
Symbols in TBLTRN statements are delimited by a change of
character class. The grouping of characters, except for the
blank or space character, into these classes is completely
under program control. However, numerals removed from the
TBLTRN: Language Specification Manual Page 21
Character Classes
large unassigned character class cannot be used to form
integers nor to form decimal integer prefixes or suffixes.
Up to 50 characters can be assigned character classes.
Included in this count are ( ) + - . , ' = * $ and the space
or blank character, but not the numerals. This limit is
imposed by the length of the 2 storage arrays needed to
store the characters and associated class numbers.
Attempted overflow is detected by the portion of the TBLSTR
routine which processes the ACC operator.
The types of symbols based on the initial character classes
are as follow.
Type 1. A grouping of the non-symbol forming characters
blank and dollar sign $ which are in separate
character classes. The dollar sign is a break
character which prints on the teletype the value of
the symbol or table entries currently being
defined.
Type 2. A symbol formed from one of the punctuation marks (
) . , ' = + and -. Each of these characters is
initially within a separate character class. For
example, the statement --=- can be written without
embedded blanks to define the symbol -- (double
minus) as identical to the symbol - (single minus).
Type 3. A symbol formed from one or more of the remaining
characters which are not within any particular
character class and so, by default, form a single
large class. These include the letters A through Z
and numerals 0 through 9 and punctuation marks *
and / as well as any other characters not assigned
to specific classes.
Subtype 3A. A symbol which is not an integer and
does not begin with a decimal integer prefix. It
should be noted that, when the radix is greater
that 10, integers can be formed from the numerals 0
through 9 and the alphabetic letters A through a
maximum of F for hexadecimal.
Subtype 3B. An integer formed from the numerals 0
through 9, and, if the prevailing radix is greater
than decimal 10, from the letters A through a
maximum of F for hexadecimal. Symbols constructed
from these numeric characters are integers and do
not require storage in the symbol dictionary. A
numeral equal or greater than the radix is not
allowed in a symbol formed entirely of the
characters 0 through 9. For example, the number 80
is a radix violation if the radix is 8 (octal).
TBLTRN: Language Specification Manual Page 22
Character Classes
Subtype 3C. A symbol with a decimal integer
prefix. The symbol must contain at least 1
character not in the range 0 through 9 and, if the
radix is greater than 10, not in the range A
through a maximum of F for hexadecimal. The symbol
is not of this subtype if the symbol following the
decimal integer prefix begins with a character in
the character class originally occupied by the
asterisk. The value of the prefix cannot exceed
100000. See section titled "Parenthetical
Expressions" for the entry of higher or negative
values.
The stem (the portion of the symbol excluding the
prefix) will be identified if it is currently
defined as an operator which can accept a decimal
integer prefix, and if the entire symbol including
the prefix is not itself currently defined. It is
possible for selected values of the prefix to have
altered meanings. For example, the statements
L=LFT,XSY LFT
5LFT=10L,10LFT=5L
LFT=L,XSY L
or, if instead a definition of the form A=.''/B/
(where B can bear a decimal integer prefix) is
used, which assigns to A the the meaning of B in
the original symbol dictionary regardless of the
current meaning of B, then the statements
XSY LFT
5LFT=.''/10LFT/
10LFT=.''/ 5LFT/
LFT=.''/ LFT/
would interchange the meanings of the prefixes 5 and
10 when used with the LFT operator, without
modifying the meanings of the other prefixes.
Subtype 3D. A single appearance of the asterisk
character (or of any other character which has been
placed into the character class originally occupied
by the asterisk) with a decimal integer prefix.
Such symbols are produced by the pre-execution
assembly of user defined functions and are
interpreted without referencing the symbol
dictionary as the operators having the identifier
codes appearing as the decimal integer prefixes.
Successive symbols of this subtype do not require
separating blanks between them since the single
asterisk (or other character in its class)
terminates the symbol regardless of the class of the
TBLTRN: Language Specification Manual Page 23
Character Classes
following character. Although the single asterisk
does not appear as an operator within the symbol
dictionary, nothing prevents its being defined,
providing it is not defined as equal to some other
operator which could itself take a decimal integer
prefix, then expected to be taken as that operator
if used with a decimal integer prefix.
Each of the following character strings contains 4 symbols.
THIS IS A SAMPLE
.10TRX+20
.+10TRX 20
---=-777
As can be seen from the above examples, blanks are necessary
only when the character classes of adjacent symbols are the
same. Extra blanks, however, cause no harm and in some
cases make for easier reading.
It is convenient to separate words which are grouped to form
single symbols by the / character or, if the first word is
not an integer, by the * character which is then of the same
character class as the numerals and letters. Symbols can be
of any desired length, limited only by the 80 character line
width. The following examples illustrate the legibility
obtained through the use of * and / as separation
characters.
THIS*IS*ONE*SYMBOL THIS/IS/ONE/SYMBOL
IF*2*GROUPS*MEET IF/2/GROUPS/MEET
ACID*SENSITIVE*GROUP ACID/SENSITIVE/GROUP
Symbol Types
------ -----
TBLTRN symbols can be operators, address labels, both
operators and address labels, or be undefined. The primary
operator classifications are constants, packing patterns,
text strings, and programmed operators. The programmed
operators are the supplied TBLTRN symbols and are described
individually in a later section. Constants, packing
patterns and text strings are defined within the input
table.
Constants are symbols which have only the property of value.
They can be either single or multiple precision. The
definition of a multiple precision constant contains
directions for offset from the table entry origin. For
example, the statements
TBLTRN: Language Specification Manual Page 24
Symbol types
CONSTANT1=123
CONSTANT2=2WRD 123
define the symbols CONSTANT1 and CONSTANT2 as single
entry constants with the value decimal 123, but
CONSTANT2 is multiple precision. When used without
additional offset in a statement which defines table
entries, CONSTANT1 assembles into the current table
entry orgin, but CONSTANT2 would assemble into the 1st
table entry beyond. The statement
CONSTANT1 CONSTANT2
would then assemble 2 entries, each containing the value
123. Multiple precision constants can, however, specify
multiple entries. For example, the definition
CONSTANT3=CONSTANT1 CONSTANT2
or
CONSTANT3=123 2WRD 123
or
CONSTANT3=MSK ARG 2WRD ARG
CONSTANT3=CONSTANT3 123 123
specifies that CONSTANT3 is a multiple precision,
multiple entry constant which assembles the value 123
into both the table entry origin and the next entry
beyond when used without additional offset in a
statement which defines table entries.
Packing patterns are templates which specify the relative
destination and manner in which constants are to be
packed. The packing pattern is employed by stating its
name followed by the constants, its arguments, to which
it is to apply. If more than one constant is to be a
single argument, these are enclosed within parentheses.
For example, some future address minus the current
address, a relative separation within the table, could
be packed as a single argument even though it involves 2
constants and, in this case, a change of sign. The
packing pattern is defined by appending to the
definition of a currently defined packing pattern the
definitions of other packing patterns, and/or new
argument specifications each terminated by the ARG
operator, and/or origin increment specifications
indicated by the . (single period) operator. The null
packing pattern MSK is provided to initiate this
process. As an example, the packing pattern defined by
the statement
TBLTRN: Language Specification Manual Page 25
Symbol types
PATTERN=MSK+0LFT 1WRD ARG IOR 3LFT 1WRD ARG
or
PATTERN=MSK IOR 3LFT 1WRD ARG
PATTERN=MSK+0LFT 1WRD ARG PATTERN
could be used in a statement of the form
PATTERN(LOC ADRS-LOC.)5
to pack the difference between the address of the table
entry named ADRS and the current address into the first
(non-shifted) byte of the current table entry origin,
and the value 5 into the fourth byte (3 byte shifted) of
the current table entry orgin. The byte sizes which the
packing pattern uses are those current when the packing
of its arguments was defined, regardless of the byte
size in effect when the packing pattern happens to be
used. An argument of a packing pattern which does not
contain an address and which remains fixed in value can
be specified in the packing pattern definition following
the ARG operator which has specified its packing. Such
an automatic argument must be enclosed within
parentheses if it consists of more than a single integer
or constant. See the description of the ARG operator
for examples of automatic argument definitions.
Text strings are groups of characters following on the
current line either of the operators ' or ''. The
string starts following the first non-blank charcter
after the ' or '' operator and continues through the end
of the current line or up to the next appearance of the
delimiter character. Except for specifying the ends of
the string, the delimiter character is ignored. Text
strings are used for the introduction of character
information which is not to be scanned for recognizable
symbols. A typical example of the use of a text string
is the statement
ACC'/+-/
which specifies that the plus sign is to be placed into
the character class of the minus sign. Operators can
also be defined as text strings. The statement
LOC*OF*A='/LOC A/
defines the symbol LOC*OF*A as an operator which will
replace itself by the text LOC A wherever encountered
except within the range of a TEL or XSY operator or
within the range of an unfulfilled IF or Do-If class
operator. It is entirely possible for the character
TBLTRN: Language Specification Manual Page 26
Symbol types
delimiting a text string to be an apostrophe as long as
this is separated by at least one blank from the leading
' or '' operator. Also, a text string can contain a
text string. Examples of quite complicated text strings
are given in the later section named "User Defined
Functions."
The insertion of the text by which an operator replaces
itself can be deferred until a given number of symbols
or statements have been interpreted if the text string
is preceded in the definition of the operator by a
constant or parenthetical expression. The argument
count is a number of symbols if zero or positive, or a
number of statements if negative. Any insertion made at
the end of a statement extends, rather than closes, that
statement. The insertion is made at the end of the
current statement if the argument count is -1.
Statements within the range of an unfulfilled IF class
operator are not counted. Another text replacement
operator cannot direct a deferred insertion while
symbols or statements are being counted to determine the
point at which text is to be inserted by a first text
replacement operator. A text replacement operator for
which the insertion is not deferred can appear within
such a range but is not itself included within the
symbol count. Similarly not counted are transparent
symbols and those symbols within the range of an
unfulfilled (false answer) Do-If class operator. A text
string together with its leading ' or '' operator is
counted as a single symbol. A symbol can be defined as
a sequence of deferred text strings. An insertion
deferred for a given number of symbols is not performed
at all if the current statement is terminated prior to
the interpretation of the desired number of symbols.
Similarly cancelled are any additional unperformed
insertions directed by the operator which specified the
failing symbol count.
Address labels are table entry names and have as values the
locations of the named entries within the table. These
are treated as constants if preceded by the LOC
operator. (The LOC operator cannot be used with a
following address label either in a symbol definition
nor as the value following an operator which could have
taken a decimal integer prefix, but did not. This
restriction is necessary to prevent the tremendous
amount of temporary storage which might be made
necessary by the use of an undefined label within such a
symbol or value definition. It should be noted,
however, that a symbol can be defined as a text string
containing these symbols merely as character
information.) Address labels specify the destination
when used after the BIT operator. A symbol can
TBLTRN: Language Specification Manual Page 27
Symbol types
concurrently be both an operator and an address label,
but definition of a symbol as a text string always takes
precedence over possible definition as an address label.
A symbol being defined as an address label can already
be an address label. If the symbol is an operator other
than a text string, in order to be assigned as a label,
it must follow one of the operators ADR, LOA or HIA.
These operators specify that the symbol is the label of
the current table entry origin, of the lowest table
entry assembled by the current statement, and of the
highest table entry so far assembled by the current
statement respectively. Any of these operators can be
offset to refer to higher table entries if preceded by
the WRD operator either with decimal integer prefix or
following parenthetical expression. No offset is
indicated by 1WRD and is the default value. The offset
specified by the WRD operator prior to the appearance of
the address label does not apply to following constants
nor to additional following address labels. If the
symbol being assigned as an address label is not an
operator, then use of the ADR operator is optional in
the assignment of an address label either prior to the
specification in the statement of the contents of a
table entry or immediately after a packing pattern has
specified an increment of the table entry origin. It
should be noted that under these conditions a misspelled
operator name can be taken as an address label and, if
the statement in which it appears has not assembled a
table entry, force the assembly of a zero table entry.
The table entry associated with an address label often
is unknown when the label is referenced. The default
sign should never be used to pack an unknown address
label into a byte containing other contents, since the
specified action can be performed only when the label
has been assigned. Thus, a statement of the form
LOC ADRS+1
where ADRS is an unknown address, effectively amounts to
the statement (providing the default sign is IOR)
1 IOR LOC ADRS
and should instead have been written as
+LOC ADRS+1
or
1+LOC ADRS
TBLTRN: Language Specification Manual Page 28
Symbol types
Even a statement of the form
LOC ADRS+LOC ADRS
gives unexpected results since an initial reference of
an unknown address within a statement actually is
processed last in order to allow TBLTRN to determine if
the table entry will contain anything else.
Radices for Integer Evaluation
------- --- ------- ----------
The default radix for table entry statements is independent
from that used in symbol definitions. Both of these radices
are set to 10 at the start of each table. All integers are
therefore assumed to be decimal unless these radices have
been altered temporarily by the DEC (DECimal) or OCT (OCTal)
operators or permanently by the TRX (Table RadiX) or SRX
(Symbol RadiX) operators. None of these radix modification
operators alter the interpretation of the integer prefixes
allowed for some operators. The DEC and OCT operators are
used in either table entry or symbol definitions to specify
that the following integer is to be interpreted as decimal
and octal respectively, regardless of the value of the
default radix. Necessary packing size, sign and shift
information can precede these operators or can appear
between these operators and the integer to which they apply.
The following integers are equivalent
8SIZ 1LFT OCT 10
8SIZ OCT 1LFT 10
1LFT 8SIZ OCT 10
1LFT OCT 8SIZ 10
OCT 8SIZ 1LFT 10
OCT 1LFT 8SIZ 10
and all equal decimal 64 (octal 100). Constructions of the
sort
TABLERADIX16=16TRX
SYMBOLRADIX16=16SRX
or
I16=DEC 16
TABLERADIX16=TRX I16
SYMBOLRADIX16=SRX 16
are allowed, but the use of the radix commands within the
definition results in no permanent alteration of the
prevailing default radices. Either of the symbols
TBLTRN: Language Specification Manual Page 29
Radices for Integer Evaluation
TABLERADIX16 or SYMBOLRADIX16 could be used, however,
outside a symbol definition to change the corresponding
radix, and SYMBOLRADIX16 could be used within a symbol
definition to temporarily alter the radix for the remainder
of the definition. Some care must, of course, be exercised
if either radix is set greater than decimal 10. For
example, the statements
10TRX 16SRX,ABC=ABC
or
10TRX,ABC=16SRX ABC
would define the symbol ABC as hexadecimal ABC or 10*16*16 +
11*16 + 12. Similarly, the statements
10TRX 16SRX,B=BIT,ABC=10B,BCD=10BIT
would define symbol ABC as hexadecimal 10B but BCD as the
operator 10BIT which could then be used in other statements
to specify that the 10th bit in a particular table entry be
turned on. Under a default symbol definition radix of
decimal 10, ABC would have been given the latter definition
since B and BIT have here been defined as identical
operators.
Parenthetical Expressions
------------- -----------
Parenthetical expressions in TBLTRN input can be of either
of the following 2 types.
1. Possibly multiple precision expressions. Such an
expression can have several values, each of different
precision. Integers are considered to be single
precision constants. The values of a multiple precision
constant are used to establish values having
corresponding precisions for the expression. Possibly
multiple precision expressions are used for the
following purposes.
A. The entering of several constants into a table entry
or constant definition with a single sign and byte
and word specification.
B. The entering of several constants as a single
automatic argument within the definition of a
packing pattern.
C. The use of several constants in the definition of a
text replacement operator to establish the number of
symbols or statements for which the insertion of the
TBLTRN: Language Specification Manual Page 30
Parenthetical Expressions
text is to be deferred. Although this value is
accumulated as a possibly multiple precision
expression, only the resulting low precision (word
1) value is used.
2. Single precision expressions. Such an expression has
only a single value. The values of integers within the
expression are always used in determining the value of
the expression. Only the values of words having the
precision selected by the PFX operator are used from
symbols defined as constants. The PFX operator with
integer prefix, or a symbol defined as the combination
of PFX operator and value, can appear either before or
within the expression. Single precision expressions are
used for the following purposes.
A. The use of several constants in establishing the
value of an operator which could have been used
instead with a decimal integer prefix.
B. The use of several constants in establishing the
value to be tested by the Do-If class operators DIN,
DIL, DILE, DIE, DIGE, and DIG, and by the IF class
operators IFN, IFL, IFLE, IFE, IFGE, and IFG.
These parenthetical expressions all have the common
structure
OSR(OSR CONSTANT OSR CONSTANT OSR CONSTANT)
in which OSR indicates optional sign and/or radix
specifications in any order, and CONSTANT is either an
integer or a symbol defined as a constant (or the operator
LOC followed by an address label if the expression is used
to define the contents of a table entry only). The OSR
CONSTANT combination can appear within the parenthetical
expression any number of times. However, if only a single
constant is used, then the parentheses are optional in all
circumstances in which a expression can appear.
A sign specified prior to the left parenthesis applies to
any unsigned constant within the expression. Within the
expression, a sign before a constant temporarily replaces
the sign, if any, established prior to the left parenthesis
and applies only to the following constant. The only
instance in which a parenthetical expression can appear
within another is the specification of the value of an
operator which could have taken a decimal integer prefix
inside a parenthetical expression defining table entries, a
constant, an automatic argument of a packing pattern, or the
argument count of a deferred text insertion. Due to the
limitations of the contents of a parenthetical expression,
the operator involved would have to be either TRX or SRX in
expressions similar to (assuming that A and RADIX are
TBLTRN: Language Specification Manual Page 31
Parenthetical Expressions
constants and that RADIX happens to be 2 greater than the
desired radix)
IOR 2WRD 3LFT(A TRX(RADIX-2)64)
or
CONSTANT=2WRD 3LFT(A SRX(RADIX-2)64)
or
MASK=MSK IOR 2WRD 3LFT ARG(A SRX(RADIX-2)64)
It should be noted that the )) operator (double right
parenthesis without internal blanks) is not equivalent to a
double appearance of the ) operator and cannot be used to
terminate a parenthetical expression except when the
parenthetical expression is a packing pattern argument and
the )) is meant to both close the argument and advance the
argument list of the packing pattern to the next origin
increment if any.
Entering Multiple Constants into a Single Byte
-------- -------- --------- ---- - ------ ----
All items enclosed within parentheses in a table entry or
constant definition are entered into the table entry or the
constant being defined using the shift and sign in effect
when the left parenthesis is encountered. If within the
range of a packing pattern, such a parenthetical or constant
shift expression is taken as a single argument. Integers
within the constant shift expression are interpreted under
the default radix unless preceded by the OCT or DEC
operators. The SRX or TRX operators (whichever is
appropriate) can similarly be used either with decimal
integer prefix or following constant or following
parenthetical expression within the constant shift
expression. The sign, but not the shift or word count, can
be temporarily modified for a single constant within the
constant shift expression, but is restored to its original
value after the constant has been processed. As an example,
the sum of A and B could be entered into the byte and entry
specified for the first argument of the packing pattern
MORE, and the sum of C and D into those specified for the
second argument by the statement
MORE (A+B)(C+D)
It should be noted that neither A and B nor C and D are
summed prior to being inserted into the table entry being
defined. The parenthetical expression merely defines the
TBLTRN: Language Specification Manual Page 32
Parenthetical Expressions
byte and word into which A, B, C and D are packed, and the
signs used during this packing.
A right parenthesis following a right parenthesis or
unmatched by a preceding left parenthesis causes the
remaining unfulfilled argument specifications of the packing
pattern currently in effect to be ignored up to the packing
pattern's next origin increment specification. The effect
of the packing pattern within the current statement is
terminated if the packing pattern has no unperformed origin
increment specification. A double right parenthesis,
written without internal blanks at the end of the constant
shift expression, is here equivalent to 2 single right
parentheses. (However, a double right parenthesis without
internal blanks cannot be used to terminate both a constant
shift expression and a parenthetical expression following a
SRX or TRX operator within the constant shift expression.)
For example, if additional items were to be specified beyond
the argument list, the argument list can be terminated, or
advanced to the next origin increment specification if any,
by the double right parentheses operator )) as in the
statement
MORE (A+B)(C+D)) 100SIZ 2LFT (E+F)
A double left parentheses, written either with or without
blanks, is always equivalent to a single left parenthesis
(both have the same operator identifier code), so this
statement could also be written
MORE ((A+B)(C+D)) 100SIZ 2LFT (E+F)
A null argument of a packing pattern can be indicated by the
operator NUL, by the () operator pair or by the sequence of
3 operators (NUL).
Using Multiple Constants Instead of an Integer Prefix
----- -------- --------- ------- -- -- ------- ------
Those operators which require a value which can be
established by a decimal integer prefix can instead be used
with a following, possibly signed integer or constant, or by
a group of possibly signed constants enclosed within
parentheses. If no sign is given, the sign used is the
default sign for the current byte size. The sign, if any,
established prior to the operator is not used and remains
unchanged following the specification of the value
associated with the operator. For example, the statement
-LFT(A+2)10
TBLTRN: Language Specification Manual Page 33
Parenthetical Expressions
assembles a table entry containing the result of left
shifting the integer 10 the sum of A and 2 bytes, then
subtracting the shifted result from zero. A sign, if any,
established between the operator and the left parenthesis
preceding a group of constants will apply to any of the
constants which are unsigned. For example, the statement
-LFT+(A 2)10
produces the same result as the previous example, regardless
of the default sign for the current byte size, even though
the integer 2 is unsigned. Integers following the operator
are interpreted under the current radix, not necessarily
decimal. The radix can be temporarily changed at any point
by the OCT or DEC operators, or permanently by the TRX or
SRX operators (whichever is appropriate) used with decimal
integer prefix only.
The value of a multiple precision constant following an
operator which could have taken a decimal integer prefix,
but did not, normally is the value of its highest precision
word. The value can, however, be of a word of precision
selected by the PFX operator if this latter operator is used
with a positive value. The default selection of the value
of the highest precision word can be regained by use of the
PFX operator with zero value. The value of the constant
following an operator which could have taken a decimal
integer prefix, but did not, can instead be its precision if
the PFX operator is issued with a negative value. Such
precision selection does not apply to integers.
Stack Construction and Use
----- ------------ --- ---
TBLTRN has operators for the construction and use of both
value and name stacks. Value stacks are merely multiple
precision constants from which the values of words of
selected precision can be accessed by those operators which
could be used with decimal integer prefixes. Name stacks
are families of operators having a common name stem with a
distinguishing decimal integer suffix.
The value stack A could be defined either within an =
definition, or by the stack construction operators PSH and
STK. These latter 2 operators differ only with respect to
the destination precision. STK stacks the new word onto the
top of the stack with a precision one greater than that of
the current stack. PSH pushes the new word into the
precision one word of the stack, displacing the previous
contents of the stack upward. Either STK or PSH can be used
to place a word into word one of an undefined stack. For
TBLTRN: Language Specification Manual Page 34
Stack Construction and Use
example, either of the statements
PSH 444 A PSH 333 A PSH 222 A PSH 111 A
or
STK 111 A STK 222 A STK 333 A STK 444 A
would construct a stack with the value 444 in the high
precision 4th word and the value 111 in the low precision
1st word. An identical stack would be produced by any of
the following sequences of = definitions.
A=2WRD A 444
A=2WRD A 333
A=2WRD A 222
A=2WRD A 111
or
A=444 2WRD A
A=333 2WRD A
A=222 2WRD A
A=111 2WRD A
or
A=A PFX-1 WRD(A+1)111
A=A PFX-1 WRD(A+1)222
A=A PFX-1 WRD(A+1)333
A=A PFX-1 WRD(A+1)444
or
A=PFX-1 WRD(A+1)111 A
A=PFX-1 WRD(A+1)222 A
A=PFX-1 WRD(A+1)333 A
A=PFX-1 WRD(A+1)444 A
The above examples work correctly even when A is undefined
since, within an = definition, the symbol being defined, if
currently undefined, is taken as a constant of zero value
and without offset even if an offset has been supplied by a
packing pattern or by the WRD operator. Statements such as
A=A
or
A=5WRD A
would, if A was previously undefined or merely an address
label, define A as a single precision constant with the
TBLTRN: Language Specification Manual Page 35
Stack Construction and Use
value zero. When the symbol being defined is currently
undefined or is merely an address label, and appears
following an operator which could have taken a decimal
integer prefix, but did not, the value of the symbol is
taken as zero even if the PFX-1 operator has temporarily
selected that the value of a non-integer constant be its
precision. Within an = definition, use of any symbol which
is undefined or merely an address label, other than the
symbol being defined, is considered to be a non-fatal error.
Similarly, outside an = definition, a symbol which is
undefined or merely an address label, when used after an
operator which could have taken a decimal integer prefix,
but did not, is assumed to have value and precision equal to
zero.
Value stacks can be used as constants in the assembly of
table entries or in the definitions of other constants or of
the automatic arguments of packing patterns. Under the
default precision selection (identical with that selected by
the 0PFX operator), the value of a constant or value stack
following an operator which could have taken a decimal
integer prefix, but did not, is the value of the highest
precision word of the constant. If the PFX operator has
been issued with positive value, the value of such a
constant is the value of the word of the precision selected
by the PFX operator if a word of the selected precision has
been defined, or zero otherwise.
The highest precision word of a value stack is the initial
value placed into the stack if the PSH operator was used, or
the most recent value if the STK operator was used. The POP
operator removes the highest precision word from the stack
and so reveals the values in the order in which they were
inserted by the PSH operator. Applying the POP operator to
a single precision stack removes the stack symbol from the
symbol dictionary. The ROT operator reveals the values in
the same order, but pushes the value stripped from the high
precision word into the low precision word so that the stack
maintains constant precision and is not destroyed.
Name stacks are referenced by the NST (Numeric Symbol Text)
operator. This operator replaces itself in all
environments, except within the range of an unfulfilled IF
or Do-If operator, by a symbol name consisting of an
alphabetic stem established by the NSN (Numeric Symbol Name)
operator with a decimal integer suffix set by the NSV
(Numeric Symbol Value) operator. Stacks constructed through
the use of the NST operator can consist of either address
labels or other operators. Several examples of such stacks
are given in the section titled ''User Defined Functions.''
TBLTRN: Language Specification Manual Page 36
User Interaction with Assemblies
User Interaction with Assemblies
---- ----------- ---- ----------
The programmer can obtain teletype control of an assembly at
any preselected statement break by use of the TTY operator
outside a symbol definition in the input text. If the
primary input is not itself the teletype, the translator
will write the message
CONTROL TO TELETYPE
on the teletype, swap the uninterpreted portions of the
teletype and input file text buffers, and transfer control
to the teletype. All statements issued by the programmer
(including those following on the same line either his
previous issuance of the TTY operator or closure of a
definition requested by the == operator if any) will be
inserted into the assembly until the next appearance of the
TTY operator outside a symbol definition. The only
variation in the format for teletype input is the acceptance
of 120 character lines (such as might be desired if the
teletype has a wide carriage) instead of the 80 character
lines read from the input file.
The == operator can be used to force the programmer to
define selected symbols without relinquishing control to
him. Messages can be transmitted to the programmer by the
'' operator which treats all characters to its right within
a pair of delimiter characters as a non-executable comment
and causes these to be written on the teletype. The text
line
AA=AA+1,''/AA HAS BEEN INCREMENTED/
would add 1 to the present value of AA, then type the
message
AA HAS BEEN INCREMENTED
on the teletype.
In the above example, the comma separating AA+1 and the text
string to be written on the teletype is necessary since
otherwise AA would become a text replacement operator
specifying the insertion of the text string after AA+1
symbols (or statements if this value is negative).
A symbol or statement count, which is being performed to
determine the point at which to make a deferred text
insertion, will include either the == or TTY operators and
will continue at the start of the text from the newly
selected input device. If the symbol or statement count has
not yet begun due to the == or TTY operators being within
TBLTRN: Language Specification Manual Page 37
User Interaction with Assemblies
text already inserted by the same use of the operator which
has specified the deferred text insertion, then the text
read from the device being selected will also be taken as
part of the previously inserted text and the testing for the
point at which the insertion is to be made will be resumed
only when control is returned to the device deselected by
the == or TTY operator.
Conditional Assembly Capability
----------- -------- ----------
The IF and Do-If class operators are provided to allow the
programmer to delete the execution of portions of the input
table during an assembly or to abort recursive functions.
IF class operators can only appear at the start of a
statement (or as a separate statement) and must be followed
immediately by a constant or expression the value of which,
or by a symbol the identity of which is tested to determine
whether the following statements are to be executed or
ignored. The statements through the matching END operator
are executed only if the following symbol or parenthetical
expression fulfills the requirement of the IF class
operator. Transparent or null text replacement operators
are ignored and so cannot be tested. Additional IF class
operator tests and their matching END operators can occur in
the range of the statements being ignored, but, of course,
no action is taken for these except for the adjustment of
the IF versus END count used in detecting the END operator
which closes the range of the original IF class operator.
In order that the IF class operators be treated correctly
when used within the range of other IF class operators, it
is important that they be preceded by a statement break (a
comma or END operator or, providing the BAC operator has not
been issued, the start of a new line not itself preceded on
the same line by the ,, operator or on the previous
non-comment line or on an intervening comment line by the
,,, operator). The IF class operators and the conditions
tested are as follow.
Symbol Condition
IFA is symbol an address
IFD is symbol defined
IFE is value of expression equal zero
IFG is value of expression greater than zero
TBLTRN: Language Specification Manual Page 38
Conditional Assembly Capability
IFGE is value of expression greater than or equal zero
IFL is value of expression less than zero
IFLE is value of expression less than or equal zero
IFN is value of expression not equal zero
IFNA is symbol not an address
IFNO is symbol not an operator other than an address
IFO is symbol an operator other than an address
IFU is symbol undefined
An example of the use of the IF class operators follows.
''+NON-ZERO TO INCREMENT AA BB CC+
SWITCH==
IFN SWITCH AA=AA+1
BB=BB+1
CC=CC+1
''/AA BB AND CC HAVE BEEN INCREMENTED/
END
The above sequence of statements first types the message
NON-ZERO TO INCREMENT AA BB CC
on the teletype. The == operator then requests the user to
define the symbol SWITCH on the teletype. The Statements
AA=AA+1
BB=BB+1
CC=CC+1
''/AA BB AND CC HAVE BEEN INCREMENTED/
are executed only if the value of SWITCH is non-zero.
The range of the Do-If operators is indicated instead as a
number of symbols within the current statement, rather than
by a particular statement terminator. This number of
symbols is specified as a decimal integer prefix or by a
following constant or parenthetical expression. The range
of the Do-If class operator is terminated at the end of the
statement even if the number of symbols indicated has not
been encountered. Within the range of an unfulfilled (false
answer) Do-If class operator, a text string including its
delimiter characters and the initiating ' or '' operators is
counted as a single symbol. An operator defined as a text
string similarly is counted as a single symbol and is not
replaced by its equivalent text. Operators defined as null
TBLTRN: Language Specification Manual Page 39
Conditional Assembly Capability
text strings (transparent symbols) are not counted. The
conditions tested by the IF and Do-If classes of operators
are the same. The following sequences of statements use
Do-If class operators to perform the same task as given as
an example above.
''+NON-ZERO TO INCREMENT AA BB CC+
SWITCH==,7DIN SWITCH 1INC AA 1INC BB 1INC CC
,,''/AA BB AND CC HAVE BEEN INCREMENTED/
or
''+SWITCH MUST BE 27 TO INCREMENT AA BB CC+
SWITCH==,DIE 8(27-SWITCH)INC 1 AA 1INC BB 1INC CC
,,''/AA BB AND CC HAVE BEEN INCREMENTED/
The comment and continuation symbols ... ,, and ,,, are, of
course, not included within the unfulfilled Do-If class
operator symbol count.
Data Statement Output
---- --------- ------
The assembled table entries are output as FORTRAN DATA
statements which must then be spliced into the program which
requires the table. The format of these DATA statements can
be defined in the table being assembled. The array name
used in the output DATA statements is taken as the text
string following the TTL operator. The character width of
the columns of data within the generated DATA statement is
specified as a decimal integer prefix of, or the constant or
parenthetical expression following, the CLM operator. This
prefix or following constant or parenthetical expression
will specify one of the following actions.
1. If the specified column width is zero, the DATA
statements are generated without internal blanks. The
output requires the minimum number of characters, but is
difficult to interpret visually.
2. If the specified column width is greater than zero but
is less than the maximum number of characters in any
single number, blanks will be inserted into the output
to form columns of sufficient width to contain the
output.
3. If the specified column width is equal to or greater
than the maximum number of characters in any single
number, blanks will be inserted into the output to form
columns of the specified width. Separating commas are
not included in this count.
TBLTRN: Language Specification Manual Page 40
Data Statement Output
The number of characters in the statement field of a single
output line is specified as a decimal integer prefix of, or
the constant or parenthetical expression following, the WID
operator. The value of this prefix or following constant or
parenthetical expression cannot be greater than 66 since, of
the 72 characters in a single line of a FORTRAN statement, 5
are in the statement number field and 1 is in the
continuation field.
For example, the specification statement
TTL'/ONE/52WID 7CLM
was used to generate the following DATA statements.
DIMENSION ONE (120),ONE001( 50),ONE051( 50),
1 ONE101( 20)
EQUIVALENCE (ONE001(1),ONE( 1)),
1 (ONE051(1),ONE( 51)),
2 (ONE101(1),ONE(101))
DATA ONE001/ 10, 10, 10, 10, 10,
1 1010, 1010, 1010, 1010, 1010,
2 101010, 101010, 101010, 101010, 101010,
3 20, 20, 20, 20, 20,
4 2020, 2020, 2020, 2020, 2020,
5 202020, 202020, 202020, 202020, 202020,
6 30, 30, 30, 30, 30,
7 3030, 3030, 3030, 3030, 3030,
8 303030, 303030, 303030, 303030, 303030,
9 40, 40, 40, 40, 40/
DATA ONE051/ 4040, 4040, 4040, 4040, 4040,
1 404040, 404040, 404040, 404040, 404040,
2 50, 50, 50, 50, 50,
3 5050, 5050, 5050, 5050, 5050,
4 505050, 505050, 505050, 505050, 505050,
5 60, 60, 60, 60, 60,
6 6060, 6060, 6060, 6060, 6060,
7 606060, 606060, 606060, 606060, 606060,
8 70, 70, 70, 70, 70,
9 7070, 7070, 7070, 7070, 7070/
DATA ONE101/ 707070, 707070, 707070, 707070, 707070,
1 80, 80, 80, 80, 80,
2 8080, 8080, 8080, 8080, 8080,
3 808080, 808080, 808080, 808080, 808080/
However, with the specification statement
TTL'/TWO/52WID 0CLM
the following output is instead obtained representing the
same table.
TBLTRN: Language Specification Manual Page 41
Data Statement Output
DIMENSION TWO(120),TWO001(99),TWO100(21)
EQUIVALENCE (TWO001(1),TWO(1)),(TWO100(1),TWO(100))
DATA TWO001/10,10,10,10,10,1010,1010,1010,1010,1010,
1101010,101010,101010,101010,101010,20,20,20,20,20,
22020,2020,2020,2020,2020,202020,202020,202020,
3202020,202020,30,30,30,30,30,3030,3030,3030,3030,
43030,303030,303030,303030,303030,303030,40,40,40,40,
540,4040,4040,4040,4040,4040,404040,404040,404040,
6404040,404040,50,50,50,50,50,5050,5050,5050,5050,
75050,505050,505050,505050,505050,505050,60,60,60,60,
860,6060,6060,6060,6060,6060,606060,606060,606060,
9606060,606060,70,70,70,70,70,7070,7070,7070,7070/
DATA TWO100/7070,707070,707070,707070,707070,707070,
180,80,80,80,80,8080,8080,8080,8080,8080,808080,
2808080,808080,808080,808080/
The routines DATAST and DAWORD can be replaced if FORTRAN
DATA statements are not the desired output. The routine
DANUMB, although part of the DATA statement generator
package, is used elsewhere by TBLTRN to print positive octal
numbers without the leading zeroes normally inserted by
PDP-10 FORTRAN, and to generate the decimal numbers
appearing both in the text by which NST replaces itself and
in pre-assembled code.
Construction of Test Tables
------------ -- ---- ------
The TBLTRN syntax is maintained through the use of test
tables which assemble to give predicted results. New test
tables are written when the syntax recognition facility is
extended or to insure against recurrence of corrected
errors. Test tables are designated by the appearance of the
TST operator either with decimal integer prefix or
immediately followed by a constant or parenthetical
expression which specifies the number of table entries to be
assembled by the test statements. The assembly of a test
table is normal except that the TTY and == operators swap
buffers but continue to read from the input file if the TST
operator has been issued. The expected values of the test
statements are specified by simple statements at the end of
the table so that the actual number of table entries which
should be assembled is twice that specified by the TST
operator. The upper section of the predicted length is
compared with the remaining lower section of the table, and
any differences are listed in both octal and decimal through
the next correct entry. For example, the table
10TST TTL'+TEST1+
1,2,6,3,4,5,7,8,9
1,2,3,4,5,6,7,8,9,10
TBLTRN: Language Specification Manual Page 42
Construction of Test Tables
BLK
would produce the following error messages on the listing
device.
TEST1
ARRAY DIFFERENCES
*****
1) 1 OCT 1 DEC 1
1) 2 OCT 2 DEC 2
1) 3 OCT 6 DEC 6
1) 4 OCT 3 DEC 3
*
2) 10 OCT 1 DEC 1
2) 11 OCT 2 DEC 2
2) 12 OCT 3 DEC 3
*****
1) 7 OCT 7 DEC 7
*
2) 15 OCT 6 DEC 6
2) 16 OCT 7 DEC 7
*****
2) 19 OCT 12 DEC 10
*****
A correctly assembled test table enters only its name into
the listing file.
User Defined Functions
---- ------- ---------
User defined functions are created by manipulation of the
input character stream as this is processed. This is
possible since symbols can be defined as text strings and
are replaced by these text strings whenever encountered
later except within the range of the XSY or TEL or
unfulfilled IF or Do-If class operators. Such a definition
is similar to that of any other symbol except that the text
string follows either the ' or '' operators and is enclosed
within delimiter characters.
The main restrictions imposed upon the writing of user
defined functions are that the length of a single text
string cannot normally exceed the length of a single input
line, usually 80 characters, minus delimiters, and that the
unprocessed text in a single line cannot exceed the maximum
buffer length or 160 characters after the text replacement.
Buffer overflow is discarded after informing the user of
this action. The message is, however, written at most only
once for a single line. Also, since functions can be
recursive (self-calling), some maximum number of text
TBLTRN: Language Specification Manual Page 43
User Defined Functions
replacements in a single input line must be taken as a limit
to abort infinite loops. This upper limit is initially set
at 1000 but is under program control (see description of LMT
operator). For example, the symbol definition
A='+A B+
would result in both buffer overflow and infinite loop which
must be terminated when the symbol A is later encountered.
In particular, the first 5 text replacements would produce
the following lines of unprocessed text.
A B
A B B
A B B B
A B B B B
A B B B B B
Sample Function F0:
------ -------- --
N0=0...COUNT OF TIMES F0 CALLED
F0='+NSN'/Z/NSV N0 LOA NST 1INC N0+
The above is an example of a simple user defined function
named F0 which assigns a unique label to the current table
entry origin and counts the number of times it has been
called. F0 employs the NST (Numeric Symbol Text) operator
which replaces itself by a symbol constructed of a 6
character or shorter prefix established by the NSN (Numeric
Symbol Name) operator and of a non-negative number set by
the NSV (Numeric Symbol Value) operator.
Detailed Description of F0:
-------- ----------- -- --
F0='+NSN'/Z/NSV N0 LOA NST 1INC N0+
*******
defines the prefix of the symbol by which the NST operator
will replace itself to be the single letter Z. Since the
letter Z is a text string within the longer text string
which defines F0, 2 different delimiter characters are
necessary.
F0='+NSN'/Z/NSV N0 LOA NST 1INC N0+
******
defines the numeric portion of the symbol by which the NST
operator will replace itself to be the number of times F0
has been previously called.
TBLTRN: Language Specification Manual Page 44
User Defined Functions
F0='+NSN'/Z/NSV N0 LOA NST 1INC N0+
*******
assigns as the label of the current table entry origin the
symbol by which the NST operator replaces itself. This
symbol will be Z0 the first time F0 is called.
F0='+NSN'/Z/NSV N0 LOA NST 1INC N0+
*******
increments the count N0 of the number of times F0 has been
called. It should be noted that the F0 does not force a
statement break as would be necessary if N0 was to be
incremented by the statement N0=N0+1. F0 can therefore be
used anywhere within the statement which generates the table
entries which it is to label.
Sample Function F1:
------ -------- --
N1=0...COUNT OF TIMES F1 CALLED
F1='+,1DIG N0 F1A,
F1A='+NSV N1 NSN'/A/NST 1INC N1 0DEF Q0 NSN'/Z/F1B
F1B='+NSV Q0 LOC NST XAD NST,1INC Q0 1RED N0 1DIG N0 F1B
The above is a somewhat more complex function which forms a
directory of the labels assigned earlier in the table by the
function F0. These labels are expunged from the symbol
dictionary and the count of times F0 has been called is
reset to zero.
Detailed Description of F1:
-------- ----------- -- --
F1='+,1DIG N0 F1A,
***********
executes user defined function F1A if F0 has been called.
F1A will assign a unique label to the start of the
directory, then call F1B which is a recursive function to
actually create the directory.
F1A='+NSV N1 NSN'/A/NST 1INC N1 0DEF Q0 NSN'/Z/F1B
*****************
assigns a unique label to the start of the directory.
1. Defines the numeric portion of the symbol by which the
operator NST replaces itself to be the number of times
F1 has been successfully called previously.
2. Defines the prefix of the symbol by which the operator
NST replaces itself to be the letter A.
3. Assigns as the label of the current table entry origin
the symbol by which the NST operator replaces itself.
TBLTRN: Language Specification Manual Page 45
User Defined Functions
This symbol will be A0 the first time F1 is called
successfully. The table entry origin will be the start
of the directory since the current statement will not be
closed until after F1B has specified the contents of the
first location within the directory.
F1A='+NSV N1 NSN'/A/NST 1INC N1 0DEF Q0 NSN'/Z/F1B
***********************
prepares for function F1B.
1. Increments the count N1 of the number of times F1 has
been successfully called.
2. Defines as zero the number of items which F1B has placed
into the directory.
3. Defines the prefix of the symbol by which the NST
operator will replace itself in the function F1B to be
the single letter Z. The function F1B will use this
prefix in the generation of the labels which have
already been assigned by the function F0.
F1A='+NSV N1 NSN'/A/NST 1INC N1 0DEF Q0 NSN'/Z/F1B
***
calls function F1B. F1B enters the location of 1 labelled
entry into the directory each time called. F1B will recall
itself until all of the labels assigned by F0 have been
catalogued.
F1B='+NSV Q0 LOC NST XAD NST,1INC Q0 1RED N0 1DIG N0 F1B
***********************
enters a single location into the directory.
1. Defines the numeric portion of the symbol by which NST
will replace itself to be the number of times F1B has
been previously called during the present execution of
F1.
2. Inserts into the present table entry the location of the
entry which has as label the symbol by which the NST
operator replaces itself.
3. Removes this label from the symbol dictionary since it
is no longer needed and would be reassigned next time F0
was called a sufficient number of times anyway. The
following comma both terminates the range of the XAD
operator and increments the table entry origin for the
next entry in the directory.
F1B='+NSV Q0 LOC NST XAD NST,1INC Q0 1RED N0 1DIG N0 F1B
***************
prepares for recalling function F1B.
1. Increments the count Q0 of the number of times F1B has
been called for use in generation of the next label the
next time F1B is called.
TBLTRN: Language Specification Manual Page 46
User Defined Functions
2. Decrements the number of times F0 was called. As long
as this number is greater than zero, F1B will continue
to recall itself.
F1B='+NSV Q0 LOC NST XAD NST,1INC Q0 1RED N0 1DIG N0 F1B
***********
recalls the function F1B if the count N0 has not yet been
reduced to zero.
F1='+,1DIG N0 F1A,
*
The terminal comma insulates the F1 function from whatever
statements happen to follow on the same line as the
appearance of F1. A terminal blank is not necessary to
insulate this comma from the following symbol which could
itself be formed of commas since an extra blank is inserted
when a text replacement is performed if the right character
of the inserted text string is of the same character class
as the first non-blank character following the symbol being
replaced. Excess blanks immediately following the symbol
being replaced are removed to prevent accidental
accumulation of terminal blanks within a recursively called
function.
Sample Function F2
------ -------- --
Statements of the form
GROUP1 CAN BE ALDEHYDE OR KETONE OR ACID
GROUP2 CAN BE BROMIDE OR IODIDE
can be used to turn on a prespecified bit in each of the
several destination sets identified by the symbols ALDEHYDE,
KETONE etc. if the definitions given below are made. It is
assumed that the identifier symbols are used elsewhere in
the tables as constants having values which, when shifted,
are identical to the sequence of the desired destination
sets. If RXSET is the number of entries necessary to
contain the range of prespecified bits, the destination sets
are twice this length with the GROUP1 statements accessing
the lower RXSET entries and the GROUP2 statements accessing
the upper RXSET entries. The destination sets referenced
are created later in the table by the function F2. The
created sets are prefaced by a directory set of length FGSET
with only those bits turned on which correspond to the
referenced sets created by F2. The definitions necessary to
accomplish these tasks are as follow:
FGSET=2...NUMBER OF ENTRIES PER FUNCTIONAL GROUP SET
RXSET=3...NUMBER OF ENTRIES PER REACTION SET
TBLTRN: Language Specification Manual Page 47
User Defined Functions
...
...DEFINE GROUP1, GROUP2 AND OR
GROUP1='+NSN'/X/,Q5=1,XSY Q6,OR
GROUP2='*NSN'/X/,Q5=RXSET+1,XSY Q6,OR
OR='/,Q6=1RIT/1'/-1,NSV Q6 WRD Q5 BIT N0 NST/
CAN=,BE=
...
...DEFINE F2
N2=0...COUNT OF TIMES F2 CALLED
Q4=RXSET+RXSET
F2='+,64DEF Q0 0DEF Q1 0DEF Q2 NSN'/X/F2A,
F2A='+,NSV Q1 1INC Q1 1RED Q0 1DIA NST F2B 1DIG Q0 F2A
F2B='+1DIE Q2 F2C NST WRD Q4 NUL BIT Q1 Q3 XAD NST,
F2C='+1DEF Q2 NSN'/B/NSV N2 NST Q3 WRD FGSET NUL F2D
F2D='+1INC N2 NSN'/X/1RED Q1 NSV Q1 1INC Q1,
Detailed Description of F2:
-------- ----------- -- --
GROUP1='+NSN'/X/,Q5=1,XSY Q6,OR
GROUP2='*NSN'/X/,Q5=RXSET+1,XSY Q6,OR
The operations performed by GROUP1 or by GROUP2 are as
follows.
1. The prefix of the names of the destinations sets which
will be constructed by the NST operator is defined to be
the single letter X.
2. The symbol Q5 will be used after the WRD operator by the
function OR to determine offset of the BIT operator. Q5
is defined so as to allow GROUP1 to access the lower
half and GROUP2 to access the upper half of the
destination sets. The definitions of GROUP1 and GROUP2
are identical except for this offset.
3. Q6 will be defined by the function OR to be the shifted
and offset value of the identifier symbol such as
ALDEHYDE. If no offset is necessary, the last use of OR
in the previous statement will have defined Q6 as a
shift operator. The present definition of Q6 is removed
from the symbol dictionary to insure its legal definitin
by OR as a constant.
4. The function OR is called the first time so that it need
not be written in the statement preceding the first
identifier symbol.
OR='/,Q6=1RIT/1'/-1,NSV Q6 WRD Q5 BIT N0 NST/
The text
OR ALDEHYDE
is processed as the text
TBLTRN: Language Specification Manual Page 48
User Defined Functions
,Q6=1RIT ALDEHYDE-1,NSV Q6 WRD Q5 BIT N0 NST
It is necessary that text be processed following the final
identifier symbol in the GROUP1 or GROUP2 statement in order
to finish the definition of Q6 and to turn on the bit in the
referenced destination set. To prevent necessity of writing
a terminal symbol in the statement, the definition of the
function OR specifies that the text
-1,NSV Q6 WRD Q5 BIT N0 NST
be inserted into the text stream after one additional symbol
has been interpreted. (It should be noted that a text
replacement symbol which specifies a deferred insertion
cannot appear within the range of another such symbol. Text
replacement symbols which do not direct deferred insertion
can appear within the range of a deferred insertion, but are
not themselves taken into the symbol count although symbols
inserted by them are counted.) The operations performed by
OR are as follows.
1. Q6 is defined as one less than the value of the
identifier symbol right shifted one bit. It is assumed
that the identifier symbol can have the even values 2
through 128 while the symbols by which the NST operator
replaces itself are desired to be X0 through X63 so as
to conserve symbol dictionary space.
2. The numeric portion of the name of the destination set
is defined to be the value of Q6.
3. The offset Q5 defined by GROUP1 or GROUP2 is applied in
order to access the proper half of the destination set.
4. The bit N0 defined by the last use of the function F0 is
turned on in the selected half of the destination set
having as name the symbol by which the NST operator
replaces itself.
CAN=,BE=
The symbols CAN and BE are defined as null text strings and
are therefore transparent.
N2=0...COUNT OF TIMES F2 CALLED
Q4=RXSET+RXSET
N2 is a count of the number of times F2 is called
successfully and is used for generation of a unique name for
the directory set. Q4 is the number of table entries which
must be reserved for each referenced destination set even
though not all of these need be non-zero.
F2='+,64DEF Q0 0DEF Q1 0DEF Q2 NSN'/X/F2A,
F2 prepares to loop through function F2A 64 times to test
each of the possibly referenced destination set names X0
TBLTRN: Language Specification Manual Page 49
User Defined Functions
through X63. Q0 is a count of the number of times F2A must
yet be called. Q1 is the count of the number of times F2A
has already been called and is used in the generation of the
symbol names to be tested. Q2 is a switch which will be
made non-zero if and when a directory set has been
constructed before creating the first referenced destination
set.
F2A='+,NSV Q1 1INC Q1 1RED Q0 1DIA NST F2B 1DIG Q0 F2A
F2A tests each of the possible destination set names for
definition as an address label. If true, F2B is called to
create the destination set and the directory if necessary.
F2A recalls itself if it has not been executed 64 times.
F2B='+1DIE Q2 F2C NST WRD Q4 NUL BIT Q1 Q3 XAD NST,
F2B tests Q2 to determine if the directory set has been
constructed. If not, F2C is called to allocate space for
this and name it Q3. F2B turns on bit Q1 within the
directory set to mark the existence of the destination set.
Q4 entries are allocated for the present destination set,
the name of which is then removed from the symbol
dictionary.
F2C='+1DEF Q2 NSN'/B/NSV N2 NST Q3 WRD FGSET NUL F2D
F2D='+1INC N2 NSN'/X/1RED Q1 NSV Q1 1INC Q1,
F2C is called only before the construction of the first
referenced destination set. It creates the directory set of
FGSET entries, assigns this both the name Q3 and the name B
with the number of previous successful calls of F2 as
suffix. The symbol by which NST replaces itself is then
redefined to be that in effect when F2C was called. F2C is
divided into 2 sections merely to reduce the number of
unprocessed characters in the input text buffer.
Pre-execution Assembly of User Defined Functions
------------- -------- -- ---- ------- ---------
Although both the ' and '' operators can be used to specify
user defined functions, the '' operator causes the text
string to be converted to an assembled form which can be
interpreted without referencing the symbol dictionary when
the function is executed. During this assembly, the
operators which are recognized are all of those which TBLTRN
had available prior to the first table, and these are
delimited by the initial character classes even though the
symbol dictionary and character classes can have since been
modified. All symbols which were not in the initial TBLTRN
symbol dictionary, the entire contents of a text string
TBLTRN: Language Specification Manual Page 50
Pre-execution Assembly of User Defined Functions
within the text string forming the definition, and the NEG
operator are not altered. The assembler does not test
syntax so errors can be detected only at execution of the
function. Similarly, The use of an initially recognizable
operator name after the XSY operator, or as an address label
following the operators LOA, HIA, LOC or BIT will not be
handled correctly.
Pre-assembled functions have the advantage that they are
executed faster and can access operators which may no longer
exist in the symbol dictionary. When a table uses only
functions which are pre-assembled, most of the programmed
operators can be removed from the symbol dictionary and
therefore speed the identification of all the user defined
symbols.
The assembled codes are formed of the operator identifier
code followed by an asterisk or whatever character has been
placed by the ACC operator into the class originally
occupied by only the asterisk. The decimal integer prefixes
which some operators can take are shifted to the right of
the assembled code separated from it by the DEC operator
designation 12* if the prefix has a value of 3 or greater.
As examples, the user Defined functions OR and F2 introduced
in the previous section are shown below as they are stored
in the symbol dictionary first if defined using the '
operator and and second when defined using the '' operator.
The assembled version of a function often requires more
space than the source due to the expansion of single and
double character operators and the necessity of insertion of
the DEC operator representation before integers which were
originally prefixes.
TEXT 4437 OPR 8 OR
'' '' ********
'' '' ,Q6=1RIT
'' '' ********
'' '' * ARGUMENT COUNT 1
'' '' ***************************
'' '' -1,NSV Q6 WRD Q5 BIT N0 NST
TEXT 4437 OPR 8 OR
'' '' ************
'' '' 5*Q6 15*32*1
'' '' ************
'' '' * ARGUMENT COUNT 1
'' '' *****************************
'' '' 9*1 5*119*Q6 58*Q5 40*N0 121*
TEXT 4092 OPR 8 F2
'' '' *************************************
'' '' ,64DEF Q0 0DEF Q1 0DEF Q2 NSN'/X/F2A,
TBLTRN: Language Specification Manual Page 51
Pre-execution Assembly of User Defined Functions
TEXT 4092 OPR 8 F2
'' '' ****************************************
'' '' 5*112*12*64 Q0 113*Q1 113*Q2 118*4*/X/F2
'' '' A 5*
'' '' ****
WARNING. In text which is to be assembled, operators should
not be written with decimal integer prefixes if within the
range of code executed conditionally depending upon the
validity of a Do-If class operator test. The reason for
this is that the assembly process converts the single
operator with integer prefix to one symbol if the prefix has
the value zero, to the operator followed by the prefix if
the prefix has the value 1, or to the operator followed by
the DEC operator designation 12* followed by the prefix if
the prefix has a value greater than 1.
Query Operators
----- ---------
Query operators report to the user on the teletype the
current status of various TBLTRN conditions without going
through the usual symbol recognition process. Such
operators are completely transparent to the TBLTRN
processor, and are always active except within text strings.
A query operator is identified by being composed only of
characters of the class originally occupied by the dollar
sign. The option desired is selected by the number of
characters making up the operator. These options are as
follow.
Single character query operators list the symbol or the
group of table entries currently being defined. The
format of the output is identical to that which would
be generated by the TEL operator. Through the use of
several single character query operators within a
statement, individual steps in the definition or
assembly can be observed.
Double character query operators list the current sign, byte
and word together with the name of the presently
selected packing pattern, if any. Sign is indicated
by numbers -1 through 4 as follow.
-1. Default sign.
0. Exclusive or.
1. And.
2. Addition.
3. Subtraction.
4. Inclusive or.
TBLTRN: Language Specification Manual Page 52
Query Operators
The listed byte size is the base of the byte size
specified by the source table if this specified byte
size is a base from 2 through 17 raised to some
power. Otherwise, the listed byte size is identical
to that specified by the source table. The listed
byte number is based upon the listed byte size,
assuming the right byte to be byte 1. The entry
number is listed as the number of table entries below
the current table entry origin and is followed by the
current offset. The offset which would correspond to
the highest numbered table entry currently assembled
is also given.
Following this packing information in the output is a
listing of the text currently in the input buffer and
of the text being held for deferred insertion, if
any, together with the conditions necessary for its
insertion. This portion of the listing consists of a
character count, the classification name "NEW TEXT"
or "DEFERRED" and the text itself.
Triple character query operators list the current character
classes in the order of the character class number.
The listed class numbers begin at 5 since the lower
class numbers are reserved for special combinations
of the unassigned characters. Class 5 characters are
treated as blanks. Class 6 contains the characters
which can form query operators. Class 7 contains the
characters which can be used with decimal integer
prefixes as pre-assembled code. No special functions
are associated with the higher class numbers.
The query operater answer message begins with the current
input line number and that portion of the current statement
appearing on the current input line. After generation of
this message, all class 5 and class 6 characters are
translated to blanks so that the current query operator will
not be printed in later answer or error messages.
Example:
$MASK$=$MSK$ARG$65$2WRD ARG$129$
would generate the following messages.
1 $
1 MASK$
ENTRY 1 OCT 0 0
1 MASK =$
TEXT 4472 OPR 8 MASK
TBLTRN: Language Specification Manual Page 53
Query Operators
1 MASK = MSK$
OPERATOR 4472 OPR 29 MASK
1 MASK = MSK ARG$
BYTEMASK 4472 OPR 29 SIN 4 SIZ 2 BYT 1 WRD 1 MASK
1 MASK = MSK ARG 65$
BYTEMASK 4472 OPR 29 SIN 4 SIZ 2 BYT 1 WRD 1 MASK
'' '' AUTO ARG OCT 101 65 MASK
1 MASK = MSK ARG 65 2WRD ARG$
BYTEMASK 4472 OPR 29 SIN 4 SIZ 2 BYT 1 WRD 1 MASK
'' '' AUTO ARG OCT 101 65 MASK
'' '' SIN 4 SIZ 2 BYT 1 WRD 2 MASK
1 MASK = MSK ARG 65 2WRD ARG 129$
BYTEMASK 4472 OPR 29 SIN 4 SIZ 2 BYT 1 WRD 1 MASK
'' '' AUTO ARG OCT 101 65 MASK
'' '' SIN 4 SIZ 2 BYT 1 WRD 2 MASK
'' '' AUTO ARG OCT 201 129 MASK
Example:
MASK=MSK.,LOC ADR2
ADR1$LOC ADR2$MASK$LOC ADR2$MASK$2BIT ADR1$77$
would generate the following messages.
16 ADR1$
ENTRY 2 OCT 0 0
16 ADR1 LOC ADR2$
ENTRY 2 OCT 0 0
RESERVED SIN 4 SIZ 2 BYT 1 LOC 2 ADR2
16 ADR1 LOC ADR2 MASK$
LIST END 2 ADR2
BYTEINFO 1 SIN 4 SIZ 2 BYT 1 LOC 2 ADR2
16 ADR1 LOC ADR2 MASK LOC ADR2$
LIST END 2 ADR2
BYTEINFO 1 SIN 4 SIZ 2 BYT 1 LOC 2 ADR2
ENTRY 3 OCT 0 0
RESERVED SIN 4 SIZ 2 BYT 1 LOC 3 ADR2
16 ADR1 LOC ADR2 MASK LOC ADR2 MASK$
BYTEINFO 2 SIN 4 SIZ 2 BYT 1 LOC 3 ADR2
BYTEINFO 1 SIN 4 SIZ 2 BYT 1 LOC 2 ADR2
LIST END 3 ADR2
BYTEINFO 2 SIN 4 SIZ 2 BYT 1 LOC 3 ADR2
16 ADR1 LOC ADR2 MASK LOC ADR2 MASK 2BIT ADR1$
BYTEINFO 4454 SIN 4 SIZ 2 BYT 1 LOC 2 ADR2
TBLTRN: Language Specification Manual Page 54
Query Operators
ENTRY 2 OCT 2 2
POINTER 3 4454 ADR2
BYTEINFO 1 SIN 4 SIZ 2 BYT 1 LOC 3 ADR2
16 ADR1 LOC ADR2 MASK LOC ADR2 MASK 2BIT ADR1 77$
BYTEINFO 4454 SIN 4 SIZ 2 BYT 1 LOC 2 ADR2
ENTRY 2 OCT 2 2
POINTER 3 4454 ADR2
BYTEINFO 1 SIN 4 SIZ 2 BYT 1 LOC 3 ADR2
ENTRY 4 OCT 115 77
Example:
MASK=MSK$$3WRD$$2LFT$$10SIZ$$-$$ARG$ $$
10DUP 0
2WRD$$-$$2LFT$$22$ $$MASK$$33$ $$
would generate the following messages.
1 MASK=MSK$$
SIGN=-1, BYTE= 1 OF SIZE= 2, ENTRY= 0+ 1 OF 0
39 NEW TEXT MASK=MSK$$3WRD$$2LFT$$10SIZ$$-$$ARG$ $$
1 MASK=MSK 3WRD$$
SIGN=-1, BYTE= 1 OF SIZE= 2, ENTRY= 0+ 3 OF 0
39 NEW TEXT MASK=MSK 3WRD$$2LFT$$10SIZ$$-$$ARG$ $$
1 MASK=MSK 3WRD 2LFT$$
SIGN=-1, BYTE= 3 OF SIZE= 2, ENTRY= 0+ 3 OF 0
39 NEW TEXT MASK=MSK 3WRD 2LFT$$10SIZ$$-$$ARG$ $$
1 MASK=MSK 3WRD 2LFT 10SIZ$$
SIGN=-1, BYTE= 3 OF SIZE= 10, ENTRY= 0+ 3 OF 0
39 NEW TEXT MASK=MSK 3WRD 2LFT 10SIZ$$-$$ARG$ $$
1 MASK=MSK 3WRD 2LFT 10SIZ -$$
SIGN= 3, BYTE= 3 OF SIZE= 10, ENTRY= 0+ 3 OF 0
39 NEW TEXT MASK=MSK 3WRD 2LFT 10SIZ -$$ARG$ $$
1 MASK=MSK 3WRD 2LFT 10SIZ - ARG$
BYTEMASK 4430 OPR 29 SIN 3 SIZ 10 BYT 3 WRD 3 MASK
1 MASK=MSK 3WRD 2LFT 10SIZ - ARG $$
SIGN=-1, BYTE= 1 OF SIZE= 10, ENTRY= 0+ 1 OF 0
39 NEW TEXT MASK=MSK 3WRD 2LFT 10SIZ - ARG $$
3 2WRD$$
SIGN=-1, BYTE= 1 OF SIZE= 2, ENTRY= 10+ 2 OF 0
33 NEW TEXT 2WRD$$-$$2LFT$$22$ $$MASK$$33$ $$
3 2WRD -$$
SIGN= 3, BYTE= 1 OF SIZE= 2, ENTRY= 10+ 2 OF 0
33 NEW TEXT 2WRD -$$2LFT$$22$ $$MASK$$33$ $$
TBLTRN: Language Specification Manual Page 55
Query Operators
3 2WRD - 2LFT$$
SIGN= 3, BYTE= 3 OF SIZE= 2, ENTRY= 10+ 2 OF 0
33 NEW TEXT 2WRD - 2LFT$$22$ $$MASK$$33$ $$
3 2WRD - 2LFT 22$
ENTRY 12 OCT 777777777650 -88
ENTRY 11 OCT 0 0
3 2WRD - 2LFT 22 $$
SIGN=-1, BYTE= 1 OF SIZE= 2, ENTRY= 10+ 1 OF 2
33 NEW TEXT 2WRD - 2LFT 22 $$MASK$$33$ $$
3 2WRD - 2LFT 22 MASK$$
SIGN= 3, BYTE= 3 OF SIZE= 10, ENTRY= 10+ 3 OF 2 MASK
33 NEW TEXT 2WRD - 2LFT 22 MASK$$33$ $$
3 2WRD - 2LFT 22 MASK 33$
ENTRY 13 OCT 777777771434 -3300
ENTRY 12 OCT 777777777650 -88
ENTRY 11 OCT 0 0
3 2WRD - 2LFT 22 MASK 33 $$
SIGN=-1, BYTE= 1 OF SIZE= 2, ENTRY= 10+ 1 OF 3
33 NEW TEXT 2WRD - 2LFT 22 MASK 33 $$
Example:
$$$ACC'/??/ACC'/(A/ACC'/)A/ACC'*//*ACC'/-+/$$$
would generate the following messages.
18 $$$
CHARACTER CLASSES
5
6 $
7 *
8 .
9 ,
10 '
11 -
12 +
13 =
14 (
15 )
18 ACC'/??/ACC'/(A/ACC'/)A/ACC'*//*ACC'/-+/$$$
CHARACTER CLASSES
5
6 $
7 *
8 .
9 ,
TBLTRN: Language Specification Manual Page 56
Query Operators
10 '
12 +
-
13 =
14 /
16 ?
Programmed Operators
---------- ---------
The symbols described below are recognized initially by
TBLTRN. The operators having the names, ,, ,,, ' '' ... END
and NST cannot be removed from the symbol dictionary, but
can be renamed. All other symbols (including the = and ==
and XSY and XAD operators) can be removed from the symbol
dictionary by the XSY operator and then be redefined during
the translation of a particular table by the = or ==
operators, but the original symbol assignments are usually
restored during the preparation for the translation of the
following table (i.e., by the BLK operator or by any symbol
which has been equated to the BLK operator).
Symbol Meaning
, (comma, end of statement) This operator defines end of
statement if necessary. The symbol following this
operator begins a new statement. This statement
separator is necessary in input from the normal input
device only if multiple statements appear on a single
line or if the BAC operator has been issued. If the ==
(double equal sign) operator is used to request that
the user enter a symbol definition on the teletype when
the teletype is not the selected input device, the
definition can be terminated by a comma or, if the BAC
operator has not been issued, by typing a new statement
on a following line. In the latter case, or in the
former if additional text follows the comma on the same
line, the additional text is stored until additional
teletype input is required.
,, (double comma, continue) This operator is used at the
start of a line to indicate that the current line
continues the current statement. Elsewhere, this
operator is treated as transparent. Use of the double
comma operator within the range of the BAC operator is
redundant, but causes not harm.
,,, (triple comma, continue) This operator is used to
indicate that the present statement is continued on the
next non-comment line. Characters right of this
operator on the present line are to be treated as a
TBLTRN: Language Specification Manual Page 57
Programmed Operators
comment and are ignored by the translator. Use of the
triple comma operator within the range of the BAC
operator or at the end of the line prior to a line
beginning with the double comma operator is redundant
but causes no harm.
Example: (See definition of ... for another example.)
MASK=MSK 100SIZ 1LFT ARG ARG
is exactly equivalent to the statement
MASK ,,,FIRST COMMENT
= ...SECOND COMMENT (TRIPLE PERIOD)
,,MSK ,,,THIRD COMMENT
100SIZ,,,FOURTH COMMENT
...FIFTH COMMENT (TRIPLE PERIOD)
1LFT ,,,SIXTH COMMENT
,,ARG ...SEVENTH COMMENT (TRIPLE PERIOD)
,,,EIGHTH COMMENT
ARG
' (apostrophe or single quote) followed on the same line,
with or without separating blanks, by a non-blank
delimiter character. The text right of the delimiter
character up to the next appearance of the delimiter
character or the end of the current input line is taken
as a text string. If within the range of an
unfulfilled (false answer) IF or Do-If class operator,
the entire text string including initial apostrophe and
delimiting characters is counted as a single symbol and
is not performed. The text string is used after the
ACC operator to establish character classes, and after
the NSN and TTL operators to establish names of no more
than 6 non-blank characters.
Examples:
TTL'/IVALUE/
would define IVALUE to be the name of the array
output by TBLTRN at the end of the current table.
ONE=1
DIE 2 ONE ACC'/XX/DIN 2 ONE ACC'/YY/
would place Y into its own unique character class.
However, since the DIE (Do-If Equal zero) test
failed, the next 2 symbols following the integer 2
after the DIE operator, namely the ACC operator and
the text string '/XX/, would not be executed and
the character class of X is unchanged.
TBLTRN: Language Specification Manual Page 58
Programmed Operators
When such a text string appears in a symbol definition
containing at most other text strings, each possibly
preceded by a constant or parenthetical expression, the
symbol being defined when encountered again, except
within the range of the TEL and XSY or unfulfilled IF
class or Do-If class operators, will insert the text
string into the input statement after the
interpretation within the present statement of the
number of symbols specified by a preceding zero or
positive constant or zero or positive expression, or
before the number of statement breaks specified by a
preceding negative constant or negative expression.
The count of symbols or of statements is done after all
non-deferred text replacements are completed.
Therefore, the count does not include symbols defind as
text strings, but rather includes those symbols or
statements by which these text replacement symbols
replace themselves.
Example:
ADD*THREE*CONSTANTS=1'/+/1'/+/
or
TWO=2
ADD*THREE*CONSTANTS=(TWO-1)'/+/ONE'/+/
would define the symbol ADD*THREE*CONSTANTS as a
text replacement operator which would insert text
consisting of a plus sign after each of the next 2
symbols following it in the current statement. The
statements
A+B+C
and
ADD*THREE*CONSTANTS A B C
would then be equivalent.
Example:
REMOVE*SYMBOLS=-1'/XSY A B C/
would define the symbol REMOVE*SYMBOLS as a text
replacement operator which would insert the text
XSY A B C at the end of the statement in which it
is used.
The statements
TBLTRN: Language Specification Manual Page 59
Programmed Operators
REMOVE*SYMBOLS=-1'/XSY A/0'/B C/
and
REMOVE*SYMBOLS=-1'/XSY A/'/B C/
are identical and produce a result equivalent to
the previous example, since a absent argument count
has the default value zero and here specifies that
the text B C is to be inserted immediately (that
is, after zero additional symbols within the
present statement) after the interpretation of the
text XSY A. Splitting of a long insertion is often
useful to reduce the number of characters which
must be stored in the input text buffer. It should
be noted, however, that an argument count greater
than zero could never be satisfied if any previous
argument of the text replacement operator is
negative.
The definition
REMOVE*SYMBOLS=-1'/XSY A/-1'/B C/
produces the same result as the previous example
since the end of statement which signals the
insertion of the text XSY A still exists following
the symbol A at which point the text B C is
inserted.
Example:
REMOVE*SYMBOLS=-1'/XSY A B C/-2'/XSY D E F/
would define the symbol REMOVE*SYMBOLS as a text
replacement operator which would insert the text
XSY A B C at the end of the statement in which is
is used, and which would insert the text XSY D E F
at the end of the following statement.
Example:
The statements
TELL*SYMBOLS=-1'/=1/-2'/=2,TEL A,TEL B/
,,-1'/TEL C/-2'/=3/
TELL*SYMBOLS A,B,C
or
TELL*SYMBOLS=-1'/=1/-3'/A,TEL B/...NOTE -3 HERE
,,-1'/TEL C/-2'/=3/
DUMMY='/=2,TEL/...THIS COMMA COUNTS IN -3 ABOVE
TBLTRN: Language Specification Manual Page 60
Programmed Operators
TELL*SYMBOLS A,B DUMMY,C
or
TELL*SYMBOLS=-1'/=1/-2'/=2,DUMMY/
DUMMY='/TEL A,TEL B/,,-1'/TEL C/-2'/=3/
TELL*SYMBOLS A,B,C
or
TELL*SYMBOLS=-1'/=1/-2'/=2 DUMMY/,,,
-1'/TEL C/-2'/=3/
DUMMY='/,TEL A,TEL B/
TELL*SYMBOLS A,B,C
are equivalent to the text
A=1,B=2,TEL A,TEL B TEL C,C=3
and would report to the user the values of
constants A and B, report the definition of the TEL
operator, and report that C is unknown. The TEL
operator is included within the list of items
reported since the insertion of the text TEL C
continues the argument list of the TEL operator
already in the statement into which this text is
inserted. As can be seen from the above examples,
a text replacement operator for which the insertion
is deferred can have within its range text
replacement operators which direct immediate
insertion. However, a deferred insertion text
replacement operator cannot appear within the range
of another deferred insertion operator.
If the text string in a symbol definition instead is
separated from the = or == operator by a single period
operator, then the symbol to the left of the = or ==
operator is defined to have a meaning identical to the
current non-address meaning of the symbol appearing in
the text string. Both the old and new symbols retain
their initial meanings until the end of the statement.
After the definition statement has been completed, the
non-address meaning of the symbol appearing in the text
string is removed from the symbol dictionary. This
operation therefore performs a rename.
If not used within any of the above described contexts,
the text string will be written without trailing blanks
into the output before the generated DATA statement.
All blanks are suppressed in a text string following
the ACC, NSN or TTL operators.
TBLTRN: Language Specification Manual Page 61
Programmed Operators
Examples:
'+ BLOCK DATA+
'+C DRIVING TABLE+
writes into the generated output the FORTRAN BLOCK
DATA statement and follows this with a FORTRAN
Comment card.
A='-'* BLOCK DATA*-
defines A to be a text string which will output the
FORTRAN BLOCK DATA statement when A is used.
ACC'*//*
assigns the character / (slash) to its own unique
character class.
NSN'+A+
assigns the text A to be the prefix of the symbols
constructed by the NST (Numeric Symbol Text)
operator. If the command 235NSV (Numberic Symbol
Value) is also given, the following appearances of
NST are replaced by the text A235 except within the
range of an unfulfilled IF or Do-If class operator.
'' (double apostrophe) followed on the same line, with or
without separating blanks, by a non-blank delimiter
character. Identical to ' (single apostrophe) operator
defined above if not within the range of a = or ==
operator, except that the text string is written onto
the teletype if not within the range of the ACC, NSN or
TTL operators.
When used after the = or == operators in a symbol
definition consisting only of text strings, possibly
preceded by constants or parenthetical expressions, the
text string is assembled using the original TBLTRN
programmed operators (those described in this manual)
and the original character classes, leaving unaltered
any unrecognizable symbols or text strings within the
larger text string.
If the text string is separated from the = or ==
operator by the single period operator, then the symbol
to the left of the = or == operator is defined as
identical to the meaning within the original (default)
symbol dictionary of the symbol (possibly used with
decimal integer prefix) in the text string. The
current meaning, if any, of the symbol appearing in the
text string is not changed.
TBLTRN: Language Specification Manual Page 62
Programmed Operators
. (single period) In a statement which defines a table
entry, this operator acts as the address label of the
current table entry. Used alone or following the LOC
operator, the single period operator acts as a constant
having as value the address of the table entry into
which it is deposited.
After the BIT operator, the single period operator can
be used to specify that the destination is the current
table entry origin, offset by one less than the value
of the WRD operator if present.
The single period operator used before a text string in
a symbol definition defines the symbol left of the = or
== operator as equal to the non-address meaning of the
symbol appearing within the text string. If the text
string is begun by the single apostrophe operator, the
current non-address meaning of the symbol in the text
string is removed from the symbol dictionary when the
statement is terminated. If instead, the text string
is begun by the double apostrophe operator, the
definition assigned to the new symbol will be that in
the original symbol dictionary of the symbol within the
text string. These operations are provided to allow
the renaming or copying of the statement continuation
and statement termination operators.
Examples:
A='/LFT 3+LOC/
LOCATION*OF=.'/A/
defines the symbol LOCATION*OF as a text
replacement operator (macro) which when used will
insert the text LFT 3+LOC into the input text
buffer. The text replacement meaning of the symbol
A is removed from the symbol dictionary by the
definition of LOCATION*OF.
SHIFT*LEFT=.''/3LFT/
defines the symbol SHIFT*LEFT as an operator equal
to the original (default) meaning of the symbol
3LFT regardless of the current meaning of either
LFT or 3LFT. A decimal interger prefix can only be
used if the text string is begun by the double
apostrophe operator, and if the operator bearing
the prefix can legally be written with such a
prefix.
COMMENT=.''/.../
TBLTRN: Language Specification Manual Page 63
Programmed Operators
defines the symbol COMMENT as identical to the
original meaning of the triple period operator.
The current meaning, if any, of the triple period
operator would not be changed by this definition.
In the definition of a packing pattern, the single
period operator specifies that when the packing pattern
is used, the table entry origin is to be incremented
after the previous argument specifications have been
fulfilled if either of the following is true.
1. The present packing pattern has a following
argument specification which is fulfilled either
automatically (see definition of ARG operator) or
explicitly. Performance of an origin increment can
be forced by following its specification in the
packing pattern definition by one of the sequences
ARG 0, ARG NUL, ARG() or ARG(NUL) which would
specify an automatic single precision zero
argument.
2. All the argument specifications, if any, of the
present packing pattern have been fulfilled either
automatically or explicitly, and within the
statement in which the packing pattern is used
another packing pattern is not selected before
processing of the next constant or address label or
a BIT operator with the destination being indicated
by the single period operator as the incremented
table entry origin or a BIT operator with the
destination being a known address label of a table
entry already assembled by the current statement
(BIT possibly preceded, regardless of whether the
destination is indicated as period or label, by the
WRD operator). The table entry origin offset is
not performed if there does not remain unprocessed
within the statement such a constant or address
label or BIT deposit.
This offset of the table entry origin can be specified
by the WRD operator prior to the appearance of the
single period operator in the packing pattern
definition. The default value of the offset is 1.
Example:
JUMP*TWO*WORDS=MSK WRD 2.
defines the symbol JUMP*TWO*WORDS as a packing
pattern which when used would increment the table
entry origin by 2 words if the current statement
specifies additional contents of the table entries
defined by the current statement before the use of
TBLTRN: Language Specification Manual Page 64
Programmed Operators
another pattern if any.
... (triple periods, comment) Characters right of this
operator on the present line are to be treated as a
comment and are ignored by the translator. This
operator does not itself force closure of the current
statement.
Example:
102 ...FIRST COMMENT
300 ...SECOND COMMENT
...THIRD COMMENT
,,+4...FOURTH COMMENT
500 ,,,FIFTH COMMENT (TRIPLE COMMA)
...SIXTH COMMENT
+6...SEVENTH COMMENT
700 ...EIGHTH COMMENT
,,,NINTH COMMENT (TRIPLE COMMA)
+8...TENTH COMMENT
assembles table entries
102
304
506
708
+ (plus sign, add) The next constant encountered after
this operator within the current statement is to be
added into the constant or table entry or operator
value being currently defined.
- (minus sign, subtract) The next constant encountered
after this operator within the current statement is to
be subtracted into the constant or table entry or
operator value being currently defined.
= (equal sign) When used outside a symbol definition,
the symbol appearing left of this operator is to be
defined as the operator or expression right of the =
operator through the end of the statement (as indicated
by the , or END operator or, if the BAC operator has
not been issued, by a new statement on a following
line). The = operator must be the second symbol
(excluding transparent symbols or symbols defined as
text strings having deferred insertion) within the
statement or be the second symbol following the symbol
or parenthetical expression tested by an IF class
operator if present. The symbol being defined must
previously have been undefined, or have been defined as
a constant or packing pattern, or have been only an
address label. If the symbol was previously a packing
TBLTRN: Language Specification Manual Page 65
Programmed Operators
pattern or a constant, it can be redefined in terms of
its previous identity. If the symbol was previously
defined only as an address, its future use as an
address is unchanged by the new definition (unless the
new definition is as a text string since this would
have precedence over definition as an address label,
see below) since the same symbol name can be both
address label and other operator depending upon the
context in which it is used.
Example:
PACKING=SIZ
defines the symbol PACKING to be an operator which
can be used to establish the packing size in the
same manner as the operator SIZ.
Example:
PACKINGSIZE=64SIZ
or
PACKINGSIZE=SIZ 64
or
PACKINGSIZE=32
PACKINGSIZE=SIZ(OCT 40+PACKINGSIZE)
defines the symbol PACKINGSIZE as an operator which
can be used to set the packing size at 64 to create
6 bit bytes. The use of the SIZ operator within
the symbol definition has not, however, changed the
packing size for the following statements.
Example:
SIXTYFOUR=8SIZ 2LFT 1
or
SIXTYFOUR=2LFT 8SIZ 1
or
ONE=1,TWO=2,EIGHT=8
SIXTYFOUR=LFT TWO SIZ EIGHT ONE
defines the symbol SIXTYFOUR as a constant with the
value decimal 64 (1 left shifted 2 units of 3 bits
each).
TBLTRN: Language Specification Manual Page 66
Programmed Operators
A symbol can also be defined as a text string following
and on the same line as the ' or '' operator and
enclosed within delimiter characters. Such a symbol is
replaced by the text string whenever encountered except
within the range of the XSY or TEL or unfulfilled IF or
Do-If class operators. This is the only mechanism by
which a symbol can be defined as equal to a group of
unrelated operators, or in terms of address labels.
Definition as a text string can also be used to
simulate definition as the text construction operator
NST (as opposed to the text constructed by NST) or the
terminator, continuation and comment operators , ,, ,,,
' '' ... and END. However, definition as a text string
consisting of only a single operator should not be
performed unless it is necessary that the definition be
removable by the XSY operator or conditionally
performed following Do-If or IF class operators. If no
definition is given (for example ABC=) the symbol is
defined as a null text string (identical to ABC='//)
and is transparent to all operators except XSY and TEL.
Example:
SETA='/,XSY A,A='+,XSY B,B='-LOC C-, +,/
defines SETA as a symbol which when used will
define A as a symbol which when used will define B
as the value of the subscript of the table entry
having the address label C. It should be noted
that the definitions of SETA and of A are insulated
from other symbols by the end of statement operator
single comma. This properly closes the previous
statement, if any, on the same line as the use of
SETA or of A. Such closure would be necessary, for
example, if this previous statement was itself a
symbol definition. No extra blanks are necessary
at the right end of the text string to separate the
terminal comma from the symbol following the use of
SETA or of A even though this could itself be
formed of commas.
The = operator can be followed by a single period
operator and then by a text string indicated by the ''
operator (but not by the ' operator) to define the
symbol preceding the = operator as identical to the
meaning in the original (default) symbol dictionary of
the symbol appearing within the text string. Only the
default meaning of the NEG operator cannot be copied in
this manner. The current definition, if any, of the
symbol within the text string is ignored. This is the
only mechanism by which more than one symbol name can
become associated directly with any of the operators ,
,, ,,, ' '' ... END or NST.
TBLTRN: Language Specification Manual Page 67
Programmed Operators
Example:
STOP=.''/,/,HALT=''/,/
defines the symbol STOP as an end of statement
operator identical to the initial meaning of the
single comma operator. The effect of the use of
the symbols STOP and HALT would under most
conditions be the same, however HALT could not
cause an end of statement if used within the range
of the TEL or XSY or unfulfilled (false answer) IF
class or unfulfilled Do-If class operators.
The = operator can also be followed by a single period
operator and then by a text string indicated by the '
operator (but not by the '' operator) to rename the
non-address meaning of the symbol within the text
string to the name of the symbol being defined. Both
the old and new symbol names retain their previous
meanings until the end of the definition statement.
The non-address meaning of the old symbol name is
removed from the symbol dictionary after the statement
is terminated.
Example:
RENAME=''/=.'/,XSY.,.RENAME/,/, ,=
1. Defines RENAME as a symbol which will replace
itself in the input text stream by constructed
operators having meanings identical to the
operators = . and ' (single equal sign, single
period and single apostrophe) in the initial
symbol dictionary.
2. Removes the current meaning of the operator
. (single period) from the symbol dictionary.
3. Renames the end of statement operator , (single
comma) to have the new name . (single period).
This statement is terminated by the comma which
has retained its initial meaning until the
statement is closed.
4. Defines the , (single comma) operator as a null
text string.
== (double equal sign, ask user for definition) Identical
to the = (single equal) operator defined above except
that the definition must be input by the user on the
teletype. Lack of a definition will not be accepted as
a default definition as a null text string unless the
teletype is also the currently selected input unit. A
message is typed on the teletype informing the user of
the line number and symbol name. Control is
transferred to the teletype until the definition has
TBLTRN: Language Specification Manual Page 68
Programmed Operators
been completed. The user must close the definition
either with a single comma or END operator, or, if the
BAC operator has not been issued, by typing a new
statement on a following line. In the latter case, or
in the former if additional text follows the comma on
the same line, the additional text is stored until
additional teletype input is required. Neither a blank
line nor a line containing only transparent symbols nor
a comment line beginning with the ... (triple period)
operator terminates the definition since a statement
can continue across these. The program will confirm
the definition of the symbol when the definition has
been completed.
Example:
SYMBOL1==,SYMBOL2==,SYMBOL3==
would request that the user define the symbols
SYMBOL1, SYMBOL2 and SYMBOL3. Execution will not
continue until these definitions are supplied.
( (single left parenthesis) The following constants
through the next byte pattern name, the symbols ) or
)), or the end of the statement are to be entered into
the byte of the table entry currently established and
with the sign currently established. The sign can be
temporarily altered but is restored to its initial
value after each constant.
Example: Table starting with
MASK=MSK 100SIZ 1LFT ARG+ARG
TWO=2
TON MASK LOC. . +.
(LOC.+1) LOC. +.
( .+TWO)( .LOC.)
assembles table entries
102
304
506
The value of an operator which could have accepted a
decimal integer prefix, but which does not have such a
prefix, can instead be specified enclosed within
parentheses following the operator. The parentheses
are not necessary if this value is calculated from just
a single constant or integer. The sign, if any,
established prior to the operator which could have
taken the decimal integer prefix is re-established
after the end of the following expression.
TBLTRN: Language Specification Manual Page 69
Programmed Operators
Example:
DEF-(+5 3)TWO SIZ+(3 5)
LFT TWO(1+TWO)(TWO+3)
LFT(7-TWO-3)(OCT 17 AND TRX(TWO+6)25)
,,(DEC 31 XOR 30)
would assemble table entries containing 197 (octal
305) and 327 (octal 507) respectively. The
individual operations performed in this example are
as follow.
1. Define symbol TWO as a constant with value 2.
2. Set the byte size to 8 (3 bits per shift unit).
3. Left shift 2 bytes the value 1 and inclusively
OR this octal 100 into the initially zeroed
first table entry.
4. Left shift 2 bytes the value of the constant
TWO and add this octal 200 to the first table
entry to give octal 300.
5. Inclusively OR the value of the constant TWO
into the first table entry to give octal 302.
6. Add the value 3 to the first table entry to
give the final value octal 305.
7. Left shift 2 bytes the value octal 17 and
inclusively OR this octal 1700 into the
initially zeroed first table entry.
8. Set to octal the radix for the interpretation
of integers not preceded by either OCT or DEC.
9. Left shift 2 bytes the value octal 25 and
logically AND this octal 2500 into the second
table entry to give octal 500.
10. Inclusively OR the value decimal 31 (octal 37)
into the second table entry to give octal 537.
11. Exclusively OR the value octal 30 into the
second table entry to give the final value
octal 507.
An automatic argument of a packing pattern must
similarly be defined enclosed in left and right
parentheses if the argument consists of more than a
single integer or constant. Several examples are given
in the definition of the ARG operator.
(( (double left parenthesis) Identical to single left
parenthesis.
Example: This symbol is provided to allow the argument
list of a packing pattern (such as MASK) to be written
in the form
MASK ((arg1)(arg2)) rest of statement
TBLTRN: Language Specification Manual Page 70
Programmed Operators
or
MASK ( (arg1) (arg2) ) rest of statement
or, if each argument is a single constant
MASK ARG1 ARG2) rest of statement
) (single right parenthesis) Terminates the constant
byte and sign range of the preceding ( or ((. If not
preceded by ( or ((, the ) operator advances the
argument specification of the presently selected
packing pattern to the next origin increment or
terminates the range within the present statement of
the packing pattern if an origin increment not found.
)) (double right parenthesis) Terminates the constant
byte and sign range of the preceding ( or ((, and also
advances argument specification of the presently
selected packing pattern to the next origin increment
or terminates the range within the present statement of
the packing pattern if an origin increment not found.
Example:
MASK=MSK 100SIZ 1LFT ARG 2LFT ARG 3LFT ARG
TON MASK 1) +2
3))+4
(2+3))+6
((3+4))+8
assembles table entries
102
304
506
708
ACC (Alter Character Class) When used outside a symbol
definition, the next symbol, which must be a text
string initiated by the ' or '' operators and with
delimiter characters, defines or alters the character
classes used to delimit adjacent symbols not separated
by blanks. The first (left) non-blank character within
the text string is placed into the character class of
the second non-blank character. If the first and
second non-blank characters are identical, the
character is placed into a character class separate
from all others. If the text string consists of a
single non-blank character, this character is placed in
the character class containing the blank. If the text
string consists of more than 2 non-blank characters,
the extra characters to the right are ignored.
TBLTRN: Language Specification Manual Page 71
Programmed Operators
Example:
ACC'/+-/
places the character + (plus) into the class of the
character - (minus). Symbols could then be formed
of any combination of these 2 characters, as might
be done to allow the definitions +-=IOR and -+=IOR.
Example:
ACC'/88/ACC'/99/
8=LFT
9=8 1...NOT 9=18 AS 1 AND 8 NOT IN SAME CLASS
2SIZ 92
would assemble a table entry containing the value 4
which is 2 left shifted 1 byte of size 2.
ADR (ADdRess) When used outside a symbol definition, the
following symbol is defined as the address label of the
present table entry origin, offset by one less than the
value specified by the WRD operator if used prior to
the ADR operator. If the symbol was previously an
address label, its value is merely redefined. If the
symbol is currently also defined as an operator other
than an address label, it will in the future be used as
an address label following the LOC, BIT, XAD, IFA,
IFNA, DIA and DINA operators. Unlike automatic
definition as an address label, the ADR operator and
its following symbol can appear in the statement after
a constant has been assembled following the
establishment of the table entry origin.
Example:
MASK=MSK ARG.ARG 2WRD ARG
MASK 123 ADR SECOND 2WRD ADR THIRD 456 789
or
MASK=MSK ARG.ARG 2WRD ARG
MASK 123 456 789 ADR SECOND 2WRD ADR THIRD
defines the symbol SECOND to be the address label
of the second assembled table entry (containing
456) and the symbol THIRD to be the address label
of the third assembled table entry (containing
789).
AND (AND) The next constant or address encountered after
this operator within the present statement is to be
ANDed into the constant or table entry or operator
TBLTRN: Language Specification Manual Page 72
Programmed Operators
value being currently defined. After the logical AND
operation, the only bits which are turned on (set to
one) in the item being defined are those bits which
were originally on both in the item being defined and
in the item being ANDed with the item being defined.
Examples:
OCT 27 AND OCT 72
assembles a table entry containing octal 22. It
should be noted that the result of the AND of
anything with zero is always zero. Therefore a
statement such as
DEF AND 63 A
would direct that the DEF operator be used with a
zero value, and as a result, A would be defined as
a constant with the value zero.
ARG (ARGument) Marks end of sign, byte and word
specification of an argument in a packing pattern
definition. The ARG operator can be followed by a
constant or constant shift phrase to be taken as an
automatic argument of the packing pattern, by the
specification of sign, byte and word count of
additional arguments, by an origin increment
specification, or by the name of another packing
pattern.
Example:
MASK=MSK+2LFT 4WRD ARG 4WRD 2LFT-ARG
defines MASK as a packing pattern which would add
its 1st argument into the 3rd byte (2 byte shift)
of the 3rd table entry beyond the current table
entry origin and then subtract its 2nd argument
from the same byte of the same table entry.
MASK=MSK+2LFT 4WRD ARG 22 4WRD 2LFT-ARG
defines MASK as a packing pattern which would add
the value 22 into the 3rd byte of the 3rd table
entry beyond the current table entry origin and
then subtract its 2nd argument (22 is automatically
its 1st argument) from the same byte of the same
table entry.
AA=33
MASK=MSK+2LFT 4WRD ARG,,,
4WRD 2LFT-ARG(+11+OCT 54 AA)
TBLTRN: Language Specification Manual Page 73
Programmed Operators
define MASK as a packing pattern which would add
its 1st argument into the 3rd byte of the 3rd table
entry beyond the current table entry origin and
then add 11 followed by the addition of 44 and
subtraction of 33 to the same byte of the same word
if, and only if, there was a 1st argument. In the
above example, the values of the automatic argument
are stored when the definition is made, and
afterwards do not depend upon the value of AA when
the pattern is used. The radix for integer
evaluation during the remainder of the definition
(or for just the next constant in the definition)
can be reset at any point in the definition. If
the sign is not specified in the definition of an
automatic argument, the sign is taken as the last
sign specified before the left parenthesis if a
left parenthesis is used. Thus, the statements
AA=33
MASK=MSK+2LFT 4WRD ARG,,,
4WRD 8SRX 2LFT ARG+(DEC 11 54-AA)
or
AA=33
MASK=MSK+2LFT 4WRD ARG,,,
4WRD 2LFT ARG+(8SRX DEC 11 54-AA)
are exactly equivalent to the above. Byte and word
count cannot be respecified between the ARG
operator and the automatic argument just as these
cannot be respecified for an explicit argument of a
packing pattern used in a statement which defines a
table entry.
BAC (Begin Automatic Continue) When used outside a symbol
definition, this operator causes each new line to
continue the previous statement even if the ,, or ,,,
operators have not been used. Statements can only be
terminated by the , (single comma) or END operators
while the BAC operator is in effect, and text
replacement symbols for which insertion of the text is
deferred until before the end of a specified number of
statements will only be inserted before the last of the
specified number of , or END operators. Some operators
such as TTY, TEL, XSY, XAD, BLK, SAV and FIN will still
properly cause local termination of the assembly of the
table entries assembled by the statement even though
the statement has not been closed by the , or END
operators. The range of the BAC operator extends
through the appearance of the EAC (End Automatic
Continue) operator or through the end of the current
table as indicated by the BLK, SAV or FIN operators.
TBLTRN: Language Specification Manual Page 74
Programmed Operators
BIT (BIT) with decimal integer prefix or followed
immediately by a constant or parenthetical expression,
either designation being in turn followed by an address
label. When used outside a symbol definition, the bit
indicated by the decimal integer prefix or by the
constant or parenthetical expression following the BIT
operator is to be turned on in the table entry which
has the label given. Bit 1 is the right bit with
numbers increasing to the left. This numbering scheme
can be reversed by using the BPR operator to specifiy a
negative number of bits per table entry. With either
numbering system, overflow bits are placed in
successively higher table entries. The . (single
period) operator can be used to represent the address
label of the current table entry origin. It should be
noted that address labels (or a single period as an
address label) cannot be used in a symbol definition.
Example:
10BPR 5WRD 1BIT.
or
10BPR 3WRD 21BIT.
or
10BPR 1WRD 41BIT.
or
10BPR 41BIT.
or
5WRD ADDRESS 10BPR 1BIT ADDRESS
or
3WRD ADDRESS 10BPR 21BIT ADDRESS
or
1WRD ADDRESS 10BPR 1WRD 41BIT ADDRESS
or
ADDRESS 10BPR 41BIT ADDRESS
turns on the 1st (right) bit in the 4th table entry
beyond the current table entry origin. It should
be noted that 1WRD is the default and indicates no
TBLTRN: Language Specification Manual Page 75
Programmed Operators
additional offset from the current table entry
origin.
Example:
FOUR=4
SIX=6
ADDRESS1 BIT SIX ADDRESS2 BIT FOUR ADDRESS2
ADDRESS2 1BIT ADDRESS1 3BIT ADDRESS1
or
10BPR
1BIT ADDRESS1 3BIT ADDRESS1
14BIT ADDRESS1 16BIT ADDRESS1
ADDRESS1 2WRD NUL
or
MINUS=-10,BPR MINUS
ADDRESS1 2WRD NUL
8BIT ADDRESS1 10BIT ADDRESS1
15BIT ADDRESS1 17BIT ADDRESS1
assemble table entries
5 (octal 101)
40 (octal 101000)
The NUL operator is used in the above example to
force sufficient table entries to be set aside in
the destination which is to receive bits specified
later.
The BSZ operator can force the Bit operator to form
counts in larger than single bit bytes. BSZ through
either decimal integer prefix or immediately following
constant or parenthetical expression defines the byte
size referenced by the BIT operator. This byte size
need not be 2 raised to some power, but should not be a
base not greater than 17 raised to some power. A byte
size of 2 (1 bit) is the default and the BIT operator
inclusively OR's into this byte size so that the effect
is the turning on of the the specified bit. When the
byte size is larger, the BIT operator instead adds a
properly shifted one to the entry containing the byte.
The contents of the byte thus serve as a count of the
number of times the BIT operator deposited into this
particular byte. No check for overflow of the byte is
made however.
BLK (BLocK) When used outside a symbol definition, this
operator writes the table which has been assembled onto
TBLTRN: Language Specification Manual Page 76
Programmed Operators
the output device, restores the TBLTRN symbol
dictionary and character classes to their original
conditions, and begins reading of the next table to be
assembled. The final table to be assembled must be
terminated by a FIN operator rather than by a BLK or
SAV operator.
Example:
1,2,3,BLK,4,5,6,FIN
would assemble a table containing the entries 1, 2
and 3 and a second (and final) table containing the
entries 4, 5 and 6.
BOD (Begin Ordered Dictionary) When issued outside a
symbol definition, this operator causes all following
symbol definitions by the = or == operators to insert
the symbols being defined into the ordered portion of
the symbol dictionary. Such symbol definitions require
more time to perform than the simple graftings of the
new definitions to the end of the symbol dictionary
which are performed when the EOD (End Ordered
Dictionary) command is active. However, future
recognitions of symbols within the ordered portion of
the symbol dictionary are performed more quickly.
Insertion of newly defined symbols into the ordered
portion of the symbol dictionary is the default action
at the start of each table.
BPR (Bit PRecision) with decimal integer prefix or followed
immediately by a constant or parenthetical expression.
When used outside a symbol definition, the integer
prefix or the absolute value of the following constant
or parenthetical expression is to be taken as the
number of bytes per word which can be set by the BIT
operator. Unless the byte size referenced by the BIT
operator has been altered by the BSZ operator, the byte
size will be a single bit. The right hand byte in the
word is byte 1 with the byte numbering increasing to
the left if the number of bytes is specified by an
integer prefix or positive following constant or
parenthetical expression. If the number of bytes is
specified instead by a negative following constant or
parenthetical expression, the byte numbering increases
from left to right with the right byte numbered the
absolute value of the constant or parenthetical
expression. The default conditions at the start of
each table are 32 single bit bytes per table entry with
the right bit being byte 1.
BSZ (Bit SiZe) with decimal integer prefix or followed
immediately by a constant or parenthetical expression.
TBLTRN: Language Specification Manual Page 77
Programmed Operators
When used outside a symbol definition, the value of the
integer prefix or the following constant or
parenthetical expression is to be taken as the size of
the bytes referenced by the BIT operator. The byte
size is the number of different values which can be
packed into the bit. The default byte size is 2 which
is a single bit.
Example:
100BSZ
would define the byte size referenced by the BIT
operator as 100. When the byte size is greater
than 2, the BIT operator adds rather than
inclusively OR's a properly shifted one into the
byte. The statement
1BIT A 2BIT A 2BIT A 3BIT A 3BIT A 3BIT A
would deposit the value decimal 30201 into the
table entry named A if the byte size was 100.
CLM (CoLuMn) with decimal integer prefix or followed
immediately by a constant or parenthetical expression.
When used outside a symbol definition, the value of the
decimal integer appearing as prefix or the following
constant or parenthtical expression is to be taken as
the width in characters of the numbers in the DATA
statements generated as output. If this width is
specified as zero, the DATA statements will be
generated in a compact format without inserted blanks.
If the specified width is greater than zero, the DATA
statements are generated with the assembled numbers in
columns. The width of each of these columns is the
larger of the specified width and the maximum width of
any number.
Example:
TTL'/VALUE/10CLM 60WID
would specify that the output DATA statements
represent the basic array name as VALUE and group
the table entries into columns 10 characters wide
(not counting separating commas) in a statement
field 60 characters wide.
DBG (DeBuG) When used outside a symbol definition, this
operator causes the TBLTRN symbol dictionary and
assembled table entries to be listed on the lister
device. Table entries which contain pointers are
identified as such and are printed unpacked in decimal.
TBLTRN: Language Specification Manual Page 78
Programmed Operators
All other table entries and the values of defined
constants are printed in both decimal and octal.
DEC (DECimal) The integer which follows this operator in
the current statement is to be evaluated in decimal
(that is, with radix 10).
Example:
ITEM=DEC 100+OCT 13
DEC 1000+ITEM
would define a table entry containing decimal 1111
regardless of the default radices.
DEF (DEFine) with decimal integer prefix or followed
immediately by a constant or parenthetical expression,
either designation being in turn followed by a symbol
defined as a single entry constant or which is
undefined or which is merely an address label. When
used outside a symbol definition, the final argument is
assigned the value of the decimal integer prefix of the
DEF operator or of the constant or parenthetical
expression immediately following the DEF operator if a
decimal integer prefix is not present. If the final
argument of the DEF operator is undefined or merely an
address label, this final argument is defined as a
single precision constant, without altering the
possible address label definition. The operators DEF,
INC, POP, PSH, RED, ROT, SFT, and STK permanently alter
the value of a constant without depositing into the
current table entry. None of these operators can be
used within a symbol definition to alter the value of a
constant. Of course, new operator names can be defined
as equal to any one of these operators by statements of
the form
DEFINE=DEF
or
DEFINE=.''/DEF/
Example:
DEF 8 B
or
8DEF B
assigns the symbol B (which must be a single entry
constant, be undefined, or be merely an address
TBLTRN: Language Specification Manual Page 79
Programmed Operators
label) the value 8. If B is not currently a single
entry constant, it is defined as a single precision
constant. If B is currently a single entry
constant, its precision is unchanged.
DIA (Do If Address) with decimal integer prefix or followed
immediately by a constant or parenthetical expression,
this in turn being followed immediately by a symbol to
be tested for definition as an address label. When
used outside a symbol definition, the prefix or
immediately following constant or parenthetical
expression indicates the number of symbols following
the tested symbol within the current statement which
will be assembled only if the tested symbol is
currently an address label. Since a symbol can at the
same time be both address label and other operator, the
opposite of DIA is DINA (Do If Not Address) instead of
DIO (Do If Other).
DID (Do If Defined) with decimal integer prefix or followed
immediately by a constant or parenthetical expression,
this in turn being followed immediately by a symbol to
be tested for definition as either an address label or
other operator. When used outside a symbol definition,
the prefix or immediately following constant or
parenthetical expression indicates the number of
symbols following the tested symbol within the current
statement which will be assembled only if the tested
symbol is currently defined. An address label
previously referenced by the BIT or LOC operators but
as yet unassigned to a table entry is defined even
though its eventual value is unknown. The opposite of
DID is DIU (Do If Undefined).
DIE (Do If Equal zero) with decimal integer prefix or
followed immediately by a constant or parenthetical
expression, either form being followed immediately by a
possibly signed constant or parenthetical expression
(containing no address labels) of which the value is to
be tested. When used outside a symbol definition, the
prefix or immediately following constant or
parenthetical expression indicates the number of
symbols following the tested constant or expression
within the current statement which will be assembled
only if the tested constant or expression has a value
equal to zero.
Example:
The statements
MULT=2WRD 3 5WRD 1 4 WRD 3-2
2DIE 4PFX-MULT 5 +6
TBLTRN: Language Specification Manual Page 80
Programmed Operators
0PFX DIE MULT MULT 99 22 ...SKIP 99
DIE (MULT+2)(MULT-1) 22+11
66-DIE(3PFX MULT+6) MULT 99+88+22 ...SKIP 99+88+
DIE -MULT -MULT 99+ 55 ...SKIP 99+
assemble table entries containing 11, 22, 33, 44 and
55.
DIG (Do If Greater than zero) with decimal integer prefix
or followed immediately by a constant or parenthetical
expression, either form being followed immediately by a
possibly signed constant or parenthetical expression
(containing no address labels) of which the value is to
be tested. When used outside a symbol definition, the
prefix or immediately following constant or
parenthetical expression indicates the number of
symbols following the tested constant or expression
within the current statement which will be assembled
only if the tested constant or expression has a value
greater than zero.
DIGE (Do If Greater than or Equal zero) with decimal integer
prefix or followed immediately by a constant or
parenthetical expression, either form being followed
immediately by a possibly signed constant or
parenthetical expression (containing no address labels)
of which the value is to be tested. When used outside
a symbol definition, the prefix or immediately
following constant or parenthetical expression
indicates the number of symbols following the tested
constant or expression within the current statement
which will be assembled only if the tested constant or
expression has a value greater than or equal to zero.
DIL (Do If Less than zero) with decimal integer prefix or
followed immediately by a constant or parenthetical
expression, either form being followed immediately by a
possibly signed constant or parenthetical expression
(containing no address labels) of which the value is to
be tested. When used outside a symbol definition, the
prefix or immediately following constant or
parenthetical expression indicates the number of
symbols following the tested constant or expression
within the current statement which will be assembled
only if the tested constant or expression has a value
less than zero.
DILE (Do If Less than or Equal zero) with decimal integer
prefix or followed immediately by a constant or
parenthetical expression, either form being followed
immediately by a possibly signed constant or
parenthetical expression (containing no address labels)
of which the value is to be tested. When used outside
TBLTRN: Language Specification Manual Page 81
Programmed Operators
a symbol definition, the prefix or immediately
following constant or parenthetical expression
indicates the number of symbols following the tested
constant or expression within the current statement
which will be assembled only if the tested constant or
expression has a value less than or equal to zero.
DIN (Do If Not equal zero) with decimal integer prefix or
followed immediately by a constant or parenthetical
expression, either form being followed immediately by a
possibly signed constant or parenthetical expression
(containing no address labels) of which the value is to
be tested. When used outside a symbol definition, the
prefix or immediately following constant or
parenthetical expression indicates the number of
symbols following the tested constant or expression
within the current statement which will be assembled
only if the tested constant or expression has a value
not equal to zero.
DINA (Do If Not Address) with decimal integer prefix or
followed immediately by a constant or parenthetical
expression, this in turn being followed immediately by
a symbol to be tested for definition as an address
label. When used outside a symbol definition, the
prefix or immediately following constant or
parenthetical expression indicates the number of
symbols following the tested symbol within the current
statement which will be assembled only if the tested
symbol is currently not an address label. Since a
symbol can at the same time be both address label and
other operator, the opposite of DINA is DIA (Do If
Address) instead of DINO (Do If Not Other).
DINO (Do If Not Other) with decimal integer prefix or
followed immediately by a constant or parenthetical
expression, this in turn being followed immediately by
a symbol to be tested for definition as other than an
address label. When used outside a symbol definition,
the prefix or immediately following constant or
parenthetical expression indicates the number of
symbols following the tested symbol within the current
statement which will be assembled only if the tested
symbol is currently not an operator other than an
address label. Since a symbol can at the same time be
both address label and other operator, the opposite of
DINO is DIO (Do If Other) instead of DINA (Do If Not
Address).
DIO (Do If Other) with decimal integer prefix or followed
immediately by a constant or parenthetical expression,
this in turn being followed immediately by a symbol to
be tested for definition as other than an address
TBLTRN: Language Specification Manual Page 82
Programmed Operators
label. When used outside a symbol definition, the
prefix or immediately following constant or
parenthetical expression indicates the number of
symbols following the tested symbol within the current
statement which will be assembled only if the tested
symbol is currently an operator other than an address
label. Since a symbol can at the same time be both
address label and other operator, the opposite of DIO
is DINO (Do If Not Other) instead of DIA (Do If
Address).
DIU (Do If Undefined) with decimal integer prefix or
followed immediately by a constant or parenthetical
expression, this in turn being followed immediately by
a symbol to be tested for definition as either an
address label or other operator. When used outside a
symbol definition, the prefix or immediately following
constant or parenthetical expression indicates the
number of symbols following the tested symbol within
the current statement which will be assembled only if
the tested symbol is currently undefined (neither an
address label nor other). An address label previously
referenced by the BIT or LOC operators but as yet
unassigned to a table entry is defined even though its
eventual value is unknown. The opposite of DIU is DID
(Do If Defined).
DMP (DuMP) When used outside a symbol definition, this
operator causes the TBLTRN symbol dictionary to be
printed on the lister device.
DUP (DUPlicate) with decimal integer prefix or followed
immediately by a constant or parenthetical expression
defined as a single entry constant. When used outside
a symbol definition, the set of table entries specified
by the present statement (or by the next if the present
statement does not define a table entry) will be
repeated as a set to produce the number of sets
specified by the decimal integer prefix of, or by the
constant or parenthetical expression which follows, the
DUP operator.
Example:
1BIT ADDRESS 4DUP,ADDRESS 2WRD 2
or
1BIT ADDRESS 4DUP ADDRESS 2WRD 2
or
TBLTRN: Language Specification Manual Page 83
Programmed Operators
1BIT ADDRESS ADDRESS 4DUP 2WRD 2
or
1BIT ADDRESS ADDRESS 2WRD 2 4DUP
assembles the table entries
1
2
1
2
1
2
1
2
EAC (End Automatic Continue) When used outside a symbol
definition, this operator terminates the automatic
continuation specified by the BAC (Begin Automatic
Continuation) operator. After the EAC operator has
been issued, the appearance of a non-text line not tied
to the current statement by the ,, or ,,, operators is
taken as an end of statement. Automatic continuation
would also be terminated by the end of table operators
BLK, SAV and FIN.
END (END) This operator defines end of statement if
necessary, and end of conditional assembly initiated by
an IF class operator such as the IFE (IF Equal zero) or
IFN (IF Not equal zero) operators. An error message is
reported if the number of IF class operators and END
operators do not balance. Conditional assemblies can
be nested but cannot overlap.
EOD (End Ordered Dictionary) When issued outside a symbol
definition, this operator causes all following symbol
definitions by the = or == operators to add the newly
defined symbols, if undefined prior to the definitions,
to the end of the symbol dictionary. Such definitions
are performed more quickly than when the symbols are
inserted into the ordered portion of the symbol
dictionary. Similarly, expunging of symbols within the
unordered portion of the symbol dictionary is quicker,
since garbage collection then does not need to be
performed upon the entire dictionary. However, future
recognition of symbols within the unordered portion of
the symbol dictionary is slower than for symbols within
the ordered portion since the latter is searched first.
The BOD (Begin Ordered Dictionary) operator can be
issued to cause the symbols defined by the = or ==
operators to be inserted into the ordered portion of
the symbol dictionary if not already within the ordered
TBLTRN: Language Specification Manual Page 84
Programmed Operators
portion prior to the definition. Labels, and constants
defined by the DEF, STK and PSH operators, if
previously undefined are always added to the unordered
portion of the symbol dictionary.
FIL (FILl) with decimal integer prefix or followed
immediately by a constant or parenthetical expression.
When used outside a symbol definition, the value of the
the integer prefix or of the following constant or
parenthetical expression is to be taken as the number
of table entries to which the table is filled with
zeroes when output if the table length is less than
this number.
FIN (FINish) When used outside a symbol definition, this
operator writes the final assembled table onto the
output device, writes an end of file on that device and
terminates execution.
HIA (HIgh Address) When used outside a symbol definition,
the following symbol is defined as the address label of
the highest subscript table entry currently assembled,
offset by one less than the value specified by the WRD
operator if used prior to the HIA operator. If the
current statement has not assembled any table entries,
the table entry origin is one entry above the highest
entry previously assembled and this now becomes the the
highest table entry. If the symbol was previously an
address label, its value is merely redefined. If the
symbol is currently also defined as an operator other
than an address label, it will in the future be used as
an address label following the LOC, BIT, XAD, IFA,
IFNA, DIA and DINA operators. Unlike automatic
definition as an address label, the HIA operator and
its following symbol can appear in the statement after
a constant has been assembled following establishment
of the table entry origin.
Example:
MASK=MSK ARG.ARG 2WRD ARG
2WRD HIA SECOND MASK 123 456 789 HIA THIRD
or
MASK=MSK ARG.ARG 2WRD ARG
MASK 123 456 HIA SECOND 2WRD HIA THIRD 789
defines the symbol SECOND to be the address label
of the second assembled table entry (containing
456) and the symbol THIRD to be the address label
of the third assembled table entry (containing
789).
TBLTRN: Language Specification Manual Page 85
Programmed Operators
IFA (IF Address) followed immediately by a symbol to be
tested for definition as an address label. When used
outside a symbol definition, the statements which
follow through the matching END operator will be
assembled only if the following symbol is currently an
address label. Since a symbol can at the same time be
both address label and other operator, the opposite of
IFA is IFNA (IF Not Address) instead of IFO (IF Other).
IFD (IF Defined) followed immediately by a symbol to be
tested for definition as either an address label or
other operator. When used outside a symbol definition,
the statements which follow through the matching END
operator will be assembled only if the following symbol
is currently defined. An address label previously
referenced by the BIT or LOC operators but as yet
unassigned to a table entry is defined even though its
eventual value is unknown. The opposite of IFD is IFU
(IF Undefined).
IFE (IF Equal zero) followed immediately by a possibly
signed constant or parenthetical expression (containing
no address labels) of which the value is to be tested.
When used outside a symbol definition, the statements
which follow through the matching END operator will be
assembled only if the tested constant or expression has
a value equal to zero.
Example:
The following statements assemble table entries
containing the values 1 through 19.
ONE=1,TWO=2
...
...ALL THE TESTS BELOW FAIL BEACUSE THE VALUE
...TESTED IS LESS THAN ZERO OR NOT SPECIFIED.
...
...THE IFE 0,0 END CONDITIONAL IS NOT EXECUTED
...SINCE IT IS WITHIN RANGE OF A TEST WHICH FAILED.
...
1,IFE(ONE-3),0,IFE 0,0 END 0 END 2,IFE END 3
IFE-ONE,0 END 4,IFE(2-5,0 END 5,IFE(ONE-TWO END 6
...
...ALL THE TESTS BELOW SUCCEED EXCEPT FOR THE
...IFE(ONE+1),0 END CONDITIONAL, AND EXCEPT FOR THE
...TEST FOR WHICH TESTED VALUE ISN'T SPECIFIED.
...
IFE-(+ONE 1),7,IFE(ONE+1),0 END 8,IFE END IFE+0,9
END IFE(2-TWO,10 END 11,IFE(5-5 END 12 END
...
...ALL THE TESTS BELOW FAIL BECAUSE THE VALUE
...TESTED IS GREATER THAN ZERO OR NOT SPECIFIED.
TBLTRN: Language Specification Manual Page 86
Programmed Operators
...
13,IFE(3-TWO),0 END 14,IFE END 15,IFE+ONE,0 END 16
17,IFE(-1+2,0 END 18,IFE(ONE+2 END 19
IFG (IF Greater than zero) followed immediately by a
possibly signed constant or parenthetical expression
(containing no address labels) of which the value is to
be tested. When used outside a symbol definition, the
statements which follow through the matching END
operator will be assembled only if the tested constant
or expression has a value greater than zero.
IFGE (IF Greater than or Equal zero) followed immediately by
a possibly signed constant or parenthetical expression
(containing no address labels) of which the value is to
be tested. When used outside a symbol definition, the
statements which follow through the matching END
operator will be assembled only if the tested constant
or expression has a value greater than or equal to
zero.
IFL (IF Less than zero) followed immediately by a possibly
signed constant or parenthetical expression (containing
no address labels) of which the value is to be tested.
When used outside a symbol definition, the statements
which follow through the matching END operator will be
assembled only if the tested constant or expression has
a value less than zero.
IFLE (IF Less than or Equal zero) followed immediately by a
possibly signed constant or parenthetical expression
(containing no address labels) of which the value is to
be tested. When used outside a symbol definition, the
statements which follow through the matching END
operator will be assembled only if the tested constant
or expression has a value less than or equal to zero.
IFN (IF Not equal zero) followed immediately by a possibly
signed constant or parenthetical expression (containing
no address labels) of which the value is to be tested.
When used outside a symbol definition, the statements
which follow through the matching END operator will be
assembled only if the tested constant or expression has
a value not equal to zero.
IFNA (IF Not Address) followed immediately by a symbol to be
tested for definition as an address label. When used
outside a symbol definition, the statements which
follow through the matching END operator will be
assembled only if the following symbol is currently not
an address label. Since a symbol can at the same time
be both address label and other operator, the opposite
of IFNA is IFA (IF Address) instead of IFNO (IF Not
TBLTRN: Language Specification Manual Page 87
Programmed Operators
Other).
IFNO (IF Not Other) followed immediately by a symbol to be
tested for definition as other than an address label.
When used outside a symbol definition, the statements
which follow through the matching END operator will be
assembled only if the following symbol is currently not
an operator other than an address label. Since a
symbol can at the same time be both address label and
other operator, the opposite of IFNO is IFO (IF Other)
instead of IFNA (IF Not Address).
IFO (IF Other) followed immediately by a symbol to be
tested for definition as other than an address label.
When used outside a symbol definition, the statements
which follow through the matching END operator will be
assembled only if the following symbol is currently an
operator other than an address label. Since a symbol
can at the same time be both address label and other
operator, the opposite of IFO is IFNO (IF Not Other)
instead of IFA (IF Address).
IFU (IF Undefined) followed immediately by a symbol to be
tested for definition as either an address label or
other operator. When used outside a symbol definition,
the statements which follow through the matching END
operator will be assembled only if the following symbol
is currently undefined (neither an address label nor
other). An address label previously referenced by the
BIT or LOC operators but as yet unassigned to a table
entry is defined even though its eventual value is
unknown. The opposite of IFU is IFD (IF Defined).
INC (INCrement) with decimal integer prefix or followed
immediately by a constant or parenthetical expression,
either designation being in turn followed by a symbol
defined as a single entry constant. When used outside
a symbol definition, the value of the final argument is
incremented by the value of the decimal integer prefix
of the INC operator or by the value of the constant or
parenthetical expression immediately following the INC
operator if a decimal integer prefix is not present.
Example:
DEF DEC 25 A INC(5-3)A
would define the symbol A to be a constant with the
value decimal 27.
IOR (Inclusive OR) The next constant or address
encountered after this operator within the present
statement is to be inclusively ORed into the constant
TBLTRN: Language Specification Manual Page 88
Programmed Operators
or table entry being currently defined. The IOR
operator can be used to force inclusive ORing when this
operation would not be the default if no sign is given.
After the inclusive OR operation, all bits originally
turned on (set to one) in the item being defined remain
on and, in addition, the item being defined has turned
on all bits which were on in the item being ORed with
the item being defined.
Example:
OCT 25 IOR OCT 72
and
10SIZ 2TRX 1001 1001 1001 1001 1001 1001 1001
both assemble table entries with the value octal 77
(decimal 63) since the default sign is addition
when the packing size is 10.
JST (JuSTify) with decimal integer prefix or followed
immediately by a constant or parenthetical expression.
When used outside a symbol definition, the value of the
integer prefix or following expression selects the
justification of the numeric portion of the text by
which the NST operator replaces itself. If the JST
operator has been used with a zero value, or has not
been used at all, since the last appearance of the NST
operator, the numeric portion of the text by which NST
replaces itself will appear as a numeric suffix
following the text selected by the NSN operator without
any inserted blanks. If the JST operator has instead
been used with a positive non-zero value since the last
appearance of the NST operator, the text by which the
next use of the NST operator will replace itself will
have the numeric portion right justified in a field of
the width selected by the JST operator. If the numeric
portion has fewer characters than the field width, this
numeric portion is right justified by the insertion of
extra blanks following the text selected by NSN. If
this numeric portion has more characters than the
selected field width, the left (most significant)
characters will be discarded.
LFT (LeFT shift) with decimal integer prefix or followed
immediately by a constant or parenthetical expression.
The value of the integer prefix or of the following
constant or parenthetical expression is to be taken as
the number of bytes which the next constant is to be
shifted to the left before being assembled into the
table entry or symbol currently being defined.
TBLTRN: Language Specification Manual Page 89
Programmed Operators
Example:
10SIZ 2LFT 2
or
SIZ 10 LFT 2 2
assemble table entry with the value decimal 200 (2
left shifted 2 units of 10 each).
LMT (LiMiT) with decimal integer prefix or followed
immediately by a constant or parenthetical expression.
When used outside a symbol definition, the value of the
decimal integer prefix or of the following constant or
parenthetical expression is to be taken as the maximum
number of text replacements which can be performed in a
single input line. If the value of the following
constant or expression is negative, its absolute value
is taken as the limit, and a trace of text replacements
is written on the listing device. Processing of the
line will be terminated if this limit is exceeded. The
default limit at the start of each table is 1000. Each
replacement within a statement containing a syntax
error is counted as 100 replacements.
LOA (LOw Address) When used outside a symbol definition,
the following symbol is defined as the address label of
the lowest table entry assembled by the present
statement, offset by one less than the value specified
by the WRD operator if used prior to the LOA operator.
If the current statement has not assembled any table
entries, the table entry origin is one entry above the
highest entry previously assembled and this now becomes
the lowest table entry assembled by the current
statement. If the symbol was previously an address
label, its value is merely redefined. If the symbol is
currently also defined as an operator other than an
address label, it will in the future be used as an
address label following the LOC, BIT, XAD, IFA, IFNA,
DIA and DINA operators. Unlike automatic definition as
an address label, the LOA operator and its following
symbol can appear in the statement after a constant has
been assembled following establishment of the table
entry origin.
Example:
MASK=MSK ARG.ARG 2WRD ARG
3WRD LOA THIRD MASK 123 456 789 2WRD LOA SECOND
defines the symbol SECOND to be the address label
of the second assembled table entry (containing
TBLTRN: Language Specification Manual Page 90
Programmed Operators
456) and the symbol THIRD to be the address label
of the third assembled table entry (containing
789).
LOC (LOCation) When used outside a symbol definition, the
symbol following this operator is to be treated as a
constant having as its value the location within the
table of the entry for which it is the label. The
current table entry always has as its label the
operator . (single period) so that it is not necessary
to label each entry which is to contain its own
address. The construction LOC. is accepted although
LOC is not here necessary. It should be noted that
address labels (or a single period as an address label)
cannot be used in a symbol definition.
Example: Table starting
ADDRESS LOC ADDRESS
LOC .
.
2SIZ 2LFT LOC ADDRESS
assembles table entries
1
2
3
4
LST (LiST) When used outside a symbol definition, this
operator causes the assembled table entries to be
printed on the lister device.
MSK (MaSK) A null packing pattern having no arguments.
This is used to terminate the range of a packing
pattern which the TON operator has directed will apply
to all following table entries. Since packing patterns
can only be defined in terms of previously defined
patterns, MSK is also necessary for the initial user
definition of such patterns.
Example:
MASK=MSK 100SIZ 1LFT ARG ARG
TON MASK 1 2
3 4 MSK
506
assembles table entries
102
304
TBLTRN: Language Specification Manual Page 91
Programmed Operators
506
NEG (NEGative) A single precision constant having the sign
bit a one (turned on) and all other bits zeroed.
NSN (Numeric Symbol Name) When used outside a symbol
definition, the non-blank characters of the following
text string are taken as the basic name (prefix) of the
symbol by which the NST (Numeric Symbol Text) operator
replaces itself. The text string must be of 6 or fewer
non-blank characters, be initiated by ' or '' operator
and, following this operator, be enclosed within
delimiter characters which are otherwise ignored.
NST (Numeric Symbol Text) replaces itself in any
environment, except within the range of an unfulfilled
IF or Do-If class operator, by a symbol constructed of
a text name with a decimal integer suffix. The text
name is established by the NSN (Numeric Symbol Name)
operator and the value of the numeric suffix is
specified by the NSV (Numeric Symbol Value) operator.
NST is one of the few operators which cannot be
expunged from the symbol dictionary. A statement of
the form XSY NST or XAD NST instead expunges the
non-address or address meanings respectively of the
symbol by which NST replaces itself. See also JST.
Example:
NSN'+A+10NSV XSY NST
expunges the non-address meaning, if any, of the
symbol A10 from the TBLTRN symbol dictionary.
Normally, the numeric suffix would be indicated by
a non-negative constant or parenthetical expression
immediately following the NSV operator so that this
suffix can be calculated.
NSV (Numeric Symbol Value) with decimal integer prefix or
followed immediately by a constant or parenthetical
expression. When used outside a symbol definition, the
integer prefix or the value of the following constant
or parenthetical expression is taken as the numeric
suffix of the symbol by which the NST (Numeric Symbol
Text) operator replaces itself. The default value is
zero at the start of each table.
NUL (NULl) This operator acts as a null or single
precision zero valued argument during the use of a
packing pattern or during the definition of an
automatic argument of a packing pattern, and is
equivalent to the operator pair (). The form (NUL) is
acceptable, but the trailing parenthesis is necessary
TBLTRN: Language Specification Manual Page 92
Programmed Operators
only if a leading parenthesis is used. NUL acts as a
zero when used with or without the WRD operator in the
definition of a constant or of a table entry. NUL
cannot be used to specify the value of an operator
which could have taken an integer prefix but did not.
Example:
MASK=MSK 100SIZ 2LFT ARG 1LFT ARG ARG
TON MASK ( ) 1 2
(NUL) 3 4
NUL (5) 6
NUL 7 8
NUL NUL 910
or
MASK1=MSK 100SIZ 2LFT ARG NUL 1LFT ARG ARG
MASK2=MSK 100SIZ 1LFT ARG 2LFT ARG(NUL)ARG
MASK3=MSK 100SIZ 2LFT ARG()1LFT ARG ARG
MASK4=MSK 100SIZ 1LFT ARG ARG 2LFT ARG()
MASK5=MSK 100SIZ 1LFT ARG ARG 2LFT ARG NUL
MASK1 1 2
MASK2 3 4
MASK3 5 6
MASK4 7 8
MASK5 9 10
assembles table entries
102
304
506
708
910
OCT (OCTal) The next integer after this operator in the
current statement is to be evaluated as octal (that is,
with radix 8). The symbol will be tagged as illegal if
it contains the digits 8 or 9.
PFX (PreFiX) with decimal integer prefix or followed
immediately by a constant or parenthetical expression.
The value of the integer prefix or of the following
constant or parenthetical expression is to be taken as
the precision of the single entry of a single or
multiple entry non-integer constant which is to be
taken as its value when such a constant is used after
any operator which could have taken a decimal integer
prefix, but which did not. A zero value of the prefix
of the PFX operator or of the constant or parenthetical
expression following it specifies that the value of a
non-integer constant used after an operator which could
TBLTRN: Language Specification Manual Page 93
Programmed Operators
have taken a decimal integer prefix, but which did not,
is to be the value of its highest precision entry. The
latter option, the value being that of the highest
precision entry, is the default at the start of each
table. A negative value of the prefix of the PFX
operator or of the constant or parenthetical expression
following it specifies that the value of a non-integer
constant used after an operator which could have taken
a decimal integer prefix, but which did not, is to be
its precision. The last option, the value being the
precision, continues only through the end of the
current statement at which point the PFX option
previously in effect is reinstated. Similarly, the PFX
option selected prior to a symbol definition is
reinstated at the end of the definition so that effect
of PFX operators within a symbol definition is entirely
local to that definition.
POP (POP) followed immediately by a symbol which is defined
as a constant, or which is defined only as an address
label, or which is currently undefined. When used
outside a symbol definition, the high precision entry
of the following constant is deleted. If the constant
previously was of single precision, its definition as a
constant is deleted from the symbol dictionary. The
symbol following the POP operator is left unchanged if
it previously was either undefined or only an address
label.
PSH (PuSH) with decimal integer prefix or followed
immediately by a constant or parenthetical expression,
either designation being in turn followed by a symbol
which is defined as a constant, or which is defined
only as an address label, or which is currently
undefined. If undefined or merely an address label,
the final argument of the PSH operator is defined,
without altering the possible address label definition,
as a single precision constant having the value of the
decimal integer prefix of the PSH operator or of the
constant or parenthetical expression immediately
following the PSH operator if a decimal integer prefix
is not present. If the final argument is instead
already a constant, the value of the decimal integer
prefix of the PSH operator, or of the constant or
parenthetical expression following the PSH operator if
a decimal integer prefix is not present, is placed into
the precision 1 entry of the constant after
incrementing by one the precision of the previously
defined entries. The PSH operator is used only outside
symbol definitions.
RED (REDuce) with decimal integer prefix or followed
immediately by a constant or parenthetical expression,
TBLTRN: Language Specification Manual Page 94
Programmed Operators
either designation being in turn followed by a symbol
defined as a single entry constant. When used outside
a symbol definition, the value of the final argument is
decremented by the value of the decimal integer prefix
of the RED operator or by the value of the constant or
parenthetical expression immediately following the RED
operator if a decimal integer prefix is not present.
RIT (RIghT shift) with decimal integer prefix or followed
immediately by a constant or parenthetical expression.
Identical to LFT except that the shift is to the right.
Example:
10SIZ 1RIT 1020
2RIT 30400
3RIT 506000
assembles table entries
102
304
506
ROT (ROTate) followed immediately by a symbol which is
defined as a constant, or which is defined only as an
address label, or which is currently undefined. When
used outside a symbol definition, the precisions of all
entries of the following constant are incremented by
one and the highest precision entry is made the new
precision 1 entry. The final precision of the constant
is not changed. The symbol following the ROT operator
is left unchanged if it previously was either undefined
or only an address label.
SAV (SAVe) When used outside a symbol definition, this
operator writes the table which has been assembled onto
the output device, removes all labels from the TBLTRN
symbol dictionary (but does not restore this dictionary
to its original condition), and begins reading of the
next table to be assembled. All symbols defined by the
=, ==, DEF, PSH and STK operators and all character
classes defined by the ACC operator are retained.
Symbols which have been removed by the XSY operator are
not restored. The final table to be assembled must be
terminated by a FIN operator rather than by the BLK or
SAV operators.
SFT (ShiFT) with decimal integer prefix or followed
immediately by a constant or parenthetical expression,
either designation being in turn followed by a symbol
defined as a single entry constant. When used outside
a symbol definition, the value of the final argument is
TBLTRN: Language Specification Manual Page 95
Programmed Operators
left shifted the number of bytes specified by the
integer prefix of the SFT operator or by the constant
or parenthetical expression immediately following the
SFT operator if a decimal integer prefix is not
present. Right shifts are specified as a negative
number of bytes. The byte size is that specified by
the SIZ operator.
SIZ (SIZe) with decimal integer prefix or followed
immediately by a constant or parenthetical expression.
The decimal integer appearing as prefix or the
following constant or parenthetical expression is to be
taken as the byte size for shifting by the LFT, RIT and
SFT operators. Appearance of the SIZ operator with
integer prefix or following constant or following
expression within a symbol definition specifies the
byte size only for the remainder of the definition. If
the byte size is changed outside a symbol definition,
it remains at the new value until changed again or
until the end of the table at which time it is reset to
its default value of 2. The base (the smallest number
which when raised to some power equals the byte size)
of the byte size cannot exceed 17 when an address
defined later in the table is referenced or when a
packing pattern is being defined. The byte size is
really the largest number plus one which can be packed
per byte without overflowing. If the byte is to be 6
bits long, the byte size is decimal 64 which is stored
internally by the program as 2**6 when the 64SIZ
operator is encountered. If the packing is to be one
item per 3 decimal digits, the byte size is decimal
1000 which would be indicated by the 1000SIZ operator
and would be stored internally as 10**3 (note that the
base of the byte size is 10 not 1000). It should be
noted that the largest byte size which can be indicated
by a decimal integer prefix is 100000. This
restriction does not apply to byte sizes indicated by a
symbol following the SIZ operator.
SRX (Symbol RadiX) with decimal integer prefix or followed
immediately by a constant or parenthetical expression.
The value of the decimal integer appearing as prefix or
of the following constant or parenthetical expression
is to be taken as the radix of integers appearing
within symbol definitions. Appearance of a symbol
radix designation within a symbol definition specifies
the radix only for the remainder of the definition. If
the symbol radix is changed outside a symbol
definition, it remains at the new value until changed
again or until the end of the table at which time it is
reset to its default value of 10. The specified radix
must be in the range 2 through 16. Care should be
taken if the radix is greater than 10 since some
TBLTRN: Language Specification Manual Page 96
Programmed Operators
operator names will then be treated as constants.
Example:
10TRX,10SRX,D=DUP,SYMBOL=10D
defines SYMBOL as an operator which could be used
to specify that the table entries assembled by the
current or following statement be considered to
appear 10 times. However, under a symbol radix of
16, SYMBOL would become a constant with the value
1*16*16+0*16+13.
STK (STacK) with decimal integer prefix or followed
immediately by a constant or parenthetical expression,
either designation being in turn followed by a symbol
which is defined as a constant, or which is defined
only as an address label, or which is currently
undefined. If undefined or merely an address label,
the final argument of the STK operator is defined,
without altering the possible address label definition,
as a single precision constant having as value the
value of the decimal integer prefix of the STK operator
or of the constant or parenthetical expression
immediately following the STK operator if a decimal
integer prefix is not present. If the final argument
is instead already a constant, the value of the decimal
integer prefix of the STK operator, or of the constant
or parenthetical expression following the STK operator
if a decimal integer prefix is not present, is placed
into a new entry, of the constant, having a precision 1
greater than the previous high precision entry of the
constant. The STK operator is used only outside symbol
definitions.
TEL (TELl) When used ouside a symbol definition, all
available information about all symbols between this
operator and the end of the statement (as indicated by
the end of the line or by the , or END operators which
like the ' '' ,, ,,, and ... operators cannot be
arguments of the TEL operator) will be listed on the
teletype in debugging format. Integers are used within
the range of the TEL operator to request the contents
of a particular previously assembled table entry.
Decimal integers with asterisk (or any character placed
into the class originally containing the asterisk)
suffixes are used within the range of the TEL operator
to identify the initially defined operators having the
indicated operator identifier codes. It should be
noted that these integer-asterisk combinations are
identical to the indicated operators and so cannot be
used to identify operators such as ' '' , ,, ,,, ... or
END. No harm results from requesting information about
TBLTRN: Language Specification Manual Page 97
Programmed Operators
symbols not contained in the symbol dictionary since
such symbols are merely listed as undefined and, though
entered into the symbol dictionary, are removed the
next time any item is appended to the dictionary.
Use of the NST operator within the range of the TEL
operator will report the definition of the symbol with
which NST replaces itself. Other text replacement
operators appearing within the range of the TEL
operator do not replace themselves, so the definitions
of such symbols can be determined.
Example:
TEL 1 2 3 LOC .
would list the contents of table entries 1, 2 and 3
and would list the contents of the symbol
dictionary pertaining to symbols LOC and . (single
period).
The integer zero can be used anywhere within the range
of the TEL operator to cause the definitions of the
remaining items to be written on the listing device in
a storage word by storage word format. This listing
device output is continued through the end of the range
of the TEL operator or through the next appearance of
the integer zero within its range.
TON (Turn ON) When used outside a symbol definition, the
packing pattern which follows the TON operator is to
apply to all following table entries until control is
transferred to the next packing pattern encountered
outside a symbol definition or until canceled by a null
packing pattern such as MSK. Packing patterns indicate
the positions into which items in a table entry or
symbol definition are to be assembled by shifting and
how these are to be inserted (by addition, subtraction
or inclusive ORing). Selecting a packing pattern with
the TON operator does not itself generate a table entry
even if the packing pattern has an initial automatic
argument unless the statement also contains a constant,
address label or BIT operator with the current table
entry as destination. In contrast, local selection
(selction neither by the TON operator nor by being
within the range of a packing pattern selected by the
TON operator) of a packing pattern which has an initial
automatic argument does generate a table entry or
entries containing the automatic argument even if the
statement contains nothing else.
TRX (Table RadiX) with decimal integer prefix or followed
immediately by a constant or parenthetical expression.
TBLTRN: Language Specification Manual Page 98
Programmed Operators
When used outside a symbol definition, the value of the
decimal integer appearing as prefix or of the following
constant or parenthetical expression is to be taken as
the radix of integers appearing within statements which
define table entries. The specified radix must be in
the range 2 through 16. Care should be taken if the
radix is greater than 10 since some operator names
could then be interpreted as integers. The radix used
within statements which define table entries is reset
to 10 at the start of each table.
Example:
10TRX,D=DUP,10D
specifies that the set of table entries assembled
by the next statement is to be duplicated as a set
so as to appear 10 times. However, under a table
radix of 16, the statement 10D would instead
specify a single table entry with the value
1*16*16+0*16+13.
TST (TeST) with decimal integer prefix or followed
immediately by a constant or parenthetical expression.
This operator is reserved for use in test tables. When
used outside a symbol definition, the value of the
decimal integer appearing as prefix or of the following
constant or expression is to be taken as the length of
the upper section of the present table. The BLK, SAV
or FIN operator at the end of the present table will
call subroutine DACOMP rather than output a DATA
statement. DACOMP reports any differences between the
upper and lower sections of the assembled table.
TTL (TiTLe) When used outside a symbol definition, the
non-blank characters of the following text string are
taken as the name of the array containing the assembled
table entries in the DATA statements generated as final
output. This text string must be of 6 or fewer
non-blank characters and must be initiated by the ' or
'' operator and, following this operator, be enclosed
within delimiter characters which are otherwise
ignored. The default name used in these DATA
statements is TBLTRN.
TTY (TeleTYpe) When used outside a symbol definition, this
operator causes control to be switched between input
file and teletype to allow execution time modification
of assembly such as the definition of constants which
are used to select conditional assemblies. The input
file always has control initially. Control is
transferred back to the input file by typing the TTY
operator on the teletype. Additional statements can
TBLTRN: Language Specification Manual Page 99
Programmed Operators
follow the TTY control transfer statement on the same
input line on either device. Usually the TTY operator
is given as a separate statement. If issued outside a
symbol definition it will, however, terminate the
current statement before causing the control transfer.
Example: If the user desires no interaction for the
first 3 control transfers to the teletype, he might
type either
TTY,TTY,TTY
or
TTY
TTY
TTY
WID (WIDth) with decimal integer prefix or followed
immediately by a constant or parenthetical expression.
When used outside a symbol definition, the value of the
decimal integer appearing as prefix or of the following
constant or parenthetical expression is to be taken as
the width in characters of the DATA statements
generated as output. The width stated in this manner
cannot be greater than 66. The leading 6 characters in
each output line are not included in this count.
WRD (WoRD) with decimal integer prefix or followed
immediately by a constant or parenthetical expression.
The integer appearing as prefix or the following
constant or parenthetical expression specifies the nth
word of a multiple precision table entry. This
operator can be used before an address label, constant
or the BIT operator. Used before an address label, the
WRD operator indicates that the address label is the
name of the nth-1 table entry beyond the current table
entry origin. Before a constant, the WRD operator
directs that the constant be assembled into the nth-1
table entry beyond the current table entry origin.
Before a BIT operator, the WRD operator specifies that
the bit selected is to be turned on in the nth-1 word
following the table entry having the address label
which follows the BIT operator. The WRD operator can
also appear in the definition of a constant to specify
that the constant will be assembled into the nth-1
table entry beyond the table entry origin of the
statement in which it is used.
XAD (eXpunge ADdress) When used outside a symbol
definition, the address definitions, if any, of all
symbols (except for the , ,, ,,, ' '' ... and END
operators which cannot be given address meanings)
TBLTRN: Language Specification Manual Page 100
Programmed Operators
between this operator and the end of the statement, as
indicated by the , or END operators or the next
non-continuation line, are removed from the TBLTRN
symbol dictionary. A request for removal of a symbol
without an address definition is ignored. Both the NST
operator and symbols defined as text strings are
replaced within the range of the XAD operator. If a
symbol is defined as both an address label and as a
text string, the text string replacement is performed
within the range of the XAD operator rather than the
address meaning being removed.
XOR (eXclusive OR) The next constant or address
encountered after this operator within the present
statement is to be exclusively ORed into the constant
or table entry or operator value being currently
defined. After the exclusive OR operation, the only
bits which are turned on (set to one) in the item being
defined are those bits which were originally on either
in the item being defined or in the item being XORed
with the item being defined but not in both.
Example:
OCT 27 XOR OCT 72
assembles a table entry containing octal 55.
XSY (eXpunge SYmbol) When used outside a symbol
definition, the non-address definitions of all symbols
(except for the , ,, ,,, ' '' ... and END operators
which cannot be arguments of the XSY operator) between
this operator and the end of the statement, as
indicated by the , or END operators or the next
non-continuation line, are removed from the TBLTRN
symbol dictionary. A request for removal of a symbol
without a non-address definition is ignored. The NST
(Numeric Symbol Text) operator is replaced within the
range of the XSY operator by the symbol defined by the
NSN and NSV operators, but symbols defined as text
strings are not replaced by these text strings. This
allows the removal of calculated (numeric suffix)
symbols and of text string symbols (in the latter case,
without removing whatever symbols might happen to be
named within the text definition).
Example:
NAME='/NSN'+A+/,VALUE=0NSV
NAME VALUE XSY BIT XSY LFT NAME VALUE NST
would remove the symbols BIT, XSY, LFT, NAME, VALUE
and A0 from the symbol dictionary.
TBLTRN: Language Specification Manual Page 101
Programmed Operators
Symbol Definitions
------ -----------
Symbols not currently in the symbol dictionary are defined
in statements having the structure
PART1 PART2 PART3
in which
PART1 (optional) is any IF class operator followed by
the symbol, possibly signed constant or expression to be
tested.
PART2 is the symbol being defined followed by either of
the operators = or ==. With the exception of the
... ,,, and ,, operators, only a symbol defined as
either a null text string or as a deferred insertion
text string can appear before the symbol being defined,
or between the symbol being defined and the = or ==
operators. The symbol being defined must currently be
defined as a packing pattern or a constant or as only an
address label or be undefined. Other operators cannot
be redefined unless first removed from the symbol
dictionary by the XSY operator. Packing patterns and
constants can be redefined in terms of their values
prior to the present definition. If the symbol is
currently an address label, this definition is
maintained concurrent to the new definition.
The operators = and == are equivalent if the currently
selected input device is the teletype. The definition
always appears to the right of the = operator on the
currently selected input device. If the currently
selected input device is not the teletype, the ==
operator temporarily transfers control to the teletype,
prompts the user for the desired definition, and
transfers control back to the previous input device when
the definition has been stated in terms of other than
null text replacement (transparent) operators. Transfer
of control between input devices is always made to the
next character in the current line, not to the next line
so it is possible (though not desirable due to
likelihood of user error) for several teletype input
definitions to appear on a single line.
PART3 (optional if the symbol is to be defined as a null
text string operator and the == operator has not been
used while the teletype is the deselected input device)
can be any of the following
1. Any single currently defined operator except ' '' ,
,, ,,, ... and END. A context dependent definition
TBLTRN: Language Specification Manual Page 102
Symbol Definitions
of this operator as an address label, if any, is
ignored. If this operator is a packing pattern of
which the first argument is automatic, the symbol
left of the = or == operator will be defined as a
constant having the value of this automatic
argument. An operator which has been defined as a
text string will be replaced by that text string
within the definition. The operator NST will be
replaced by a symbol constructed of the text and
number suffix previously defined by the NSN and NSV
operators respectively (TBLTRN0 is the default).
2. Any of the operators BIT BPR BSZ CLM DEF DIA DID DIE
DIG DIGE DIL DILE DIN DINA DINO DIO DIU DUP FIL INC
JST LFT LMT NSV PFX PSH RED RIT SFT SIZ SRX STK TRX
TST WID or WRD with a decimal integer prefix or
followed immediately by a constant or parenthetical
expression. The following definitions are legal
(assuming that the symbol I8 has been defined as the
number 8 as in the statement I8=DEC 8).
BASE8=SIZ I8
BASE64=64SIZ
BASE64=SIZ 64
BASE64=SIZ(56+8)
BASE64=SIZ(56+I8)
BASE64=SIZ(I8+56)
BASE64=SIZ OCT 100
BASE64=SIZ 8SRX 100
BASE64=SIZ(OCT 70+I8)
BASE64=SIZ(I8+OCT 70)
BASE64=SIZ+(I8 OCT 70)
BASE64=SIZ+(I8 I8 I8 I8 I8 I8 I8 I8)
As is similarly the case for statements which define
table entries, it is not necessary that a
parenthetical expression be terminated by a right
parenthesis if nothing else appears after the
expression in the statement. (Note, however, that a
final null automatic argument of a packing pattern
cannot be defined merely by the use of a left
parenthesis following the ARG operator.)
3. Any previously defined packing pattern of which the
first argument, if any, is not automatic.
Definition in terms of a packing pattern having an
initial argument which is automatic is ambiguous
since any definition, which would assemble a table
entry or entries if not within the range of the = or
== operators, is taken as a definition of a
constant.
TBLTRN: Language Specification Manual Page 103
Symbol Definitions
4. Any previously defined packing pattern followed by
any sequence of previously defined packing patterns
and/or new packing pattern definitions consisting of
argument packing specifications and/or origin
increment specifications. Anywhere within the
definition, use of a previously defined packing
pattern having an initial argument which is
automatic will change the definition to definition
of a constant. The new packing pattern definitions
can consist of any of the following.
A. The operators SIZ and SRX with decimal integer
prefix or followed immediately by a constant or
parenthetical expression. When used within a
symbol definition, these operators modify the
byte size and radix respectively for the
remainder of the defintion.
B. The . (single period) operator optionally
preceded by the WRD operator with decimal
integer prefix or by the WRD operator
immediately followed by a constant or
parenthetical expression. This indicates that
the table entry origin of the statement in which
the packing pattern is used is to be incremented
by one table entry if the WRD operator was not
used, or by the number of entries specified by
the WRD operator. This increment is performed
only if there remains yet unprocessed in the
statement, before the selection of another
packing pattern if any, an address label or
constant or BIT operator with the destination
being a table entry already assembled by the
current statement.
C. Directions for assembly of an argument of the
packing pattern being defined. These directions
consist of the required symbol ARG preceded in
any order by optional specification of word and
byte into which and of sign with which the
argument is to be assembled. The optional word
count is specified by the WRD operator with
decimal integer prefix or followed immediately
by a constant or parenthetical expression. The
optional byte specification is specified by the
shift operator LFT or RIT with decimal integer
prefix or followed immediately by a constant or
parenthetical expression. The optional sign is
specifed by one of the operators + - XOR IOR or
AND. The default word count and byte are 1WRD
and 0LFT or 0RIT. The default sign is IOR if
the byte size at the time of the definition is 2
raised to some power, otherwise the default sign
TBLTRN: Language Specification Manual Page 104
Symbol Definitions
is +.
D. Definition of an automatic argument of the
packing pattern. The value of such an automatic
argument is specified following the ARG
operator. When the packing pattern being
defined is used, the value of the present
argument will be taken from the definition of
the packing pattern rather than from the
statement in which the packing pattern is used.
The value of the automatic argument can be
specified either by an integer or a symbol
defined as a constant. Radix change
specification can be used prior to the ARG
operator, or after the ARG operator prior to the
integer. The symbol defined as a constant can
be multiple entry. If the value must be defined
as more than a single integer or constant, the
group of integers and/or constants must be
enclosed within parentheses. If the sign is
changed within these parentheses, it is restored
to its original value after the following
integer or constant. Word count and Byte cannot
be altered from the value specified prior to the
ARG operator.
The null packing pattern MSK must be the first
non-null operator appearing in the definition of the
first packing pattern defined by the user. The
following definitions are legal.
PATTERN1=MSK 64SIZ ARG 1LFT ARG 2LFT ARG
PATTERN2=MSK 64SIZ 3LFT ARG 4LFT ARG 5LFT ARG
PATTERN3=PATTERN1 PATTERN2
PATTERN3 is defined by the above statements to be a
packing pattern which directs that its first
argument be inclusive ORed (the default if base of
the byte size is 2) and right justified, that its
second argument be inclusive ORed after being
shifted left 6 bits, similarly on through the sixth
argument which is inclusive ORed after being shifted
left 30 bits.
If instead, the first 3 arguments were to be added
and the second 3 arguments were to be subtracted, a
possible definition would be
PATTERN3=MSK 64SIZ+ARG+1LFT ARG+2LFT ARG-3LFT
ARG-4LFT ARG-5LFT ARG
The byte size in effect at the start of any
definition is the last byte size which was defined
TBLTRN: Language Specification Manual Page 105
Symbol Definitions
by a SIZ operator outside a symbol definition. The
default value of the byte size at the start of each
table is 2. The specification of the packing of an
argument of the packing pattern being defined is
complete only when the ARG operator has been given.
Therefore, PATTERN4 would be a null packing pattern
identical to MSK if defined as follows.
PATTERN4=MSK+2LFT 5WRD
5. The definition of a constant formed from any of the
following parts in any meaningful order. In
general, the definition of a constant follows the
same rules as the definition of table entries.
A. The operators SIZ and SRX with decimal integer
prefix or followed immediately by a constant or
parenthetical expression. When used within a
symbol definition, these operators modify the
byte size and radix respectively for the
remainder of the definition.
B. The name of a packing pattern which specifies
how the following constant phrases are to be
packed to form the constant currently being
defined.
C. A constant phrase constructed according to the
rules listed in the next section, except that
address labels cannot be used. A symbol
previously defined as a constant can be
redefined in terms of its former value.
The statements
ABC=3WRD 15
GHI=3
GHI=WRD GHI 15
JKL=ABC
MNO=3WRD OCT 17
PQR=8SRX 3WRD 17
define the symbols ABC, GHI, JKL, MNO and PQR as
constants with the value decimal 15 which would be
deposited into the 2nd table entry beyond the table
entry origin of the statement in which they are
used.
ABC=MSK 2WRD ARG 3WRD ARG 4WRD ARG 5WRD ARG
ABC=ABC 11 22 33 44
GHI=2WRD 11 3WRD 22 4WRD 33 5WRD 44
JKL=MSK 3WRD ARG 5WRD ARG 2WRD ARG
JKL=4WRD 33 JKL 22 44 11
TBLTRN: Language Specification Manual Page 106
Symbol Definitions
MNO=3WRD 33 2WRD 22
MNO=5WRD 44 2WRD 11 2WRD MNO
PQR=ABC
The above statements define the symbols ABC, GHI,
JKL, MNO and PQR as constants each having the set of
values decimal 11 which would be deposited into the
1st table entry, decimal 22 which would be deposited
into the 2nd table entry, decimal 33 which would be
deposited into the 3rd table entry and decimal 44
which would be deposited into the 4th table entry
beyond the table entry origin of the statement in
which they are used.
PATTERN=MSK 10SIZ 1LFT ARG ARG
I1=1,I2=I1+I1,I3=1+I2
ABC=2LFT 10SIZ I1 1LFT I2 I3
GHI=PATTERN I2 I3 10SIZ 2LFT I1
JKL=10SIZ 2LFT I1 PATTERN(I1+I1)(I1+I1+I1)
MNO=PATTERN OCT 14 I3
PQR=8SRX PATTERN 14 I3
The above statements define the symbols ABC, GHI,
JKL, MNO and PQR as constants with the value decimal
123 which would be deposited into the table entry
origin of the statement in which they are used. The
WRD operator (with integer prefix or immediately
following constant or parenthetical expression)
could have been used within the definition of the
packing pattern, or prior to the constants not used
as packing pattern arguments, to alter the offset,
from the table entry origin, of the table entry or
entries into which the constant being defined would
be assembled.
6. Any text string following the ' or '' operators and
delimited at both ends by any delimiter character
which is otherwise ignored. The end of the current
line is taken as the end of the text string if the
second appearance of the delimiter character is not
found. After the definition has been completed, the
symbol will be replaced by the text string wherever
encountered except within the range of the TEL, XSY,
or unfulfilled IF or Do-If class operators. Any
symbols in the text string following the '' operator
which are not within the original TBLTRN symbol
dictionary, and all symbols appearing in the text
string following the ' operator, must have meaning
when the text replacement is made regardless of
their meaning at the time the definition as the text
string is made. Each letter of the text string
requires a word of storage space. Except for
symbols which are to be identical to a previously
TBLTRN: Language Specification Manual Page 107
Symbol Definitions
defined single packing pattern or single multiple
entry constant, definition as a text string should
not be used if the definition can be made directly.
The text string can be preceded in the definition by
an argument count constructed according to the rules
for the definition of a constant. If the value of
this constant is zero or positive, the text will be
inserted after the interpretation of the specified
number of symbols within the present statement
rather than immediately. Another deferred text
replacement symbol cannot appear within the range of
the first. The symbol count does not include other
text replacement symbols directing immediate text
insertion but instead those none-text replacement
symbols within the inserted text, and likewise does
not include symbols within the range of any
unfulfilled Do-If class operator. The insertion is
not performed if the specified number of symbols is
not encountered prior to the end of the current
statement.
Example:
ADD=1'/+/
SUM=ADD 1 2
or
ADD=2'/+/
SUM ADD=1 2
would define SUM as the sum of 1 and 2.
The text insertion can also be deferred until prior
to a desired number of statement breaks specified by
negative value of a constant or parenthetical
expression preceding the text string in the
definition. The text insertion would then continue
the statement at the end of which it is inserted.
The statement count does not include statements
within the range of an unfulfilled IF class
operator.
Example:
ADD=-1'/+2/
ADD SUM=1,
or
ADD=-2'/+2/
ADD DIF=1-2,SUM=1,
TBLTRN: Language Specification Manual Page 108
Symbol Definitions
or
ADD=-2'/+2/
ADD DIF=1-2
SUM=1
ZERO=0
would define SUM as the sum of 1 and 2.
Additional text strings can follow in the
definition, each optionally preceded by its own
symbol or statement count. When the symbol being
defined is later encountered, the count of either
symbol or statement arguments for a particular text
insertion is not begun until all of the previously
inserted text has been interpreted, and any
statement closures within that previously inserted
text do not affect the argument count for the
following insertion.
The text string following a zero argument count
effectively continues the previous text string
although this following text string is not inserted
into the input text buffer until the previous string
has been completely interpreted. This can be used
to input a composite text string which would be
longer than a single input line. Negative and zero
argument counts can be mixed in any order. However,
since a symbol count must be satisfied within the
current statement in order that the following text
be inserted, an argument count which is greater than
zero can never be satisfied if any preceding
argument count of the same user defined function is
negative.
The statement count for a deferred insertion
includes the end of the current statement even if an
insertion has already been made at this end of
statement. For example, the values 4, 8 and 12
would be assembled by either of the following lines
of statements.
A=-1'/+1/0'/+1/-2'/+5/,A 2,3,12
or
A=-1'/+1/-1'/+1/-2'/+5/,A 2,3,12
7. A single period operator followed by either the ' or
'' operators and a text string containing the name
of 1 symbol between delimiter characters. If the
text string is introduced by the single apostrophe
operator, the current non-address meaning of the
symbol in the text string is assigned to the symbol
TBLTRN: Language Specification Manual Page 109
Symbol Definitions
being defined, and the previous name is removed from
the symbol dictionary. If the text string is
instead introduced by the double apostrophe
operator, the symbol being defined is assigned the
original (default dictionary) meaning of the symbol
(possibly with decimal integer prefix) in the text
string without changing the current meaning, if any,
of this symbol in the text string. Only the NEG
operator cannot be copied from the default
dictionary in this latter fashion.
Table Entry Definitions
----- ----- -----------
Table entries are assembled by statements having the
structure
PART1 PART2 PART3
in which
PART1 (optional) is any IF class operator followed by
the symbol, possibly signed constant or expression to be
tested.
PART2 (optional) includes any of the following items in
(except for address labels not preceded by one of the
operators ADR, LOA or HIA) any sequence.
1. An address label phrase consisting of the following
A. Optional word count consisting of the operator
WRD either with decimal integer prefix or
followed immediately by a constant or
parenthetical expression.
B. One of the operators ADR, LOA, or HIA. This
specifies that the address label is of the
current table entry origin, or of the lowest
table entry assembled by the current statement,
or of the highest table entry assembled by the
current statement respectively. If the WRD
operator has preceded this operator, this origin
is offset by one less than the specified word
count. The use of the ADR operator is optional
if the symbol to be taken as the address label
is not currently defined as an operator other
than an address label, and if no constant phrase
(as defined below) has been assembled since the
last table entry origin increment. The table
entry origin is initially the first table entry
TBLTRN: Language Specification Manual Page 110
Table Entry Definitions
assembled by the present statement and is
incremented for each period in the definition of
the packing pattern in use, if any. Address
label phrases without ADR, LOA or HIA operators,
can appear before the initial constant phrase in
the statement or before the initial constant
phrase following a shift in origin specified by
a packing pattern.
C. The symbol to be taken as the address label. If
not preceded by the ADR, LOA or HIA operators,
this symbol must currently not be an operator
other than an address label.
2. A constant phrase consisting of the following
A. In any order, optional sign (+ - XOR IOR or
AND), optional shift (LFT or RIT with decimal
integer prefix or followed immediately by
constant or parenthetical expression) and/or
optional word count (WRD with decimal integer
prefix or followed immediately by a constant or
parenthetical expression). Default sign is IOR
if the base of the byte size (shift unit defined
by SIZ operator outside a symbol definition) is
2, and is + otherwise. Default shift is no
shift. Default word count is one.
Shift and word count should not be specified if
the constant to which these would apply is the
argument of (within the range of) a packing
pattern.
B. Enclosed in optional parentheses which would
indicate uniform sign, uniform shift and uniform
word count, can appear any combination of
integers with or without the preceding operators
OCT, DEC or TRX (the latter with decimal integer
prefix or a following constant or parenthetical
expression), symbols defined as constants,
address labels preceded by the LOC operator, the
operator NUL (which might be considered to be a
constant with the value zero), and/or the
. (single period) operator with or without a
preceding LOC operator. If within parentheses,
the sign can be temporarily reset for the next
appearing constant (integer, symbol or address
label) only.
The phrase
5WRD+2LFT ABC
TBLTRN: Language Specification Manual Page 111
Table Entry Definitions
Adds the value of the constant named ABC to the
5th table entry presently being assembled (that
is, the 4th table entry beyond the current table
entry origin) after shifting it left 2 bytes.
+2LFT 3WRD.
or
+2LFT 3WRD LOC.
adds the address of the 3rd table entry
presently being assembled (the 2nd beyond the
current table entry origin) to that table entry
after shifting the address left 2 bytes. The
address of a table entry is its position
(subscript) ralative to the start of the table.
The 1st table entry assembled has the address 1.
+4WRD 1LFT(LOC ADRS 3)
adds the sum of the address of the table entry
named ADRS and 3 to the 4th table entry
presently being assembled (the 3rd beyond the
current table entry origin) after shifting each
of these left 1 byte.
3. A bit phrase consisting of the following
A. Optional word count.
B. The operator BIT with either decimal integer
prefix or followed immediately by a constant or
parenthetical expression.
C. The label of the table entry which is to be
taken as having a word count of unity.
The phrase
3WRD 6BIT ADRS
turns on the 6th bit (numbering system depending
on the precision set by the BPR operator) in the
2nd table entry after the table entry having the
address label ADRS.
2WRD 5BIT.
turns on the 5th bit in the 2nd table entry
presently being assembled (the next entry beyond
the current table entry origin).
TBLTRN: Language Specification Manual Page 112
Table Entry Definitions
Bit phrases can appear within the range of a packing
pattern or within the parentheses in a constant
phrase. In either case, the sign, shift and word
count are regenerated after the bit phrase has been
processed. Otherwise, default sign, shift and word
count are assumed immediately following a bit
phrase.
A table entry or entries will be assembled if, and only
if, the statement includes an address label phrase or a
constant phrase or a bit phrase with the destination
indicated by the . (period) operator or if it includes,
not selected by the TON operator, a packing pattern with
an initial automatic argument.
4. The name of a packing pattern which is to apply only
to the present statement.
5. The operator TON followed by the name of a packing
pattern if this pattern is to apply to the following
table entry definitions until changed by the
appearance of another packing pattern or until
terminated by the appearance of a null packing
pattern such as MSK. It should be noted that if a
packing pattern is in effect, but a particular table
entry contains more constants than the pattern has
arguments, the extra (right) constants are packed
with whatever byte size was last set outside the
range of the pattern (either right of the pattern's
arguments or before the pattern was put into
effect).
6. The operator DUP with either decimal integer prefix
or followed immediately by a constant or
parenthetical expression. The table entries
assembled by the present statement will be
duplicated as a set after the end of the statement
has been read to produce the total number of sets
specified by the prefix or constant or parenthetical
expression. Likewise, later bit deposits into the
range of the DUP operator will apply to the
referenced table entry in each set.
7. The operator SIZ with either decimal integer prefix
or followed immediately by a constant or
parenthetical expression. The byte size of the
shift operators LFT and RIT is specified by the
prefix of the SIZ operator or by the constant or
parenthetical expression which follows the SIZ
operator.
8. The operator TRX with either decimal integer prefix
or followed immediately by a constant or
TBLTRN: Language Specification Manual Page 113
Table Entry Definitions
parenthetical expression. The default radix under
which integers are interpreted in table entry
statements is specified by the prefix or following
constant or parenthetical expression.
9. The operator BPR with either decimal integer prefix
or followed immediately by a constant or
parenthetical expression. The number of bits per
table entry, and their numbering scheme, as
referenced by a bit phrase is specifed by the prefix
or following constant or parenthetical expression.
10. Any other operator in proper context except = == ARG
BLK FIN SAV TTY XSY XAD TEL or IF class operator.
PART3 (optional) is any one of the following items.
1. One of the operators BLK, FIN, SAV or TTY.
2. One of the operators XAD XSY or TEL wich have
argument lists which extend to the end of the
present statement.
TBLTRN: Principles of Operation Manual Page 114
Input Text String Buffer Structure
Input Text String Buffer Structure
----- ---- ------ ------ ---------
Each line of input text is read into the first 80 locations
of a buffer array called LETTER using a 80A1 format. The
line is scanned from right to left to determine the terminal
(right) non-blank character and its position within the line
is stored as the pointer ILTR. As the text is processed,
the buffer array can expand or contract as user defined
functions insert additional text and discard that already
processed. As a simple example, let us take the text
A=-1'/,B 2/,LMT-100
B=-1'/,C 3
C=-1'/, 4
A 1
5
The fourth line in this example assembles a table entry
containing the value 1, and directs that the text
,B 2
be inserted at the end of the current statement. The
current statement is not terminated by the end of line
following the character 1, but rather by the lack of the
continuation operator ,, before the character 5 within the
following line. Therefore, the new text is inserted not
after the character 1 but is instead inserted before the
character 5. The input buffer LETTER then contains the text
,B 25
An additional pointer is necessary to record the end of
statement condition existing after the character 2. This
pointer, MLTR, points to the right-hand character within the
present statement if an end-of-statement insertion has been
made. Otherwise, MLTR and ILTR are identical. Assembly of
the current statement is continued through the character
numbered MLTR unless a statement termination operator is
encountered prior to this. A text replacement or text
insertion operation clears all processed text from the input
buffer, left justifies the inserted text within the buffer
followed by the remaining unprocessed text, and redefines
MLTR and ILTR to correspond to the altered buffer size.
If desired, a record of all text insertion and replacement
operations will be written into the listing file. Such a
record is usually necessary when complex user defined
functions are being tested. To guard against infinite
replacement loops, the maximum number of text replacements
which can be performed for a single input line is the
absolute value of ILOOP. The number of text replacements
TBLTRN: Principles of Operation Manual Page 115
Input Text String Buffer Structure
actually performed within the line is stored as LOOP. ILOOP
can be set by the source table using the LMT operator. The
replacement summary is generated if ILOOP is negative. A
complete replacement summary for the above example would be
as follows.
LINE 4 INSERTION 1
2 OLD TEXT A
1 NEW TEXT 1
(UNTIL 0 LETTERS THEN 1 STATEMENTS)
4 DEFERRED ,B 2
LINE 5 INSERTION 1
FUNCTION A
4 NEW TEXT ,B 2
1 NEW TEXT 5
LINE 5 INSERTION 2
2 OLD TEXT ,B
1 NEW TEXT 2
(UNTIL 0 LETTERS THEN 1 STATEMENTS)
4 DEFERRED ,C 3
1 NEW TEXT 5
LINE 5 INSERTION 3
1 OLD TEXT 2
FUNCTION B
4 NEW TEXT ,C 3
1 NEW TEXT 5
LINE 5 INSERTION 4
2 OLD TEXT ,C
1 NEW TEXT 3
(UNTIL 0 LETTERS THEN 1 STATEMENTS)
4 DEFERRED , 4
1 NEW TEXT 5
LINE 5 INSERTION 5
1 OLD TEXT 3
FUNCTION C
4 NEW TEXT , 4
1 NEW TEXT 5
In the above summary, the columns from left to right are the
number of characters in the portion of the text string being
listed, the classification of that portion, and the
characters themselves. The listing of text is split onto
separate lines wherever a statement break has been, or is to
be forced at the end of inserted text. The classifications
"OLD TEXT" and "NEW TEXT" refer respectively to the
processed text being discarded, and to the unprocessed text
including that inserted. A symbol which is responsible for
the deferred insertion of a text string is listed under the
TBLTRN: Principles of Operation Manual Page 116
Input Text String Buffer Structure
classification "FUNCTION."
The LETTER array is dimensioned at 160, double the length of
the text read, to allow some expansion of the unprocessed
text buffer due to text replacement. Excess characters are
discarded after informing the user at most once of this
action. A number of error messages are treated in this
manner. These messages are generated and JERR is assigned
as value the current line number only if JERR does not
already have this as its value. If a text replacement
summary is being generated, the discarded characters are
listed within the classification "OVERFLOW."
The current value of MLTR must be stored and MLTR redefined
when the inserted text specifies that additional text is to
be inserted at the end of a statement and this end of
statement occurs prior to MLTR. For example, the simple
test table
...TEXT REPLACEMENT TEST TABLE
LMT-100 TTL'/92/TST 18
A= 1'/, 2,/-1'/B 4 6,16,17
B='/,/1'/, 5,/-1'/C 7 9,15
C='/,/1'/, 8,/-1'/D 10 12
D='/,/1'/,11,/-1'/E 13
E='/,/1'/,14 /
A 1 3,18
1, 2, 3, 4, 5, 6, 7, 8, 9,10
11,12,13,14,15,16,17,18 BLK
would, during its processing, cause the input text buffer
array LETTER to contain unprocessed portions of several text
insertions. The following replacement summary would be
generated during the processing of this table.
LINE 8 INSERTION 1
2 OLD TEXT A
6 NEW TEXT 1 3,18
(UNTIL 0 LETTERS THEN 1 SYMBOLS)
4 DEFERRED , 2,
LINE 8 INSERTION 2
1 OLD TEXT 1
FUNCTION A
8 NEW TEXT , 2,3,18
(UNTIL 4 LETTERS THEN 1 STATEMENTS)
13 DEFERRED B 4 6,16,17
LINE 8 INSERTION 3
6 OLD TEXT , 2,3,
FUNCTION A
13 NEW TEXT B 4 6,16,17
2 NEW TEXT 18
TBLTRN: Principles of Operation Manual Page 117
Input Text String Buffer Structure
LINE 8 INSERTION 4
1 OLD TEXT B
11 NEW TEXT ,4 6,16,17
(UNTIL 1 LETTERS THEN 1 SYMBOLS)
4 DEFERRED , 5,
2 NEW TEXT 18
LINE 8 INSERTION 5
2 OLD TEXT ,4
FUNCTION B
11 NEW TEXT , 5,6,16,17
(UNTIL 4 LETTERS THEN 1 STATEMENTS)
10 DEFERRED C 7 9,15
2 NEW TEXT 18
LINE 8 INSERTION 6
6 OLD TEXT , 5,6,
FUNCTION B
10 NEW TEXT C 7 9,15
5 NEW TEXT 16,17
2 NEW TEXT 18
LINE 8 INSERTION 7
1 OLD TEXT C
8 NEW TEXT ,7 9,15
(UNTIL 1 LETTERS THEN 1 SYMBOLS)
4 DEFERRED , 8,
5 NEW TEXT 16,17
2 NEW TEXT 18
LINE 8 INSERTION 8
2 OLD TEXT ,7
FUNCTION C
8 NEW TEXT , 8,9,15
(UNTIL 4 LETTERS THEN 1 STATEMENTS)
7 DEFERRED D 10 12
5 NEW TEXT 16,17
2 NEW TEXT 18
LINE 8 INSERTION 9
6 OLD TEXT , 8,9,
FUNCTION C
7 NEW TEXT D 10 12
2 NEW TEXT 15
5 NEW TEXT 16,17
2 NEW TEXT 18
LINE 8 INSERTION 10
1 OLD TEXT D
6 NEW TEXT ,10 12
(UNTIL 1 LETTERS THEN 1 SYMBOLS)
4 DEFERRED ,11,
TBLTRN: Principles of Operation Manual Page 118
Input Text String Buffer Structure
2 NEW TEXT 15
5 NEW TEXT 16,17
2 NEW TEXT 18
LINE 8 INSERTION 11
3 OLD TEXT ,10
FUNCTION D
6 NEW TEXT ,11,12
(UNTIL 4 LETTERS THEN 1 STATEMENTS)
4 DEFERRED E 13
2 NEW TEXT 15
5 NEW TEXT 16,17
2 NEW TEXT 18
LINE 8 INSERTION 12
6 OLD TEXT ,11,12
FUNCTION D
4 NEW TEXT E 13
2 NEW TEXT 15
5 NEW TEXT 16,17
2 NEW TEXT 18
LINE 8 INSERTION 13
1 OLD TEXT E
3 NEW TEXT ,13
(UNTIL 1 LETTERS THEN 1 SYMBOLS)
4 DEFERRED ,14
2 NEW TEXT 15
5 NEW TEXT 16,17
2 NEW TEXT 18
LINE 8 INSERTION 14
3 OLD TEXT ,13
FUNCTION E
4 NEW TEXT ,14
2 NEW TEXT 15
5 NEW TEXT 16,17
2 NEW TEXT 18
Each end-of-statement insertion places into the LETTER
array, between the newly inserted text and the remaining
unprocessed text, one plus the number of characters
remaining unprocessed through the end of the line, or
through the end of the previous end-of-statement insertion
if any. The LETTER array can, therefore, contain both
numeric and alphabetic information. The minimum value of
MLTR during the lifetime of the current LETTER array
contents is stored as NLTR, and is used to split into
separate lines under the "OLD TEXT" classification in the
replacement summary any text containing a statement break
which was forced at the end of inserted text. The contents
of the LETTER array together with the values of MLTR and
ILTR during the processing of the above example are listed
TBLTRN: Principles of Operation Manual Page 119
Input Text String Buffer Structure
below.
MLTR ILTR LETTER array (pointers starred below)
8 8 A 1 3,18
6 6 1 3,18
8 8 , 2,3,18
13 16 B 4 6,16,17318
*
11 14 ,4 6,16,17318
*
11 14 , 5,6,16,17318
*
10 19 C 7 9,15616,17318
* *
8 17 ,7 9,15616,17318
* *
8 17 , 8,9,15616,17318
* *
7 19 D 10 12315616,17318
* * *
6 18 ,10 12315616,17318
* * *
6 18 ,11,12315616,17318
* * *
4 16 E 13315616,17318
* * *
3 15 ,13315616,17318
* * *
4 16 ,14 315616,17318
* * *
7 16 ,14 315616,17318
* * *
13 16 ,14 315616,17318
* * *
16 16 ,14 315616,17318
* * *
Actually, duplicate sets of input buffers and associated
pointers are necessary, one each for the selected and
deselected input devices. When either the TTY operator or
the == operator switches these devices, the unprocessed
portion of the LETTER array is swapped with the contents of
the LTTR array, and the corresponding adjusted values of
MLTR and ILTR are swapped with JLTR and KLTR respectively.
The line number ILINE, error message switch JERR and text
replacement and insersion count LOOP are also swapped with
KLINE, KERR and JLOOP respectively.
TBLTRN: Principles of Operation Manual Page 120
Input Text String Buffer Structure
In all of the above examples, the end of statement was
indicated either by an end of line or by the single comma
operator. When, instead, the end of statement is indicated
by the END operator and text must be inserted before
terminating the current statement, the END operator is
discarded and the count inserted at MLTR+1 is made negative.
The END operator must be marked rather than be immediately
executed since it might actually terminate the range of an
IF class operator still within the text not yet inserted.
For example, the following text would assemble the table
entries 1 and 3.
LMT=100,A=0
B=-1'/,IFN A 2
IFE A B 1 END 3 END
The above example would generate the following replacement
summary.
LINE 3 INSERTION 1
7 OLD TEXT IFE A B
11 NEW TEXT 1 END 3 END
(UNTIL 0 LETTERS THEN 1 STATEMENTS)
8 DEFERRED ,IFN A 2
LINE 3 INSERTION 2
5 OLD TEXT 1 END
FUNCTION B
8 NEW TEXT ,IFN A 2
(RANGE OF IF CLASS OPERATOR ENDS)
5 NEW TEXT 3 END
The contents of the LETTER array during the processing of
the above example would be as follows. (Although requiring
2 characters to list, the pointer containing -6 is a single
word.)
MLTR ILTR LETTER array (pointers starred below)
19 19 IFE A B 1 END 3 END
11 11 1 END 3 END
8 14 ,IFN A 2-63 END
**
14 14 ,IFN A 2-63 END
**
TBLTRN: Principles of Operation Manual Page 121
Symbol Selection from Text Buffer
Symbol Selection from Text Buffer
------ --------- ---- ---- ------
The routine TBLNXT is responsible for selecting the next
symbol from the text buffer. As input it accepts the text
buffer LETTER, a pointer IRIGHT to the right character
already processed, and a pointer MLTR to the furthest right
character which could possibly be in the next symbol. It
returns KIND with the character class, ILEFT with a pointer
to the left character within the symbol, IRIGHT with a
pointer to the right character within the symbol, NUMBER
with the value of a integer if any under the current radix,
and ITEN with the value of a decimal integer prefix if any.
A symbol consists of contiguous characters of a single
character class and is delimited by a change in character
class. The contents of the various character classes are
alterable by the ACC operator. The IPNCTN array serves as
the template for the establishment of character classes at
the beginning of processing of each source table. IPNCTN
contains the characters blank, dollar sign, asterisk,
period, comma, apostrophe, minus sign, plus sign, equal
sign, left parenthesis and right parenthesis. These
characters are copied into the JPNCTN array and, to identify
the intial character classes, the numbers 5 through 15 are
stored in the KPNCTN array. The latter 2 arrays are
dimensioned at 50 each to allow for expansion by the ACC
operator.
Character classes 1 through 4 are subclasses reserved for
the large group of unassigned characters. Selection of
these subclasses is dependent upon the possible initial
appearance of numerals within the symbol.
Class 1 is for a symbol formed entirely of characters which
are within the small set of 10 numerals 0 through 9
with at least one character being a numeral which is
equal or greater than the current radix. Symbols
within this class are integers which contain a radix
violation and are considered to be non-fatal errors.
Class 2 is for a symbol formed entirely of characters which
are within the large set of 16 numerals (0 through 9
and A through F) and which are less than the current
radix. Symbols within this class are integers and
do not require symbol dictionary reference for
interpretation.
Class 3 is for a symbol beginning with one of the numerals 0
through 9 and containing at least one character
which is not one of the numerals 0 through 9 and
which, if within the large set of 16 numerals (0
through 9 and A through F), is equal or greater than
TBLTRN: Principles of Operation Manual Page 122
Symbol Selection from Text Buffer
the current radix. Symbols within this class bear a
decimal integer prefix. The symbol with prefix will
be tested for presence in the symbol dictionary. If
the symbol with prefix is not present, the symbol
without prefix is similarly tested. The symbol with
prefix will be added to the symbol dictionary only
if the symbol is not already present in the symbol
dictionary either with or without prefix.
Class 4 is for a symbol not beginning with one of the
numerals 0 through 9 but containing at least one
character which is not one of the numerals 0 through
9 and which, if within the large set of 16 numerals
(0 through 9 and A through F), is equal or greater
than the current radix. Symbols within the class
must be stored as is in the symbol dictionary.
Class 7 is for a symbol beginning with with some sequence of
the numerals 0 through 9 followed immediately by a
character of the class originally occupied by the
asterisk. The symbol is terminated immediately
after the asterisk regardless of the class of the
following character. Such symbols are generated as
assembled instructions when the '' operator is used
to define a symbol as a text string. The value of
the decimal integer prefix specifies a particular
operator by its identifier code. If the symbol does
not start with a decimal integer prefix followed
immediately by an asterisk, then the asterisk does
not act as a symbol delimiter within a class 3 or
class 4 symbol.
The blank (space) character is always of character class 5.
Character class 6 initially contains the dollar sign which
serves as an enquire character. Character class 7 initially
contains the asterisk which can be used with an integer
prefix to designate assembled operator identifier codes.
Characters can always be placed into character class 5, but
character classes 6 and 7 cannot be assigned if empty.
Symbols cannot be formed from either classes 5 or 6. No
special functions are associated with the character classes
above 7.
As each new character in a symbol is encountered, it is
first tested for its presence in the JPNCTN array. A
character is the end of a symbol if any of the following is
true.
1. The present character is within the JPNCTN array,
with the parallel KPNCTN array entry having the
value 7 (class originally occupied by the asterisk),
and the present symbol has consisted only of some
sequence of the numerals 0 through 9.
TBLTRN: Principles of Operation Manual Page 123
Symbol Selection from Text Buffer
2. Both the present and the next characters are present
in the JPNCTN array, but the parallel KPNCTN entries
are not identical.
3. The present character is in the JPNCTN array and the
parallel KPNCTN array entry is not 7, but the next
character is not in the JPNCTN array or if the next
character is in the JPNCTN array then the KPNCTN
array entry which is parallel to the appearance of
this next character within the JPNCTN array is 7.
4. The next character is in the JPNCTN array and the
parallel KPNCTN array entry is not 7, but the
present character is not in the JPNCTN array or if
the present character is in the JPNCTN array then
the KPNCTN array entry which is parallel to the
appearance of this present character within the
JPNCTN array is 7.
If not in the JPNCTN array, the present character must be
tested for presence in the IDGT array when all the preceding
characters, if any, are digits (including the letter A and
above if the radix is 11 or above). The value of the
accumulated number under the current radix is stored as
NUMBER. NUMBER is constructed by bit shifting and inclusive
ORing if the base of the radix is binary (as for example
octal or hexadecimal), otherwise, multiplcation shifting and
addition are used. The powers of 2 are identified by
testing for 2, 4, 8 and 16 as special cases. To save time,
radix 10 and radix 8 are tested for first since these are
most common. The value of the accumulated decimal number is
also stored as ITEN if the present character and all
preceding characters are in the IDGT array and within the
range 0 through 9.
In addition to the current radix stored in IRADIX, three
other radix states must be kept. These are the radix
appropriate for table entries KRADIX, the radix for symbol
definitions JRADIX, and the value of JRADIX at the start of
a symbol definition LRADIX. LRADIX is necessary since a
radix change within a symbol definition applies to that
definition only.
Symbol Dictionary Structure
------ ---------- ---------
Since the BIT operator can make reverse as well as forward
references, all assembled table entries must be retained
until the complete table has been assembled. Even without
this restriction, the lowest reference of an as yet unknown
address would form the upper bounds of the table entries
TBLTRN: Principles of Operation Manual Page 124
Symbol Dictionary Structure
which could be assumed to be completely specified. In order
to make the most efficient utilization of the resulting
massive storage requirement, both the assembled table
entries and the working symbol dictionary together with
information about unknown address labels are kept in the
single large array named MASTER.
In practice, although the number of assembled table entries
is continually increasing, the symbol dictionary probably
reaches its maximum size half way through the table assembly
and from then on decreases making room for the growing
assembled table as unknown address references are resolved.
The symbol dictionary is constructed starting at the top of
the MASTER array. Unless the EOD (End Ordered Dictionary)
command has been issued, new items defined by either the =
or == operators are inserted into the symbol dictionary
after (below) the most recently defined symbol having the
same number of characters in its name. Since address
labels, and constants initially defined by the DEF, PSH and
STK operators, are left in the unordered lower section of
the dictionary, garbage collection must be relied upon to
keep search time to a minimum.
The symbol dictionary is a conglomerate of symbol cells and
data cells. Each cell begins with a pointer to the
following cell and an identifier code which is zero in cells
to be garbage collected. A symbol cell has a positive
identifier code which is followed by a single value
associated with the symbol and by the characters of the
symbol itself. The value word of a symbol cell having an
associated data cell is a negative pointer to the identifier
code of that data cell. The identifier code of the data
cell is similarly a negative back-pointer to the value word
of the corresponding symbol cell. Data cells are never
cross-linked, although the linkage from the symbol cell for
an unassigned address label can proceed indirectly through
temporary storage within the assembled table. Additions to
data cells are accomplished through reverse garbage
collection.
The original dictionary is constructed from the template
array ISTORE. To aid user modification, ISTORE does not
have a list structure. Each operator is indicated in ISTORE
merely by the number of characters, followed by the operator
identifier code and the characters making up the operator.
As a table in processed, each unknown symbol read from the
input buffer is appended to the lower end of the symbol
dictionary in a symbol cell with a zero identifier code.
The lowest symbol dictionary cell is in turn replaced if its
identifier code is still zero when the next unknown symbol
is encountered. Undefined symbols are therefore not allowed
to creep into the symbol dictionary.
TBLTRN: Principles of Operation Manual Page 125
Symbol Dictionary Structure
The following is a complete list of the symbol cell
identifier codes of the programmed operators.
3 POP 27 IFE 50 CLM 73 IFD 96 DID 119 NSV
4 ' 28 IFLE 51 *CLM 74 BSZ 97 *DID 120 *NSV
5 , 29 MSK 52 TST 75 *BSZ 98 DIU 121 NST
6 ... 30 LFT 53 *TST 76 IFU 99 *DIU 122 JST
7 ,,, 31 *LFT 54 ( 77 IFA 100 DIA 123 *JST
9 - 32 RIT 54 (( 78 IFO 101 *DIA 124 XOR
10 + 33 *RIT 55 ) 79 LMT 102 DIO 125 AND
11 OCT 34 SIZ 56 )) 80 *LMT 103 *DIO 126 PFX
12 DEC 35 *SIZ 57 NUL 81 XAD 104 DINA 127 *PFX
13 LOC 36 '' 58 WRD 82 IFL 105*DINA 128 STK
14 XSY 37 == 59 *WRD 83 EAC 106 DINO 129 *STK
15 = 38 IOR 60 IFN 84 IFG 107*DINO 130 PSH
16 . 39 TON 61 IFGE 85 ROT 108 RED 131 *PSH
17 DMP 40 BIT 62 FIL 86 IFNA 109 *RED 132 SFT
18 DBG 41 *BIT 63 *FIL 87 IFNO 110 INC 133 *SFT
19 LST 42 DUP 64 BPR 88 DIE 111 *INC 134 BAC
20 BLK 43 *DUP 65 *BPR 89 *DIE 112 DEF 135 BOD
21 FIN 44 SRX 67 ARG 90 DIN 113 *DEF 136 EOD
22 SAV 45 *SRX 68 ADR 91 *DIN 114 DILE 1001 NEG
23 TTL 46 TRX 69 ,, 92 DIL 115*DILE
24 TEL 47 *TRX 70 HIA 93 *DIL 116 DIGE
25 TTY 48 WID 71 LOA 94 DIG 117*DIGE
26 END 49 *WID 72 ACC 95 *DIG 118 NSN
5 , 135 BOD 114 DILE 73 IFD 29 MSK 44 SRX
69 ,, 64 BPR 115*DILE 27 IFE 1001 NEG 45 *SRX
7 ,,, 65 *BPR 90 DIN 84 IFG 118 NSN 128 STK
4 ' 74 BSZ 91 *DIN 61 IFGE 121 NST 129 *STK
36 '' 75 *BSZ 104 DINA 82 IFL 119 NSV 24 TEL
16 . 50 CLM 105*DINA 28 IFLE 120 *NSV 39 TON
6 ... 51 *CLM 106 DINO 60 IFN 57 NUL 46 TRX
10 + 18 DBG 107*DINO 86 IFNA 11 OCT 47 *TRX
9 - 12 DEC 102 DIO 87 IFNO 126 PFX 52 TST
15 = 112 DEF 103 *DIO 78 IFO 127 *PFX 53 *TST
37 == 113 *DEF 98 DIU 76 IFU 3 POP 23 TTL
54 ( 100 DIA 99 *DIU 110 INC 130 PSH 25 TTY
54 (( 101 *DIA 17 DMP 111 *INC 131 *PSH 48 WID
55 ) 96 DID 42 DUP 38 IOR 108 RED 49 *WID
56 )) 97 *DID 43 *DUP 122 JST 109 *RED 58 WRD
72 ACC 88 DIE 83 EAC 123 *JST 32 RIT 59 *WRD
68 ADR 89 *DIE 26 END 30 LFT 33 *RIT 81 XAD
125 AND 94 DIG 136 EOD 31 *LFT 85 ROT 124 XOR
67 ARG 95 *DIG 62 FIL 79 LMT 22 SAV 14 XSY
134 BAC 116 DIGE 63 *FIL 80 *LMT 132 SFT
40 BIT 117*DIGE 21 FIN 71 LOA 133 *SFT
41 *BIT 92 DIL 70 HIA 13 LOC 34 SIZ
20 BLK 93 *DIL 77 IFA 19 LST 35 *SIZ
TBLTRN: Principles of Operation Manual Page 126
Symbol Dictionary Structure
In the above list, an operator name starting with a star
indicates an operator defined by the user as the operator
preceding it in the list with eiher decimal integer prefix
or following parenthetical expression. The identifier codes
137 through 1000 are unassigned. Cells with the following
identifiers are generated during the table assembly.
-1 or less, data cell back pointer
0 undefined symbol
1 unassigned address label
2 assigned address label
8 text replacement operator
29 packing pattern
66 multiple entry constant
1001 or greater, single entry constant
Operators without associated values have the simplest symbol
cell structure. For example, the definition
LEFT=LFT
generates the following symbol cell
4479 4472
4478 30
4477 0
4476 T
4475 F
4474 E
4473 L
This would be represented in debugging output as follows.
OPERATOR 4479 OPR 30 LEFT
The left column in the above example contains the locations
within the MASTER array. The first location 4479 within the
cell contains a pointer 4472 to the first location within
the following cell. The identifier code 30 in location 4478
defines the symbol to be the left shift operator. There is
no value associated with this operator since it will be used
either with a decimal integer prefix or with a following
constant. The location 4477 which would contain this value
is therefore zero. Locations 4476 through 4473 contain the
characters forming the symbol, one character per location.
The order of the characters within the symbol cell is
opposed to that of the construction and search of the symbol
dictionary in order to allow the symbol to be output by the
implied DO in a FORTRAN WRITE statement. The similar
statement
LEFT=2LFT
TBLTRN: Principles of Operation Manual Page 127
Symbol Dictionary Structure
associates only a single value with the new symbol so this
can still be stored within the symbol cell. The resulting
symbol cell structure is shown below.
4479 4472
4478 31
4477 2
4476 T
4475 F
4474 E
4473 L
This would be represented in debugging output as follows.
OPERATOR 4479 OPR 31 2 LEFT
In the above example, the identifier code 31 specifies that
the symbol is the left shift operator with the associated
value 2 given in the following location.
Single entry constants require the storage of 2 items of
data, the value and the precision (offset specified by WRD
operator). The use of separate data cells has been avoided,
however, by making the identifier code of these constants be
the sum of 1000 and the offset. Since single entry
constants are the most common symbol type, the use of
separate data cells would waste considerable storage. As
examples, the statements
ONE=11,TWO=2WRD 22,THREE=3WRD 33
would generate the following symbol cells.
4479 4473 4473 4467 4467 4459
4478 1001 4472 1002 4466 1003
4477 11 4471 22 4465 33
4476 E 4470 O 4464 E
4475 N 4469 W 4463 E
4474 O 4468 T 4462 R
4461 H
4460 T
These would be represented in debugging output as follows.
CONSTANT 4479 WRD 1 OCT 13 11 ONE
CONSTANT 4473 WRD 2 OCT 26 22 TWO
CONSTANT 4467 WRD 3 OCT 41 33 THREE
Multiple entry constants are represented by identifier code
66. The value word is a negative pointer to the
back-pointer in the associated data cell. The data cell
contains 2 words for each entry specified in the definition
of the constant. The higher of these 2 words contains the
TBLTRN: Principles of Operation Manual Page 128
Symbol Dictionary Structure
offset and the lower contains the contents of the entry
having that offset. The specified entries appear in the
order of precision, independent of manner and order of
specification, with the highest precision entry first
(highest). Unspecified entries and zero entries other than
the highest precision entry specified are not included in
the data cell. As examples, the statements
I=33 2WRD 22 4WRD 0
J=33 4WRD 0 2WRD 22
K=4WRD 0 2WRD 22 33
generate the following symbol and data cells.
4479 4475 4467 4463 4455 4451
4478 66 4466 66 4454 66
4477 -4474 4465 -4462 4453 -4450
4476 I 4464 J 4452 K
4475 4467 4463 4455 4451 4443
4474 -4477 4462 -4465 4450 -4453
4473 4 4461 4 4449 4
4472 0 4460 0 4448 0
4471 2 4459 2 4447 2
4470 22 4458 22 4446 22
4469 1 4457 1 4445 1
4468 33 4456 33 4444 33
These would be represented in debugging output as follows.
CONSTANT 4479 WRD 4 OCT 0 0 I
'' '' WRD 2 OCT 26 22 I
'' '' WRD 1 OCT 41 33 I
CONSTANT 4467 WRD 4 OCT 0 0 J
'' '' WRD 2 OCT 26 22 J
'' '' WRD 1 OCT 41 33 J
CONSTANT 4455 WRD 4 OCT 0 0 K
'' '' WRD 2 OCT 26 22 K
'' '' WRD 1 OCT 41 33 K
Symbols which are defined as text strings are represented by
identifier code 8. A symbol defined as a null text string
has a zero value word and no associated data cell.
Otherwise, the value word is a negative pointer to the
back-pointer in the associated data cell which contains the
characters of the text string following the back-pointer.
Query characters within the text string are stored in the
data cell and are not executed immediately. Blanks are
stored only if the single quote operator is used to begin
the text string. The stored characters of the text string
are preceded (above in the storage array) by a character
count and are followed by the argument count if a deferred
text string follows within the definition. An additional
zero length text string is stored if the initial text string
TBLTRN: Principles of Operation Manual Page 129
Symbol Dictionary Structure
within the definition is preceded by an argument
specification. As examples, the statements
A=''/ TEL A,XSY A,B /
B='/ A='*TEL A,*, /
C=1''/ A /-1'/ A /
generate the following symbol and data cells.
4437 4433 4415 4411 4392 4388
4436 8 4414 8 4391 8
4435 -4432 4413 -4410 4390 -4387
4434 A 4412 B 4389 C
4433 4415 4411 4392 4388 4375
4432 -4435 4410 -4413 4387 -4390
4431 15 4409 16 4386 0
4430 B 4408 4385 1
4429 * 4407 4384 1
4428 5 4406 , 4383 A
4427 4405 * 4382 -1
4426 A 4404 , 4381 5
4425 * 4403 A 4380
4424 4 4402 4379
4423 1 4401 L 4378 A
4422 * 4400 E 4377
4421 5 4399 T 4376
4420 4398 *
4419 A 4397 '
4418 * 4396 =
4417 4 4395 A
4416 2 4394
4393
These would be represented in debugging output as follows.
TEXT 4437 OPR 8 A
'' '' ***************
'' '' 24*A 5*14*A 5*B
TEXT 4415 OPR 8 B
'' '' ****************
'' '' A='*TEL A,*,
TEXT 4392 OPR 8 C
'' '' * ARGUMENT COUNT 1
'' '' *
'' '' A
'' '' *
'' '' * ARGUMENT COUNT -1
'' '' *****
'' '' A
The first use of A redefines A. The statement
TBLTRN: Principles of Operation Manual Page 130
Symbol Dictionary Structure
C''/FIRST/''/SECOND/
would generate the following as output.
FIRST
TEXT 4437 OPR 8 A
'' '' ***************
'' '' 24*A 5*14*A 5*B
SECOND
TEXT 4397 OPR 8 A
'' '' ******
'' '' TEL A,
The identifier code for known address labels is 2. The
value word contains the subscript of the table entry bearing
the label if this entry was not repeated by the DUP
operator. The value word for the label of a duplicated
entry is a negative pointer to a data cell since additional
information must be stored so tht a later BIT operator can
deposit into the labeled entry and into all of its copies.
The data cell contains, starting at the highest data word,
the subscript of the labeled entry, the number of copies of
this entry (1 less than value of prefix of or constant
following DUP operator), and the number of entries assembled
by the statement which were copied. As examples, the
statements
11 2WRD 22 LOA A HIA B
4DUP 33 2WRD 44 LOA C HIA D
generate the following symbol and data cells
4479 4475 4471 4467 4467 4463
4478 2 4470 2 4466 2
4477 1 4469 -4462 4465 -4457
4476 A 4468 C 4464 D
4463 4458 4458 4453
4475 4471 4462 -4469 4457 -4465
4474 2 4461 3 4456 4
4473 2 4460 3 4455 3
4472 B 4459 2 4454 2
These would be represented in debugging format at follows.
ADDRESS 4479 OPR 2 LOC 1 A
ADDRESS 4475 OPR 2 LOC 2 B
ADDRESS 4471 OPR 2 ENTRIES 2 DUP 4 LOC 3 C
ADDRESS 4467 OPR 2 ENTRIES 2 DUP 4 LOC 4 D
The identifier code for a packing pattern is 29. For a null
packing pattern such as MSK, the value word which follows
the word containing the identifier code is zero. Otherwise,
this value word is a negative pointer to the back-pointer in
TBLTRN: Principles of Operation Manual Page 131
Symbol Dictionary Structure
the associated data cell. The data cell which can be
created for the storage of a packing pattern can be more
complex than that of any other operator. The items which
follow the negative back-pointer in the data cell are
grouped in pairs. The first word identifies the type of
information being stored as follows.
1st word zero. Table entry origin increment.
The 2nd word contains the number of table entries
which the origin is to be incremented.
1st word positive. Explicit argument specification.
The 1st word contains the shift specified by the WRD
operator. The second word contains the sum of the
reduced byte size minus 2 then times 505, the sign
to be used times 101, and the shift stated in
reduced bytes plus 50. The reduced byte size is the
base of the current byte size if this base is in the
range 2 through 17. Otherwise, the reduced byte
size is the same as the current byte size. The
signs are stored as
0 Exclusive or (bit on if on in only one argument)
1 And (bit on if on in both arguments)
2 Addition
3 Subtraction
4 Inclusive or (bit on if on in either argument)
It will be noted that the shift stated in reduced
bytes must be within the range -50 to +50. In
particular, this limits shifts stated in bits, or in
bytes which are exact multiples of bits, to 50 left
and 50 right.
1st word negative. Automatic argument specification.
The 2nd word contains the same packed information as
an explicit argument specification. However, the
following words contain consecutive pairs of offsets
and values to be used as the automatic argument.
The total number of items in the offsets and values
list is the absolute value of the negative word
preceding the the word containing the packed byte
size, sign and shift information.
As examples, the statements
A=MSK
B=MSK 2WRD 3LFT+100SIZ ARG
C=MSK 3WRD.
D=MSK 16SIZ 1WRD 2LFT-ARG
E=MSK 2WRD 3LFT+100SIZ ARG 3WRD.16SIZ 1WRD 2LFT-ARG
F=3WRD 45 40 2WRD 60 3WRD+45
F=MSK 2WRD 3LFT+100SIZ ARG(F-10)3WRD.16SIZ 1WRD 2LFT-ARG
TBLTRN: Principles of Operation Manual Page 132
Symbol Dictionary Structure
would generate the following symbol and data cells.
4479 4475 4459 4455 4439 4435
4478 29 4458 29 4438 29
4477 0 4457 -4454 4437 -4434
4476 A 4456 D 4436 F
4455 4451 4435 4417
4454 -4457 4434 -4437
4475 4471 4453 1 4433 -6
4474 29 4452 361 4432 4298
4473 -4470 (0*505+3*101+58) (8*505+2*101+56)
4472 B 4431 4
4471 4467 4430 90
4470 -4473 4451 4447 4429 3
4469 2 4450 29 4428 60
4468 4298 4449 -4446 4427 2
(8*505+2*101+56) 4448 E 4426 40
4447 4439 4425 -2
4446 -4449 4424 4399
4467 4463 4445 2 (8*505+3*101+56)
4466 29 4444 4298 4423 2
4465 -4462 (8*505+2*101+56) 4422 10
4464 C 4443 0 4421 0
4463 4459 4442 3 4420 3
4462 -4465 4441 1 4419 1
4461 0 4440 361 4418 361
4460 3 (0*505+3*101+58) (0*505+3*101+58)
These would be represented in debugging output as follows.
OPERATOR 4479 OPR 29 A
BYTEMASK 4475 OPR 29 SIN 2 SIZ 10 BYT 7 WRD 2 B
BYTEMASK 4467 OPR 29 ORIGIN INCREMENT WRD 3 C
BYTEMASK 4459 OPR 29 SIN 3 SIZ 2 BYT 9 WRD 1 D
BYTEMASK 4451 OPR 29 SIN 2 SIZ 10 BYT 7 WRD 2 E
'' '' ORIGIN INCREMENT WRD 3 E
'' '' SIN 3 SIZ 2 BYT 9 WRD 1 E
BYTEMASK 4439 OPR 29 SIN 2 SIZ 10 BYT 7 WRD 4 F
'' '' AUTO ARG OCT 132 90 F
'' '' SIN 2 SIZ 10 BYT 7 WRD 3 F
'' '' AUTO ARG OCT 74 60 F
'' '' SIN 2 SIZ 10 BYT 7 WRD 2 F
'' '' AUTO ARG OCT 50 40 F
'' '' SIN 3 SIZ 10 BYT 7 WRD 2 F
'' '' AUTO ARG OCT 12 10 F
'' '' ORIGIN INCREMENT WRD 3 F
'' '' SIN 3 SIZ 2 BYT 9 WRD 1 F
References of unknown address labels are stored in data
cells packed similarly to those used for packing patterns.
The identifier code for an unknown address label is 1, and
the value word which follows is a negative pointer to the
back-pointer in the associated data cell. The items which
TBLTRN: Principles of Operation Manual Page 133
Symbol Dictionary Structure
follow the negative back-pointer are grouped in pairs. The
second word of the pair is packed identically to the second
word of an explicit argument specification of a packing
pattern. The first word, if positive, is the number of the
table entry into which the address associated with the label
is to be packed. If the first word is negative, the pair of
words store a reference of the label by the bit operator,
and the first word is the negative of the offset specified
by the WRD operator or packing pattern in effect, if any, or
is -1 if an offset has not been specified. As examples, the
statements
10BPR 3WRD 5BIT A 15BIT A
3WRD 5BIT G 15BIT G
4BSZ 3WRD 5BIT B 15BIT B
3WRD 5BIT G 15BIT G
5BSZ 3WRD 5BIT C 15BIT C
3WRD 5BIT G 15BIT G
3WRD 5LFT LOC D LOC D
3WRD 5LFT LOC G LOC G
4SIZ 3WRD 5LFT LOC E LOC E
3WRD 5LFT LOC G LOC G
5SIZ 3WRD 5LFT LOC F LOC F
3WRD 5LFT LOC G LOC G
would generate the following symbol and data cells.
6431 6427 6371 6367 6421 6417
6430 1 6370 1 6420 1
6429 -6426 6369 -6366 6419 -6416
6428 A 6368 D 6418 G
6427 6421 6367 6361 6417 6391
6426 -6429 6366 -6369 6416 -6419
6425 -3 6365 1 6415 -3
6424 458 6364 454 6414 458
(0*505+4*101+54) (0*505+4*101+50) (0*505+4*101+54)
6423 -2 6363 3 6413 -2
6422 458 6362 459 6412 458
(0*505+4*101+54) (0*505+4*101+55) (0*505+4*101+54)
6411 -3
6410 260
(0*505+2*101+58)
TBLTRN: Principles of Operation Manual Page 134
Symbol Dictionary Structure
6391 6387 6361 6357 6409 -2
6390 1 6360 1 6408 260
6389 -6386 6359 -6356 (0*505+2*101+58)
6388 B 6358 E 6407 -3
6387 6381 6357 6351 6406 1771
6386 -6389 6356 -6359 (3*505+2*101+54)
6385 -3 6355 7 6405 -2
6384 260 6354 454 6404 1771
(0*505+2*101+58) (0*505+4*101+50) (3*505+2*101+54)
6383 -2 6353 9 6403 4
6382 260 6352 464 6402 454
(0*505+2*101+58) (0*505+4*101+60) (0*505+4*101+50)
6401 6
6400 459
(0*505+4*101+55)
6381 6377 6351 6347 6399 10
6380 1 6350 1 6398 454
6379 -6376 6349 -6346 (0*505+4*101+50)
6378 C 6348 F 6397 12
6377 6371 6347 6341 6396 464
6376 -6379 6346 -6349 (0*505+4*101+60)
6375 -3 6345 13 6395 16
6374 1771 6344 1767 6394 1767
(3*505+2*101+54) (3*505+2*101+50) (3*505+2*101+50)
6373 -2 6343 15 6393 18
6372 1771 6342 1772 6392 1772
(3*505+2*101+54) (3*505+2*101+55) (3*505+2*101+55)
These would be represented in debugging output as follows.
ADDRESS 6431 OPR 1 LOC 6427 A
'' '' 6427 6431 SIN 4 SIZ 2 BYT 5 WRD 3 A
'' '' SIN 4 SIZ 2 BYT 5 WRD 2 A
ADDRESS 6391 OPR 1 LOC 6387 B
'' '' 6387 6391 SIN 2 SIZ 2 BYT 9 WRD 3 B
'' '' SIN 2 SIZ 2 BYT 9 WRD 2 B
ADDRESS 6381 OPR 1 LOC 6377 C
'' '' 6377 6381 SIN 2 SIZ 5 BYT 5 WRD 3 C
'' '' SIN 2 SIZ 5 BYT 5 WRD 2 C
ADDRESS 6371 OPR 1 LOC 6367 D
'' '' 6367 6371 SIN 4 SIZ 2 BYT 1 LOC 1 D
'' '' SIN 4 SIZ 2 BYT 6 LOC 3 D
ADDRESS 6361 OPR 1 LOC 6357 E
'' '' 6357 6361 SIN 4 SIZ 2 BYT 1 LOC 7 E
'' '' SIN 4 SIZ 2 BYT 11 LOC 9 E
ADDRESS 6351 OPR 1 LOC 6347 F
'' '' 6347 6351 SIN 2 SIZ 5 BYT 1 LOC 13 F
'' '' SIN 2 SIZ 5 BYT 6 LOC 15 F
ADDRESS 6421 OPR 1 LOC 6417 G
'' '' 6417 6421 SIN 4 SIZ 2 BYT 5 WRD 3 G
'' '' SIN 4 SIZ 2 BYT 5 WRD 2 G
'' '' SIN 2 SIZ 2 BYT 9 WRD 3 G
'' '' SIN 2 SIZ 2 BYT 9 WRD 2 G
TBLTRN: Principles of Operation Manual Page 135
Symbol Dictionary Structure
'' '' SIN 2 SIZ 5 BYT 5 WRD 3 G
'' '' SIN 2 SIZ 5 BYT 5 WRD 2 G
'' '' SIN 4 SIZ 2 BYT 1 LOC 4 G
'' '' SIN 4 SIZ 2 BYT 6 LOC 6 G
'' '' SIN 4 SIZ 2 BYT 1 LOC 10 G
'' '' SIN 4 SIZ 2 BYT 11 LOC 12 G
'' '' SIN 2 SIZ 5 BYT 1 LOC 16 G
'' '' SIN 2 SIZ 5 BYT 6 LOC 18 G
When a table entry contains only an address of an unknown
label, the table entry itself can be used to store the
necessary shift and sign information until the address is
determined. The value word of the symbol cell stores this
information for the first table entry in the list, and that
table entry stores the corresponding information for the
next. Packed with the sign and shift information is also
the table entry number, left shifted by multiplying times
8080 (101 possible shifts times 5 possible signs times 16
possible reduced byte sizes). The terminal table entry in
the list is either zero if there is no associated data cell,
or is a negative pointer to the negative back-pointer in the
data cell. The list is constructed only if, when the table
entry origin moves past all currently assembled items, an
unknown address has been the only item assembled since the
previous time the table entry origin moved past all
assembled items.
The LOCK variable is initially zero, and is again zeroed
when the table entry origin moves past all assembled table
entries. When an unknown address is assembled, LOCK is set
to 1 if it is currently zero or to 2 otherwise. LOCK is set
to 2 if any constant other than an unknown address is
assembled, or if the BIT operator specifies a deposit into
the table entry origin or into a table entry above it but
within the range of table entries assembled so far by the
current statement. The JSIGN variable records whether an
unknown address reference was encountered while LOCK was
zero. JSIGN is initially -1 but stores the appropriate sign
as 0 through 4 if an address is being temporarily stored.
IADDRS holds the location of the identifier code within the
symbol cell contaning the unknown label, JBASE holds the
reduced byte size, JSHIFT holds the shift, and JMORE holds 1
plus the offset from the current table entry origin. JMORE
is adjusted if the table entry origin moves, and, if JMORE
is no longer positive, the information stored by all of
these variables is packed into the table entry list if LOCK
is still 1 or into the data cell, creating a new one if none
exists, if LOCK is 2. IADDRS is adjusted whenever items are
inserted or deleted above the symbol cell in the symbol
dictionary. For example, the statements
3WRD 5BIT B
3WRD 5LFT LOC A
TBLTRN: Principles of Operation Manual Page 136
Symbol Dictionary Structure
3WRD 5LFT LOC B
4SIZ 3WRD 5LFT LOC A
3WRD 5LFT LOC B
5SIZ 3WRD 5LFT LOC A
3WRD 5LFT LOC B
would generate the following list structures and symbol and
data cells.
6423 6419 6431 6427
6422 1 6430 1
6421 24699 6429 48939
( 3* 8080+0*505+4*101+55) ( 6* 8080+0*505+4*101+55)
6420 A 6428 B
3 73184 6 97424
( 9* 8080+0*505+4*101+60) ( 12* 8080+0*505+4*101+60)
9 122972 12 147212
( 15* 8080+3*505+2*101+55) ( 18* 8080+3*505+2*101+55)
15 0 18 -6426
6427 6423
6426 -18
6425 -3
6424 458
( 0* 8080+0*505+4*101+54)
These would be represented in debugging output as follows.
ADDRESS 6423 OPR 1 SIN 4 SIZ 2 BYT 6 LOC 3 A
LIST END 15 A
BYTEINFO 9 SIN 2 SIZ 5 BYT 6 LOC 15 A
BYTEINFO 3 SIN 4 SIZ 2 BYT 11 LOC 9 A
ADDRESS 6431 OPR 1 SIN 4 SIZ 2 BYT 6 LOC 6 B
'' '' 6427 18 SIN 4 SIZ 2 BYT 5 WRD 3 B
POINTER 18 6427 B
BYTEINFO 12 SIN 2 SIZ 5 BYT 6 LOC 18 B
BYTEINFO 6 SIN 4 SIZ 2 BYT 11 LOC 12 B
Symbol Construction by Stack Operators
------ ------------ -- ----- ---------
The stack rotation operator ROT can cause contraction or
expansion of the symbol dictionary in order to remove all
but high precision zeroes from the storage of constants.
Such compacted storage is not efficient for stacks since
these are mostly formed of non-zero words. However, TBLTRN
is primarily a translator, not an operating system, so
efficient storage of constants to be assembled into table
entries is considered to be more important than the storage
of stacks. As examples of the manipulations performed by
the ROT operator, the stack generated by the statement
TBLTRN: Principles of Operation Manual Page 137
Symbol Construction by Stack Operators
PSH 33 A PSH 0 A PSH 0 A
or by the identical constant definition
A=3WRD 33
would appear initially, and after each of 3 rotations, as
follows.
4443 4439 4443 4439 4443 4439 4443 4439
4442 1003 4442 66 4442 66 4442 1003
4441 33 4441 -4438 4441 -4438 4441 33
4440 A 4440 A 4440 A 4440 A
4439 4433 4439 4433
4438 -4441 4438 -4441
4437 3 4437 3
4436 0 4436 0
4435 1 4435 2
4434 33 4434 33
The above is an extreme example since only one word in the
stack or constant is non-zero so that no extra data cell is
necessary whenever this is the highest precesion word in the
stack. A data cell would always be necessary if the stack
contains more than just a single non-zero entry. For
example, the stack generated by the statement
PSH 33 A PSH 22 A PSH 0
or by the identical constant definition
A=2WRD 22 3WRD 33
would appear initially, and after each of 3 rotations, as
follows.
4443 4439 4443 4439 4443 4439 4443 4439
4442 66 4442 66 4442 66 4442 66
4441 -4438 4441 -4438 4441 -4438 4441 -4438
4440 A 4440 A 4440 A 4440 A
4439 4433 4439 4433 4439 4431 4439 4433
4438 -4441 4438 -4441 4438 -4441 4438 -4441
4437 3 4437 3 4437 3 4437 3
4436 33 4436 22 4436 0 4436 33
4435 2 4435 1 4435 2 4435 2
4434 22 4434 33 4434 33 4434 22
4433 1
4432 22
TBLTRN: Principles of Operation Manual Page 138
Symbol Construction by Stack Operators
author: Donald E. Barth
Chemistry Dept.
Harvard University
12 Oxford Street
Cambridge, Mass.
updated: January 1973
TBLTRN releases
Aug 1972 Initial DECUS release.
Jan 1973 1. Extension. Rename definition of form A=.'/B/
2. Extension. Copy definition of form A=.''/B/
3. Extension. Expression as value tested by the
DIN, DIL, DILE, DIE, DIGE, DIG, IFN, IFL,
IFLE, IFE, IFGE, and IFG operators.
4. Correction. DEF, PSH and STK when acting upon
a symbol defined only as an address label did
not construct a constant of the same name.
5. Correction. POP did not reveal zero values
due to zero compression of multiple entry
constants.
6. Correction. Packing pattern used in constant
definition and at start of following statement
defining table entries sometimes produced
extra zero entries.
7. Correction. After PFX-1 statement or a symbol
definition, the precision set by PFX operator
was reset to second state prior rather than to
previous state.
8. Correction. Address label used in expression
following operator which could have taken
decimal integer prefix was treated as illegal
rather than having value zero.
9. Correction. Assembled text containing 2 as
integer prefix did not preface this integer
with DEC operator designation.
10. Correction. EAC operator could not have
alternate definition as address label.
TBLTRN Page 139
Index
$
as separate character class . . . . 21
defined . . . . . . . . . . . . . . 51
$$
defined . . . . . . . . . . . . . . 51
$$$
defined . . . . . . . . . . . . . . 52
example . . . . . . . . . . . . . . 55
'
as separate character class . . . . 21
defined . . . . . . . . . . . . . . 57
defining symbol identical to . . . 66
in range of Do-If class . . . . . . 38
''
defined . . . . . . . . . . . . . . 61
defining symbol identical to . . . 66
example . . . . . . . . . . . . . . 36
in range of Do-If class . . . . . . 38
pre-assembled code definition . . . 49, 106
(
as separate character class . . . . 21
defined . . . . . . . . . . . . . . 29, 68
example . . . . . . . . . . . . . . 25
((
defined . . . . . . . . . . . . . . 32, 69
)
as separate character class . . . . 21
defined . . . . . . . . . . . . . . 29, 70
example . . . . . . . . . . . . . . 25
))
defined . . . . . . . . . . . . . . 32, 70
when equivalent to ) ) . . . . . . 31
*
as pre-assembled code delimiter . . 22
in pre-assembled code example . . . 50
list of operator codes . . . . . . 125
+
as separate character class . . . . 21
defined . . . . . . . . . . . . . . 64
,
as separate character class . . . . 21
defined . . . . . . . . . . . . . . 20, 56
defining symbol identical to . . . 66
,,
defined . . . . . . . . . . . . . . 20, 56
defining symbol identical to . . . 66
TBLTRN Page 140
Index
in range of ,,, . . . . . . . . . . 57
,,,
defined . . . . . . . . . . . . . . 20, 56
defining symbol identical to . . . 66
-
as separate character class . . . . 21
defined . . . . . . . . . . . . . . 64
.
after BIT . . . . . . . . . . . . . 74
after WRD . . . . . . . . . . . . . 18
after WRD in packing pattern . . . 15
as local address label . . . . . . 18, 62
as separate character class . . . . 21
before text string in definition . 66
defined . . . . . . . . . . . . . . 62
in packing pattern . . . . . . . . 14, 63
in rename definition . . . . . . . 67
LOC unnecessary . . . . . . . . . . 62
...
defined . . . . . . . . . . . . . . 64
defining symbol identical to . . . 66
example . . . . . . . . . . . . . . 57
=
as separate character class . . . . 21
defined . . . . . . . . . . . . . . 64, 101
example . . . . . . . . . . . . . . 61
redefinition . . . . . . . . . . . 56
rename . . . . . . . . . . . . . . 67
==
and deferred text insertion . . . . 37
defined . . . . . . . . . . . . . . 36, 67, 101
example . . . . . . . . . . . . . . 38
redefinition . . . . . . . . . . . 56
terminating definition . . . . . . 56
within test table . . . . . . . . . 41
ACC
defined . . . . . . . . . . . . . . 70
example . . . . . . . . . . . . . . 25, 55, 61
address label
. as current . . . . . . . . . . . 18, 62
after ADR . . . . . . . . . . . . . 27, 71, 109
after BIT . . . . . . . . . . . . . 74
after HIA . . . . . . . . . . . . . 27, 84, 109
after LOA . . . . . . . . . . . . . 27, 89, 109
after LOC . . . . . . . . . . . . . 90
after WRD . . . . . . . . . . . . . 27
also as other operator . . . . . . 23, 26, 64, 71
defined . . . . . . . . . . . . . . 17, 26, 109
in symbol definition . . . . . . . 26
TBLTRN Page 141
Index
operators which need . . . . . . . 71
redefinition . . . . . . . . . . . 71
selective removal by XAD . . . . . 99
text string takes precedence over . 27
unknown . . . . . . . . . . . . . . 27
ADR
defined . . . . . . . . . . . . . . 27, 71
AND
defined . . . . . . . . . . . . . . 71
ARG
defined . . . . . . . . . . . . . . 72
argument of packing pattern
automatic argument . . . . . . . . 25, 72
explicit argument . . . . . . . . . 68, 84
NUL as null argument . . . . . . . 91
BAC
, necessary if issued . . . . . . . 56
,, in range . . . . . . . . . . . . 56
,,, in range . . . . . . . . . . . 57
defined . . . . . . . . . . . . . . 20, 73
termination of range . . . . . . . 73
bit numbering
overflow wrap-around . . . . . . . 74
reversal by BPR . . . . . . . . . . 74
set by BPR . . . . . . . . . . . . 76
bit size
set by BSZ . . . . . . . . . . . . 75, 76
BIT
. after . . . . . . . . . . . . . . 18, 62, 74
after WRD . . . . . . . . . . . . . 18, 74, 111
defined . . . . . . . . . . . . . . 26, 74
destination in range of DUP . . . . 16
blank
as separate character class . . . . 21
between text replacement and following symbol 46
extend character class of . . . . . 70
in text string . . . . . . . . . . 60
translation of query operator to . 52
BLK
causes local statement termination 73
defined . . . . . . . . . . . . . . 75
BOD
defined . . . . . . . . . . . . . . 76
versus EOD . . . . . . . . . . . . 83
BPR
defined . . . . . . . . . . . . . . 76, 113
BSZ
defined . . . . . . . . . . . . . . 76
byte shift
discussion . . . . . . . . . . . . 10
left by LFT . . . . . . . . . . . . 88
logical shift or multiplcation . . 10
TBLTRN Page 142
Index
right by RIT . . . . . . . . . . . 94
byte size
after change in symbol definition . 19
after use of packing pattern . . . 19
default . . . . . . . . . . . . . . 12
defined . . . . . . . . . . . . . . 10
during use of packing patern . . . 25
selection of . . . . . . . . . . . 12
when using BIT . . . . . . . . . . 75
byte template
(see packing pattern)
character class
alteration by ACC . . . . . . . . . 70
alteration example . . . . . . . . 55, 61
description of . . . . . . . . . . 20
restored by BLK . . . . . . . . . . 76
summary reported by $$$ . . . . . . 52
CLM
defined . . . . . . . . . . . . . . 39, 77
example . . . . . . . . . . . . . . 40
comment
after ,,, . . . . . . . . . . . . . 56
after ... . . . . . . . . . . . . . 64
example . . . . . . . . . . . . . . 57, 64
constant
as symbol type . . . . . . . . . . 23
defining value by DEF . . . . . . . 78
discussion of definition as . . . . 105
in parenthetical expression . . . . 30
increasing value by INC . . . . . . 87
multiple precision . . . . . . . . 9, 23
parenthetical expression in definition 31
redefinition . . . . . . . . . . . 64
reducing value by RED . . . . . . . 93
shifting value by SFT . . . . . . . 94
sign bit . . . . . . . . . . . . . 91
unknown in definition of itself . . 34
control transfer
permanent by TTY . . . . . . . . . 36, 98
temporary by == . . . . . . . . . . 36
DATA statement
column width set by CLM . . . . . . 77
discussion . . . . . . . . . . . . 39
example . . . . . . . . . . . . . . 40
statement width set by WID . . . . 99
DBG
defined . . . . . . . . . . . . . . 77
DEC
defined . . . . . . . . . . . . . . 28, 78
decimal integer prefix
(see integer prefix)
TBLTRN Page 143
Index
decimal radix
(see DEC)
DEF
defined . . . . . . . . . . . . . . 78
default
byte size . . . . . . . . . . . . . 12
offset . . . . . . . . . . . . . . 27
sign . . . . . . . . . . . . . . . 12
DIA
defined . . . . . . . . . . . . . . 79
dictionary
(see symbol dictionary)
DID
defined . . . . . . . . . . . . . . 79
DIE
defined . . . . . . . . . . . . . . 79
DIG
defined . . . . . . . . . . . . . . 80
DIGE
defined . . . . . . . . . . . . . . 80
DIL
defined . . . . . . . . . . . . . . 80
DILE
defined . . . . . . . . . . . . . . 80
DIN
defined . . . . . . . . . . . . . . 81
DINA
defined . . . . . . . . . . . . . . 81
DINO
defined . . . . . . . . . . . . . . 81
DIO
defined . . . . . . . . . . . . . . 81
DIU
defined . . . . . . . . . . . . . . 82
DMP
defined . . . . . . . . . . . . . . 82
Do-If class
defined . . . . . . . . . . . . . . 37
NST after . . . . . . . . . . . . . 35
text string after . . . . . . . . . 38, 57
text string symbol after . . . . . 38, 58
dump
of dictionary and table by DBG . . 77
of selected symbol or entry by TEL 96
of symbol dictionary by DMP . . . . 82
of table by LST . . . . . . . . . . 90
of text replacements by LMT . . . . 89
DUP
BIT destination in range of . . . . 16
defined . . . . . . . . . . . . . . 16, 82, 112
duplication
of table entry by DUP . . . . . . . 16, 82, 112
TBLTRN Page 144
Index
EAC
defined . . . . . . . . . . . . . . 20, 83
end of statement
indicated by , . . . . . . . . . . 56
END
defined . . . . . . . . . . . . . . 20, 83
defining symbol identical to . . . 66
EOD
EOD
versus BOD . . . . . . . . . . . . 76
FIL
defined . . . . . . . . . . . . . . 84
FIN
causes local statement termination 73
defined . . . . . . . . . . . . . . 84
HIA
defined . . . . . . . . . . . . . . 27, 84
IF class
at start of symbol definition . . . 101
defined . . . . . . . . . . . . . . 37
in table entry definition . . . . . 109
NST after . . . . . . . . . . . . . 35
termination of range by END . . . . 20, 83
text string after . . . . . . . . . 57
text string symbol after . . . . . 58
within range of deferred insertion 26
within range of IF class . . . . . 37
IFA
defined . . . . . . . . . . . . . . 85
IFD
defined . . . . . . . . . . . . . . 85
IFE
defined . . . . . . . . . . . . . . 85
IFG
defined . . . . . . . . . . . . . . 86
IFGE
defined . . . . . . . . . . . . . . 86
IFL
defined . . . . . . . . . . . . . . 86
IFLE
defined . . . . . . . . . . . . . . 86
IFN
defined . . . . . . . . . . . . . . 86
IFNA
defined . . . . . . . . . . . . . . 86
IFNO
defined . . . . . . . . . . . . . . 87
IFO
defined . . . . . . . . . . . . . . 87
IFU
TBLTRN Page 145
Index
defined . . . . . . . . . . . . . . 87
INC
defined . . . . . . . . . . . . . . 87
input text
storage after == closure . . . . . 68
storage after TTY control transfer 36
integer prefix
as operator value . . . . . . . . . 22
following constant instead of . . . 32
list of operators which accept . . 102, 125
parenthetical expression instead of 32
IOR
defined . . . . . . . . . . . . . . 87
JST
defined . . . . . . . . . . . . . . 88
label
(see address label)
LFT
defined . . . . . . . . . . . . . . 12, 88
line
length . . . . . . . . . . . . . . 20, 36
list
(see dump)
LMT
defined . . . . . . . . . . . . . . 43, 89
LOA
defined . . . . . . . . . . . . . . 27, 89
LOC
. after . . . . . . . . . . . . . . 18, 62
after WRD . . . . . . . . . . . . . 18
defined . . . . . . . . . . . . . . 26, 90
in symbol definition . . . . . . . 26
LST
defined . . . . . . . . . . . . . . 90
MSK
defined . . . . . . . . . . . . . . 90
example . . . . . . . . . . . . . . 24
multiple precision constant
(see constant)
(see value stack)
name stack
defined . . . . . . . . . . . . . . 33
example as address label stack . . 43
of DATA statement . . . . . . . . . 98
of table entry (see address label)
NEG
defined . . . . . . . . . . . . . . 91
NSN
defined . . . . . . . . . . . . . . 35, 91
TBLTRN Page 146
Index
example . . . . . . . . . . . . . . 61
NST
defined . . . . . . . . . . . . . . 35, 91
defining symbol identical to . . . 66
in symbol definition . . . . . . . 66
NSV
defined . . . . . . . . . . . . . . 35, 91
NUL
defined . . . . . . . . . . . . . . 32, 91
example . . . . . . . . . . . . . . 75
null text string symbol
after Do-If class . . . . . . . . . 38
definition as . . . . . . . . . . . 66
example . . . . . . . . . . . . . . 48
numeric symbol text
as name stack . . . . . . . . . . . 35
numeric suffix set by NSV . . . . . 91
symbol prefix set by NSN . . . . . 91
OCT
defined . . . . . . . . . . . . . . 28, 92
example . . . . . . . . . . . . . . 28
octal radix
(see OCT)
operator codes
list of . . . . . . . . . . . . . . 125
origin offset
by packing pattern . . . . . . . . 14, 63
when performed . . . . . . . . . . 15, 63
packing pattern
ARG in definition . . . . . . . . . 72
argument definition . . . . . . . . 72
automatic argument . . . . . . . . 25, 72
byte size after use of . . . . . . 19
defined . . . . . . . . . . . . . . 9, 24
discussion of definition as . . . . 102
end of argument list . . . . . . . 70
end of explicit argument . . . . . 70
example . . . . . . . . . . . . . . 25, 70, 71
explicit argument . . . . . . . . . 68, 84
global selection by TON . . . . . . 14, 97
local selection . . . . . . . . . . 97
NUL as null argument . . . . . . . 91
null . . . . . . . . . . . . . . . 14, 24, 90
null argument . . . . . . . . . . . 32
origin increment specified by . . . 14
parenthetical expression as argument 31
redefiniton of . . . . . . . . . . 64
skip to origin increment . . . . . 70
trace of sample definition . . . . 53
use of in definition in range of TON 19
within range of pattern selected by TON 19
TBLTRN Page 147
Index
parenthetical expression
as packing pattern argument . . . . 24
defining constant . . . . . . . . . 31
defining table entry . . . . . . . 31
discussion . . . . . . . . . . . . 29
within parenthetical expression . . 30
PFX
defined . . . . . . . . . . . . . . 33, 92
example . . . . . . . . . . . . . . 34
POP
defined . . . . . . . . . . . . . . 35, 93
pre-assembled code
defining symbol as . . . . . . . . 61, 106
discussion . . . . . . . . . . . . 49
interpretation of . . . . . . . . . 22
precision as value of operator
(see PFX)
(see value stack)
prefix
(see integer prefix)
(see PFX)
PSH
defined . . . . . . . . . . . . . . 33, 93
example . . . . . . . . . . . . . . 34
query operator
(see $ $$ or $$$)
discussion . . . . . . . . . . . . 51
radix
discussion . . . . . . . . . . . . 28
in parenthetical expression . . . . 30
in symbol definition . . . . . . . 73
in table entries . . . . . . . . . 97
interpretation of integers under . 21
temporary . . . . . . . . . . . . . 78, 92
RED
defined . . . . . . . . . . . . . . 93
redefinition
of address label . . . . . . . . . 71
of constant . . . . . . . . . . . . 64
of packing pattern . . . . . . . . 64
RIT
defined . . . . . . . . . . . . . . 12, 94
ROT
defined . . . . . . . . . . . . . . 35, 94
SAV
causes local statement termination 73
defined . . . . . . . . . . . . . . 94
SFT
defined . . . . . . . . . . . . . . 94
shift
TBLTRN Page 148
Index
(see byte shift)
sign
+ . . . . . . . . . . . . . . . . . 64
- . . . . . . . . . . . . . . . . . 64
AND . . . . . . . . . . . . . . . . 71
default . . . . . . . . . . . . . . 12
in parenthetical expression . . . . 30
IOR . . . . . . . . . . . . . . . . 87
of automatic argument . . . . . . . 73
of packing pattern argument . . . . 9
should specify for unknown label . 27
when using BIT . . . . . . . . . . 75, 77
while packing table entry . . . . . 12
XOR . . . . . . . . . . . . . . . . 100
single precision constant
(see constant)
SIZ
defined . . . . . . . . . . . . . . 10, 95, 112
space
(see blank)
SRX
defined . . . . . . . . . . . . . . 95
example . . . . . . . . . . . . . . 29
in parenthetical expression . . . . 30
in symbol definitions . . . . . . . 95
stack
(see name stack)
(see value stack)
statement
automatic continuation . . . . . . 20, 73, 83
continuation . . . . . . . . . . . 20, 56
end of == definition . . . . . . . 68
explicit continuation . . . . . . . 56
length . . . . . . . . . . . . . . 20
local termination . . . . . . . . . 73
termination . . . . . . . . . . . . 56, 83
STK
defined . . . . . . . . . . . . . . 33, 96
example . . . . . . . . . . . . . . 34
symbol definition
as group of operators . . . . . . . 66
as pre-assembled code . . . . . . . 61, 106
as text string . . . . . . . . . . 66
by = . . . . . . . . . . . . . . . 64
discussion . . . . . . . . . . . . 101
IF class at start . . . . . . . . . 101
temporary byte size set during . . 19
temporary packing pattern used in . 19
symbol dictionary
restored by BLK . . . . . . . . . . 56, 76
selective address removal by XAD . 99
selective operator removal by XSY . 100
symbol
TBLTRN Page 149
Index
defining as text string . . . . . . 58, 66
definition by = . . . . . . . . . . 64
definition by == . . . . . . . . . 36, 67
detecting breaks between . . . . . 20
length . . . . . . . . . . . . . . 23
type of . . . . . . . . . . . . . . 23
table entry origin
address label of . . . . . . . . . 71
increment of by packing pattern . . 14
table entry
duplication by DUP . . . . . . . . 16, 82, 112
parenthetical expression in definition 31
table termination
by BLK . . . . . . . . . . . . . . 75
by FIN . . . . . . . . . . . . . . 84
by SAV . . . . . . . . . . . . . . 94
fill with zeroes . . . . . . . . . 84
TEL
causes local statement termination 73
defined . . . . . . . . . . . . . . 96
text string symbol after . . . . . 58
transparent symbol after . . . . . 66
teletype
symbol definition on . . . . . . . 36, 67
test table
discussion . . . . . . . . . . . . 41
specifying . . . . . . . . . . . . 98
text replacement symbol
(see text string symbol)
text replacement
(see text string symbol)
blanks between it and following symbol 46
buffer overflow warning . . . . . . 20, 42
by numeric symbol text . . . . . . 91
deferred . . . . . . . . . . . . . 26, 37, 58
deferred example . . . . . . . . . 48, 107
dump of . . . . . . . . . . . . . . 89
loop termination set by LMT . . . . 43
text string symbol
after Do-If class . . . . . . . . . 38
as user defined function . . . . . 42
defined . . . . . . . . . . . . . . 25
precedence over label definition . 27
text string
after ' . . . . . . . . . . . . . . 57
after '' . . . . . . . . . . . . . 61
after ACC . . . . . . . . . . . . . 70
after Do-If class . . . . . . . . . 38
blanks in . . . . . . . . . . . . . 60
defined . . . . . . . . . . . . . . 25
defining symbol as . . . . . . . . 66
discussion of definition as . . . . 106
TBLTRN Page 150
Index
within pre-assembled code . . . . . 49
within symbol definition . . . . . 61
within text string . . . . . . . . 61, 66
written as output . . . . . . . . . 60
TON
defined . . . . . . . . . . . . . . 14, 97, 112
example . . . . . . . . . . . . . . 70
restoration after pattern use in definition 19
second packing pattern within range of first 19
transparent symbol
,, not starting line . . . . . . . 56
and deferred text insertion . . . . 26
definition as . . . . . . . . . . . 66
TRX
defined . . . . . . . . . . . . . . 97, 112
example . . . . . . . . . . . . . . 29
in parenthetical expression . . . . 30
TST
defined . . . . . . . . . . . . . . 41, 98
TTL
defined . . . . . . . . . . . . . . 39, 98
example . . . . . . . . . . . . . . 40, 77
TTY
and deferred text insertion . . . . 37
causes local statement termination 73
defined . . . . . . . . . . . . . . 36, 98
within test table . . . . . . . . . 41
user defined function
discussion . . . . . . . . . . . . 26, 42, 106
pre-assembly of . . . . . . . . . . 49
value stack
adding item to by PSH . . . . . . . 93
adding item to by STK . . . . . . . 96
as value of operator . . . . . . . 33
defined . . . . . . . . . . . . . . 33
precision as value of operator . . 92
removing item from by POP . . . . . 93
rotating by ROT . . . . . . . . . . 94
WID
defined . . . . . . . . . . . . . . 40, 99
example . . . . . . . . . . . . . . 40, 77
WRD
. after . . . . . . . . . . . . . . 18
. after in packing pattern . . . . 15, 63
address label after . . . . . . . . 27, 71
BIT after . . . . . . . . . . . . . 18
defined . . . . . . . . . . . . . . 8, 99
LOC after . . . . . . . . . . . . . 18
XAD
TBLTRN Page 151
Index
causes local statement termination 73
defined . . . . . . . . . . . . . . 99
redefinition of . . . . . . . . . . 56
XOR
defined . . . . . . . . . . . . . . 100
XSY
causes local statement termination 73
defined . . . . . . . . . . . . . . 100
redefinition of . . . . . . . . . . 56
text string symbol after . . . . . 58
transparent symbol after . . . . . 66