Google
 

Trailing-Edge - PDP-10 Archives - decus_20tap2_198111 - decus/20-0050/tbltrn.doc
There is 1 other file named tbltrn.doc in the archive. Click here to see a list.




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