@X @~
~L3 COUK1247
80
~V7 56 2 -5
~D10
~H                    MUSS
~
~
~D10
   ~H          BSC071
~D10
~MMANCHESTER UNIVERSITY  -  CONDFIDENTIAL
~
~
                                                   ISSUE 11~
~V9 -1
~P
~V9 1
~YBSC071
~S~M~OBASIC COMPILER IMPLEMENTATION MANUAL
~S~M~OSection 7
~S~OSection 7. Expression Processing
~S~O1.1 General Description
~BThis module of the compiler provides procedures for the
recognition, analysis and compilation of expressions.
~S~O2. Interfaces
~S~O2.1 Section Interfaces Used
~
   Section 3 :   (Lexical Analysis)~
   Section 4 :   (Declaration Processing)~
   Section 8 :   (Name List Management)~
   Section 9 :   (Fault and Reference Point Monitoring)~
~S~O2.2 Section Interface
~
Exported Procedures:~
   EXPR~
   IN.EXPR~
   CODE.EXPR~
   CODE.LET~
   CODE.MAT~
   CODE.SUBS~
   CODE.STR.EXPR~
   EVAL.EXPR~
   SAVE.NODE.SUBS~
   CODE.NODE~
   PL.CD.SEQ~
   PL.STK.LB~
   PL.COND.JUMP~
   PL.COMP.STR~
   OUT.AS~
   TEMP.DECL~
~S11) EXPR(KIND,REQUIRED.TYPE)CODE.INFO
~BThis procedure recognises an expression, performs implicit declarations
where necessary for operands, and checks for type and compatability between
operators and operands within the expression.  Any faults are reported
and control returned to the statement driver.  Then providing the
expression is semantically valid, code is generated for the expression.
~BP1 specifies the restrictions on the type and kind of expression
valid.  It is encoded as follows:~
~T# 15
~
   Bit  0 = 1~Istring expression not permitted.~
   Bit  1 = 1~Inumeric expression not permitted.~
   Bit  2 = 1~Irelational expression not permitted.~
   Bit  4 = 1~Iexpression consists of a single operand.
(Recognition stops after the first operand without checking whether it
is in fact only part of an expression).~
   Bit  5 = 1~Iexpression consists of a single subprogram call (again
recognition stops after first operand).~
   Bit  6 = 1~Iallow expression to be an array name.~
   Bit  7 = 1~Iexpression consists of a single simple variable operand.~
   Bits 8,9=1~I1 dimensional array expression.~
           =2~I2 dimensional array expression.~
           =3~ILHS of matrix assignment.~
   Bits 11-15~Itype of array expression.~
~BBits 0-4 of P2 if non-zero specify the required numeric type of the value, aft
er
evaluation of the expression a conversion will be planted if necessary.
A value of zero in bit 8 of P2 means load the A with the
expression value, a one means load B with it.
This parameter is only relevant to numeric expressions.
~BThe coding of some relational expressions leaves the
logical result in the T register, this is indicated by a
positive result encoded as follows: 1 =, 2 /=, 3 >=, 4 <,
5 =<, 6 >.  The result is zero in all other situations.
~BThis procedure is generally used when the syntax and code generation
for the expression can be done in sequence without any intervening
processing.
~S12) IN.EXPR(KIND)EXPR.AP
~BThis procedure recognises an expression, processes implicit
declarations and checks for a semantically correct expression as
in EXPR above.  The parameter P1 is interpreted
as in EXPR.
The result is an index into AS to the terminal node for the expression.
Other sections of the compiler may only inspect the first word of this
node to ascertain the type and kind of the actual expression.  All
other details of the expression analysis record are known only to this
section.
~BThis procedure is used when intervening action is required
between the syntax and code generation phase for an expression,
and for matrix assignment.
~S13) CODE.EXPR(EXPR.AP,REQUIRED.TYPE)CODE.INFO
~BThis procedure generates code for an expression which has
previously been processed by IN.EXPR.  P1 is an index into AS
to the root node for the expression, P2 and the result are interpreted
as P2 in EXPR.
~S14) CODE.LET([LHS.AP.LIST],NO.OF.LH.OPERANDS,RHS.AP)
~BThis procedure performs the code generation for the LET statement.
P1 is a bounded pointer to a vector containing the indices into AS
of the operands to be assigned to.  P2 specifies the number of
operands to be assigned to.  P3 is the index into AS for the RHS
expression.  The procedure assumes that the semantics of the
statement are correct.
~S15) CODE.MAT(LHS.AP,RHS.AP)
~BThis procedure codes the matrix assignment.  P1 is the index
to the expression tree of the matrix to be assigned too, and P2
is an index to the matrix expression.
~S16) CODE.SUBS(ARR.PROPS,SUBS.AP)
~BThis procedure plants code to load B with an array element
subscript.  P1 is the NLIST index to the array properties (of
type N.LIST.E) and P2 is an index into AS to the subscript
list of expression trees for the array element.
~S17) CODE.STR.EXPR(STR.EXPR.AP,ACTION)
~BThis procedure plants code for a string expression.  P2 determines
if a reference to the string expression value is generated, or to
copy the string value to a predeclared string variable.  If a reference
is requested and the expression involves substrings or concatenation the
string value is first copied to a temporary string variable and code planted
to create reference to the temporary string.
~BThe second parameter is encoded as follows:~
~T# 3 6 8
~
# 0#-~ICreate string expression value reference in A.~
~
# 1#-~IAs 0 but reference in D.~
~
#>2#-~ICopy string expression value to variable whose MUTL name is
given by P2 & %FFF.  If bit 14 of P2 is zero then it is the MUTL
name of a pointer to a string variable, otherwise it is the MUTL name of a
string.~
~S18) EVAL.EXPR(TYPE,CONST.PTR,EXPR.AP)KIND
~BIf the expression is a constant of type P1
its value is put in the appropriate field of CLIST.E pointed at by P2.  P3
is the expression tree index.  A non-zero result indicates a constant
expression of the required type and the result is an encoding of its type,
a zero result means a variable expression.
~S19) SAVE.NODE.SUBS(NODE.AP)
~BIf the node of the expression tree indexed by P1 has a variable
subscript or a variable substring this procedure codes them and
assigns them to temporary variables and modifies the node accordingly.
(Note.  Now that with CODE.LET we should be able to remove
this from the interface).
~S110) CODE.NODE(OP.CODE,NODE.AP)
~BThis procedure plants code to coerce the A/B register with
an operand.  P2 is an index into AS of an operand node.  P1
specifies the OP.CODE as follows:~
~
   Bit  8=0/1~IA/B MUTL register.~
   Bits 0,4~IOpcode.  The opcodes are as described in section 3.~
~I18 - Load~
~I19 - Assign~
~S111) PL.CD.SEQ(CODE.SEQUENCE)
~BThis procedure issues a sequence of TL procedure calls.
A TL call is encoded in one or two elements.  Let E1 and E2 represent
the elements of an encoding.  Bits 12-15 of the first element determine
the action and is encoded as follows:~
~
~M0 TL.PL(E1 & %FFF, OPERAND)
~
The OPERAND is encoded in E2 as follows:~
~
If bit 14, 15 of E2 = 3 then the operand is the current literal which will be
set by PL.CD.SEQ to hold the FIND.N index of a procedure as
specified by bits 0-11 of E2.~
~T# 25
~
# 0  -  BIO.READ~
# 1  -  BIO.END.READ~
# 2  -  BIO.INPUT~
# 3  -  BIO.ELAPSED~
# 4  -  BIO.SKIP.REST~
# 5  -  BIO.SET.REC~
# 6  -  BIO.OUTPUT~
# 7  -  BIO.ENC.FORMAT~
# 8  -  BIO.PRINT.SEP~
# 9  -  BIO.OUT.SEP~
#10  -  BIO.PRINT.NL~
#11  -  BIO.PRINT.TAB~
#12  -  BIO.ENC.RUN.FORMAT~
#13  -  BIO.EXCEPTION~
#14  -  BIO.END.RUN~
#15  -  BIO.MARGIN~
#16  -  BIO.ZONE~
#17  -  BIO.OPEN~
#18  -  BIO.PRINT.I16~
#19  -  BIO.PRINT.I32~
#20  -  BIO.PRINT.R32~
#21  -  BIO.PRINT.R64~
#22  -  BIO.PRINT.STRING~
#23  -  BIO.MAT.PRINT.I8~
#24  -  BIO.MAT.PRINT.I16~
#25  -  BIO.MAT.PRINT.I32~
#26  -  BIO.MAT.PRINT.R32~
#27  -  BIO.MAT.PRINT.R64~
#28  -  BIO.MAT.PRINT.STRING~
#29  -  BIO.CLOSE.ALL~
#30  -  BIO.FORMAT~
#31  -  BIO.IN.I16~
#32  -  BIO.IN.I32~
#33  -  BIO.IN.R32~
#34  -  BIO.IN.R64~
#35  -  BIO.IN.STR~
#36  -  BIO.LINE.IN.STR~
#37  -  BIO.MAT.IN.I8~
#38  -  BIO.MAT.IN.I16~
#39  -  BIO.MAT.IN.I32~
#40  -  BIO.MAT.IN.R32~
#41  -  BIO.MAT.IN.R64~
#42  -  BIO.MAT.IN.STR~
#43  -  BIO.INIT.RUN~
#44  -  BIO.STR.ASS~
#45  -  BIO.STR.COMP~
#46  -  ANGLE~
#47  -  D.ANGLE~
#48  -  BIO.CEIL~
#49  -  BIO.D.CEIL~
#50  -  BIO.DATE~
#51  -  BIO.EPS~
#52  -  BIO.D.EPS~
#53  -  BIO.INF~
#54  -  BIO.FP~
#55  -  BIO.DFP~
#56  -  R.IP~
#57  -  DP.IP~
#58  -  BIO.INT~
#59  -  BIO.DINT~
#60  -  LOG.2~
#61  -  DLOG.2~
#62  -  BIO.I16.REM~
#63  -  BIO.I32.REM~
#64  -  BIO.REM~
#65  -  BIO.DREM~
#66  -  BIO.RND~
#67  -  BIO.ROUND~
#68  -  BIO.DROUND~
#69  -  BIO.SIGN~
#70  -  BIO.DSIGN~
#71  -  BIO.TIME~
#72  -  BIO.TRUNCATE~
#73  -  BIO.D.TRUNCATE~
#74  -  BIO.HANDLER~
#75  -  BIO.EXIT.HANDLER~
#76  -  BIO.SET.ACCESS~
#77  -  BIO.SET.ORGANISATION~
#78  -  BIO.SET.REC.TYPE~
#79  -  BIO.SET.R.KIND~
#80  -  BIO.SET.R.LENGTH~
#81  -  BIO.CLOSE~
#82  -  BIO.ASK~
#83  -  BIO.ASK.STRING~
#84  -  BIO.ASK.INT~
#85  -  BIO.END.INPUT~
#86  -  BIO.END.OUTPUT~
#87  -  BIO.ERASE~
#88  -  BIO.RESET~
#89  -  BIO.S.DATE~
#90  -  BIO.S.TIME~
#91  -  BIO.L.CASE~
#92  -  BIO.U.CASE~
#93  -  BIO.L.TRIM~
#94  -  BIO.R.TRIM~
#95  -  BIO.ORD~
#96  -  BIO.POS~
#97  -  BIO.STR~
#98  -  BIO.D.STR~
#99  -  BIO.VAL~
#100 -  BIO.CAUSE~
#101  -  BIO.PAR.CHAN~
#102  -  BIO.MAT.R32.SCALE~
#103  -  BIO.MAT.R64.SCALE~
#104  -  BIO.MAT.R32.CONST~
#105  -  BIO.MAT.R64.CONST~
#106  -  BIO.MAT.R32.UNARY~
#107  -  BIO.MAT.R64.UNARY~
#108  -  BIO.MAT.R32.DIADIC~
#109  -  BIO.MAT.R64.DIADIC~
#110  -  BIO.MAT.STR.ASS~
#111  -  BIO.DET.R32~
#112  -  BIO.DET.R64~
#113  -  BIO.CDET.R32~
#114  -  BIO.CDET.R64~
#115  -  BIO.DOT.R32~
#116  -  BIO.DOT.R64~
#117  -  BIO.LBOUND~
#118  -  BIO.UBOUND~
#119  -  BIO.D.SIZE~
#120  -  BIO.SIZE~
#121  -  BIO.REDIM.1~
#122  -  BIO.REDIM.2~
~
This number is known as the RUNTIME.PROC.ID.~
~
Furthermore it is assumed that the opcode is STK.LB (i.e. %48).
If bits 14, 15 of E2 = 2 then the operand is as specified
by bits 0-11 of E2.~
~
# 0  -  DATAMN~
# 1  -  DATAMN+1~
# 2  -  TINT~
# 3  -  G.LIT.16.0~
# 4  -  LAB.MN~
# 5  -  OPEN.ID.MN~
# 6  -  GO.SUB.LABS~
# 7  -  GO.SUB.PTR~
# 8  -  ZERO~
# 9  -  ONE~
#10  -  LAST.MN+1~
#11  -  G.LIT.32.0~
#12  -  LAST.MN+2~
#13  -  C.EXIT.LAB~
#14  -  CD.MN.0~
#15  -  G.LIT.16.1~
#16  -  CD.MN.1~
#17  -  CUR.PROC~
#18  -  Mutl name of pointer to type STR.N~
#19  -  EXLINE.MN~
#20  -  EXTYPE.MN~
#21  -  TEMP.0 (local to PL.CD.SEQ)~
~
Otherwise if bits 14, 15 of E2 are zero or one then OPERAND is E2.~
~T# 4 8
~
#1.~IStart procedure call to BASIC run-time support procedure
TL.CLIT.32 (FIND.N index of proc whose RUN.TIME.PROC.ID is
given by E1 & %FFF) TL.PL (%48, result type).~
~
#2.~IConvert accumulator from degrees to radians if OPTION DEGREES
operative.~
~
#3.~IPlant MUTL built in function.~
#~ITL.PL'%32,E1 & %FF)~
~
#~IIf bit 1D of E1 is set then if no 16 bit integer function is
available plant convert to 32 bit integer prior to TL.PL call.~
~
#~IIf bit 9 of E1 is set then if no 16 bit integer function is
available plant convert to integer 16 bit after TL.PL call.~
~
#~IIf bit 11 of E1 is set then mark accumulator as not in use.~
~
#4.~IConvert accumulator from radians to degrees if OPTION DEGREES
operative.~
~
#5.~IDeclare temporary string variable TL.S.DECL("", %80, E1 & %FFF).
If E1 & %FFF is zero then a string of default size is declared.  MUTL
name is assigned to local TEMP.0 of PL.CD.SEQ.~
~
#6.~IStack accumulator as parameter and mark it as out of use.~
#~ITL.PL(%41, %3000).~
~
#7.~ICode first string parameter CODE.STR.EXPR (PARAM1, E1 & %FFF).~
~
#8.~IInform MUTL of register retention requirements~
#~ITL.REG (E2).~
~
#9.~IPlant code to copy first string parameter to temporary string
declared by action 5.~
#~ICODE.STR.EXPR(PARAM1, TEMP.0).~
~
#10.~IEnd of procedure call.~
#~ITL.PL(%42, 0).~
~
#11.~IBits 0-3 of E1 determine the required action.~
#~I      0  stack reference to array descriptor of a parameter~
#~I      1  stack reference to array and its descriptor of a~
#~I         parameter.~
#~IBit  4-7 of E1 specify which parameter.~
~
#12.~IPlant code to evaluate parameter.  E1 & %FF specify
the numeric target type for the parameter. If bit 11 of E1 is set
then the value of the parameter is stacked and the accumulator
marked as not in use.  E1 & %700 specify the parameter number.~
~
#13.~ISet MAXLEN size of first parameter.~
~
#14.~ICode second string parameter~
#~ICODE.STR.EXPR(PARAM2, E1 & %FFF).~
~
#15.~IPlant A= (or A= ref) to first parameter.~
~S112) PL.STK.LB(BIO.PROC.ID)
~BThis procedure first calls TL.C.LIT.32 to set the current
literal to the FIND.N index of the procedure as identified by P1, then
~X {* }\
TL.PL(%48{STACK.LIB.LINK},0) is called.  The encoding of P1
is as described under PL.CD.SEQ.
~X {{ }}
~S113) PL.COND.JUMP(TEST,LABEL)
~BThis procedure plants a conditional jump to the label
whose MUTL name is given by P2.  Bits 0 - 7 of P1
specify the whereabouts (i.e. in A or T) of the evaluation
of a relational expression.  If bit 8 of P1 = 0 then
control is transferred if the relational expression is true,
otherwise control is transferred if it is false.
~S114) PL.STR.COMP(STR.VAR.MN,STR.LIST,INDEX)
~BThis procedure plants code to compare a string variable with
a string constant.  P1 contains the MUTL name of the variable,
and P2 is a bounded to a string list with P3 indexing the required
string constant.  If bit 14 of P1=1 then the last call of PL.STR.COMP
was made with the same string variable.
~S115) OUT.AS()
~BThis procedure prints the analysis record on the current output
stream.  This procedure is for development purposes only and it is
available as a library procedure in the computer.
~S116) GET.TEMP(TYPE,DIM)MUTL.NAME
~BThis procedure returns the MUTL name of a variable for temporary
use (i.e. current statement) whose data type is given by P1, if
P1 is -1 thia means a TL select variable.  A value of zero for P2
means a scalar variable is required, otherwise an array of P2 elements
is obtained.  All temporary variables become available at the end of
each statement.
~S117) INIT.STAT.7()
~BThis procedure initialises code generation variables at the start
of each statement.
~S~O3. Implementation
~S~O3.1 Outline of Operation
~S~MEXPRESSION TREES
~BThe analysis record for an expression is in the form of a binary
tree.  Nodes are either terminal (operands) or non-terminal (operators).
Basic operands such as constants, variables, array element references,
function references appear as terminal nodes.  For each non-terminal
node there is an operator to specify how the two immediately subservient
nodes are coerced to form the operand of the node.  During code generation
the tree is pruned and updated.
~S~OTERMINAL NODE
~T# 9 13
~
WORD 0#Bit 7 = 1 Means terminal node.~
~
#Bits 0 -> 3 Operand kind.~
# 0~IExplicit constant.~
# 1~IVariable.~
# 2~IArray element.~
# 3~IArray.~
# 4~IArray value (i.e. IDN, ZERO, CON, NULL).~
# 5~IArray functions (i.e. TRN, INV).~
# 6~ISubroutine.~
# 7~IFunction.~
# 8~IBasic supplied subroutine.~
# 9~IBasic supplied function.~
#12~IOperand in accumulator or B register.~
#13~IOperand stacked.~
#14~IOperand is a boolean function of the contents of T register
the function is specified by T.FN and is encoded as 1=, 2/=, 3>=,
4<, 5=<, 6>.~
#15~IUnprocessed name.~
~BDuring syntax recognition of statements the kind of
named operands are not determined, therefore terminal nodes have an operand
kind of 0 or 15.  The kind and types of all nodes is determined
prior to code generation in the reduce expression process
(REDUCE.EXPR), thus terminal nodes then have a value between 0 and 9.
During code generation (CODE.EXPR) the tree is repeatedly pruned as
coding progresses and values 12, 13 and 14 indicate the whereabouts
of the intermediate operands used during evaluation.
~
~T# 14
~
Bit  4~IFor unprocessed names (i.e. not reduced) then
bit 4=1 indicates that use of this name as a simple
variable is prohibited.~
~
Bit  6 = 1~IChannel expression node.~
~
Bit  8 = 1~IOperand has a subscript expression list or an
argument expression list.~
~
Bit  9 = 1~IOperand has a substring specifier.~
~
Bit 10 = 1~IOperand is a parenthesised expression in a string array
expression.~
~
Bit 11 - 13~ISize of arithmetic operand.~
~I0 - byte, 1 - 16 bit, 2 - 32 bit, 3 - 64 bit.~
~
Bit 14 - 15~IType. 0 - Real, 1 - Integer, (2 - reserved for logical
type), 3 - String.~
~
WORD 1~IIndex into itemised line L.BUFF of item associated with
this operand.  This information is maintained so that typing and coercion
errors yield an accurate diagnosis.~
~
WORD 2~IFor named operands it contains a NLIST index.  For
explicit constants it contains a CLIST index.  For basic supplied functions an
identifier for the particular version of the basic procedure
required for this node.~
~
WORD 3~IIf the node has a subscript/argument expression list
then it contains an index into AS to an expression list.  A
subscript/argument expression list commences with a count followed
by that number of indexes to the expressions.  A count of
zero is valid and means that the function or subroutine call has
no arguments.~
~
WORD 4, 5~IA non-zero value in word 4 indicates a substring specifier,
in which case word 4 contains an index into AS to the lower substring
specifier expression, and word 5 contains an index into AS to the upper substrin
g
specifier expression.~
~
Note for constants and names without subscripts, arguments and substring
specifiers the node is 3 words long, otherwise it is 6 words.
~S~ONON TERMINAL NODE
~
~
WORD 0~IBit 7 = 0 Means non-terminal node.~
~IBits 0 -> 5 Operator.~
~
~IOperator identfifier, see section 3 for list of operators.~
~
~IBit  6=1 Channel expression node.~
~IBits 9   specify expression kind~
~I       0 - numeric or string expression~
~I       1 - complete numeric or string array expression.~
~
~IBits 10-15.  See notes for corresponding fields of terminal
nodes.~
~
WORD 1~IAs word 1 of terminal node.~
~
WORD 2~IIndex into analysis record of left hand operand.~
~
WORD 3~IIndex into analysis record of right hand operand.~
~S~MOUTLINE OF OPERATION OF PROCEDURES
~BFor expression recognition an operator precedence algorithm
is used to produce an analysis
record for the expression on the AS stack.  The WS stack holds
alternating operator entries prior to their placement in the
analysis record.  On accepting an operand from the itemised line
a terminal expression node is pushed onto the AS stack and an index to
it pushed onto the WS stack.  On accepting an operator from the
itemised line its precedence is compared with the operator at the top
of the stack, if it is of higher procedence it is pushed onto the WS
stack; otherwise a non-terminal node is created on the AS stack for
the coercion of the operand, operator, operand triplet at the top of
the WS stack.  This triplet is moved to the AS stack and a pointer to the newly
created non-terminal node pushed onto the WS stack, the comparison
action of operators is then repeated.  An operator precedence table
controls the operator action for arithmetic, relational and
character.
~BAt the start of recognition a special low precedence operator is
pushed onto the WS stack and throughout recognition the WS stack
contains a sequence of alternating operator operands.  On encountering
a bracketed expression the expression recognition procedure
is called and an index to the analysis
record for the subexpression is pushed onto the WS stack.
~BA unary plus or minus on input gets replaced by a zero operand and
a plus or minus.  Similarly, a unary .NOT. gets replaced by a .TRUE.
operand and a high precedence .NEQV..
~BThe expression recognition procedure is called recursively
to recognise any embedded bracketed
subexpression, subscript lists, parameter lists or substring list.
~Q 14
~S~OANALYSIS RECORD EXAMPLES
~3
~Q 12
~
1.    B+C*D+E~
                  |--+--|~
                  |     |~
                  |     |~
               |--+--|  E~
               |     |~
               |     |~
               B  |--*--|~
                  |     |~
                  |     |~
                  C     D~
~
~
~
~
~Q 16
~
2.    B**(-C*(D+E)/F)~
~
                  |--**--|~
                  |      |~
                  |      |~
                  B   |--/---|~
                      |      |~
                      |      |~
                  |--*---|   F~
                  |      |~
                  |      |~
               |----| |--+--|~
               |    | |     |~
               |    | |     |~
               O    C D     E~
~
~Q 20
~
3.    B+C >= C OR NOT D =< E+F AND G~
~
                  |---OR--------|~
                  |             |~
                  |             |~
               |---GE---|    |---NEQV---|~
               |        |    |          |~
               |        |    |          |~
           |---+---|    H  .TRUE.    |---AND---|~
           |       |                 |         |~
           |       |                 |         |~
           B       C              |---=<---|   G~
                                  |        |~
                                  |        |~
                                  D     |--+--|~
                                        |     |~
                                        |     |~
                                        E     F~
~
~
~
~
~Q 13
~
4.    B(I%+1,J%)~
~
                              (|,|)~
                               | |~
                               | |~
                               | J~
                               |~
                               |~
                            |--+--|~
                            |     |~
                            |     |~
                            I     1~
~0
~Q 52
~M~OOperator precedence table
~
~MCURRENT OPERATOR
~3
~
~
          ~O     0   1   2   3   4   5   6   7   8   9  10  11 ~O~
         |   |   |   |   |   | R | N | A | X |   | I | E |   |~
         |   | U |** | * | + | E |HE | N | OO| ? | M | Q | U |~
         |~O   | N-| ^ | / | - | L |PQ | D | RR|   | P | V | N+~O|~
         |   |   |   |   |   |   |   |   |   |   |   |   |   |~
       0 | U | 3 | 0 | 0 | 2 | 2 | 3 | 2 | 2 | 2 | 2 | 2 | 3 |~
         |~O N-|   |   |   |   |   |   |   |   |   |   |   |   ~O|~
         |   |   |   |   |   |   |   |   |   |   |   |   |   |~
       1 | **| 2 | 2 | 2 | 2 | 2 | 3 | 2 | 2 | 2 | 2 | 2 | 0 |~
         |~O  ^|   |   |   |   |   |   |   |   |   |   |   |   ~O|~
         |   |   |   |   |   |   |   |   |   |   |   |   |   |~
       2 | * | 2 | 0 | 2 | 2 | 2 | 3 | 2 | 2 | 2 | 2 | 2 | 0 |~
         |~O / |   |   |   |   |   |   |   |   |   |   |   |   ~O|~
         |   |   |   |   |   |   |   |   |   |   |   |   |   |~
       3 | + | 2 | 0 | 0 | 2 | 2 | 3 | 2 | 2 | 2 | 2 | 2 | 0 |~
         |~O - |   |   |   |   |   |   |   |   |   |   |   |   ~O|~
         | R |   |   |   |   |   |   |   |   |   |   |   |   |~
       4 | E | 0 | 0 | 0 | 0 | 3 | 3 | 2 | 2 | 2 | 2 | 2 | 0 |~
         |~O L |   |   |   |   |   |   |   |   |   |   |   |   ~O|~
         | N |   |   |   |   |   |   |   |   |   |   |   |   |~
       5 |HE | 0 | 0 | 0 | 0 | 0 | 3 | 2 | 2 | 2 | 2 | 2 | 0 |~
         |~OPQ |   |   |   |   |   |   |   |   |   |   |   |   ~O|~
         | A |   |   |   |   |   |   |   |   |   |   |   |   |~
       6 | N | 0 | 0 | 0 | 0 | 0 | 0 | 2 | 2 | 2 | 2 | 2 | 0 |~
         |~O D |   |   |   |   |   |   |   |   |   |   |   |   ~O|~
         |X  |   |   |   |   |   |   |   |   |   |   |   |   |~
       7 |OO | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 2 | 2 | 2 | 2 | 0 |~
         |~ORR |   |   |   |   |   |   |   |   |   |   |   |   ~O|~
         |   |   |   |   |   |   |   |   |   |   |   |   |   |~
       8 | [ | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 |~
         |~O   |   |   |   |   |   |   |   |   |   |   |   |   ~O|~
         | I |   |   |   |   |   |   |   |   |   |   |   |   |~
       9 | M | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 2 | 2 | 2 | 0 |~
         |~O P |   |   |   |   |   |   |   |   |   |   |   |   ~O|~
         | E |   |   |   |   |   |   |   |   |   |   |   |   |~
      10 | Q | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 2 | 0 | 2 | 0 |~
         |~O V |   |   |   |   |   |   |   |   |   |   |   |   ~O|~
         |   |   |   |   |   |   |   |   |   |   |   |   |   |~
      11 |U  | 3 | 4 | 4 | 4 | 4 | 3 | 4 | 4 | 4 | 4 | 4 | 3 |~
         |~ON+ |   |   |   |   |   |   |   |   |   |   |   |   ~O|~
~
UN+    : Plus for processing unary plus.~
UN-    : Minus for processing unary minus.~
HP NEQ : High precedence non-equivalence for processing unary .NOT..~
[      : Special initial operator at beginning of expression.~
REL    : All relational operators.~
?      : All other delimiters.~
~0
~BThe current operator selects the column, and the previous operator on
WS selects the row.  The intersection of these determines the action.
~T# 13
~
~
   0 - STACK OPERATOR~
~IAdd an operator entry to WS for the current operator~
~
   1 - END OF EXPRESSION~
~
~IThe above four codes mean that the previous operator on
the WS stack is the initial operator, and the current operator
is, unless there is a fault, the terminating operator for the
expression.  The terminator is checked for validity against the
permitted terminators for the expression.~
~
   2 - REMOVE~
~IThis pops the operand, operator, operand triplet from the WS
stack and creates a non-terminal expression node on the AS stack,
a pointer to this node is pushed onto the WS stack.~
~
   3 - ILLEGAL USE OF SYMBOL~
~
   4 - REMOVE UNARY PLUS~
~IThis removes the redundant operator and operand entry from the WS
stack which was generated by a previous unary plus.  The penultimate
operand (which is a zero) is replaced by the operand from the top of
the WS stack, then the operand entry is removed from the top of the WS
stack.~
~BThe operator precedence table was constructed from an ordered list
of precedences for the operators, and a table showing which combination
of operators is illegal.~
~T# 16
~
**#:: 0~
*,/#:: 1~
+,-#:: 2~
Unary +,-#:: 3~
~
REL#:: 4~
HP NEQV#:: 5~
~
AND#:: 6~
OR,XOR#:: 7~
IMP~
EQV~
~
Operators in descending order of precedence.~
~
~
~Q 28
~T# 8
~MCURRENT OPERATOR
~3
#   ~O                                               ~O~
#  |       |       |       |       |       |       |~
#  |       |  UN+  |  **   |       |  HP   |AND,OR |~
#  |       |  UN-  |  *,/  |  REL  | NEQV  | EQV,  |~
#  |~O       |       |  +,-  |       |       |IMP,XOR~O|~
#P |       |       |       |       |       |       |~
#R |  UN+  |   I   |       |       |   I   |       |~
#E |  UN-  |       |       |       |       |       |~
#V |~O       |       |       |       |       |       ~O|~
#I |       |       |       |       |       |       |~
#O |  *X   |       |       |       |       |       |~
#U |  *,/  |       |       |       |   I   |       |~
#S |~O  +,-  |       |       |       |       |       ~O|~
#  |       |       |       |       |       |       |~
#O |  REL  |       |       |   I   |   I   |       |~
#P |       |       |       |       |       |       |~
#E |~O       |       |       |       |       |       ~O|~
#R |       |       |       |       |       |       |~
#A |  HP   |       |       |       |   I   |       |~
#T | NEQV  |       |       |       |       |       |~
#O |~O       |       |       |       |       |       ~O|~
#R |       |       |       |       |       |       |~
#  |AND,OR |       |       |       |       |       |~
#  |EQV,IMP|       |       |       |       |       |~
#  |~O  XOR  |       |       |       |       |       ~O|~
~
~MI - Illegal combination of operators.
~0
~S~O3.2 Data Structures
~
   AS~IAnalysis record stack.  Note that other sections modify or
extend the analysis record.~
~S~M~OBasic Supplied function data structures
~BFor any one Basic supplied function name there may be more than
course of action, selection of a specific action depends on the
type and number of arguments present in the function reference.
The SUPPLIED.FN procedure returns a FN.ID for a basic supplied
function.  The specification and code generation detail of basic
supplied functions are held in the following data structures.~
~3
~T# 16
~Q 31
~
#      ~O           ~O           ~O           ~O~
#  |  |           |         |           |~
#  |  |           |         |           |~
#  v  |  BFN.SEL  |         | BFN.ARG.I |~
#FN.ID|~O           ~O|         |~O           ~O|~
#     |~O           ~O|-------->|~O           ~O|----~
#     |~O           ~O|------   |~O           ~O|    |~
#     |           |      |  |~O           ~O|    |~
#     |           |       ->|           |    |~
#     |           |         |           |    |~
#     |~O           ~O|         ~O|           ~O|    |~
#                                            |~
#                                            |~
#      ~O           ~O           ~O  BFN.ARG  ~O     |~
#  |  |           |         |           |    |~
#  |  |           |         |           |    |~
#  v  |           |         |           |    |~
#FN.ID|   BFN.K   |         |           |<---~
#     |           |         |           |~
#     |           |         |           |~
#     |~O           ~O|         |~O           ~O|~
~
~
#      ~O           ~O           ~O           ~O~
#     |           |         |           |~
#     |           |         |           |~
#     |           |         |           |~
#     | BFN.CODE  |<--------| BFN.CODE.I|~
#     |           |         |           |~
#     |           |         |           |~
#     |~O           ~O|         |~O           ~O|~
~
Selection of the set of variants of a particular basic supplied
function is obtained by indexing BFN.SEL with its FN.ID.  This gives
a sublist within BFN.ARG.I which contains indices into BFN.ARG,
this latter table holds the specification of the allowable variants.
The index into BFN.ARG.I of the selected variant when used an index
into BFN.CODE.I selects the code generation action from BFN.CODE.
~BFinally BFN.K when indexed by FN.ID yields kind information
concerning the Basic supplied function.  This is encoded as follows:~
~3
~
   Bits 0 - 3   4 - Array value function~
                5 - Array function~
                9 - Numeric or string function.~
~
   Bit  7       1 - Inspect first two parameters in~
                    selection of specific version of function.~
~Y
~V9 -1
~P
~D15
~HFLOWCHARTS
~
~
~H                BSC071
~V9 -1
~F
//16 21.JUL.83
@TITLE BSC07(1,11)
@COL 1S-2R-3R-8R-4R-7R-5R-6F
@FLOW 1-2-3-8-4-7-5-6
@BOX 1.0
EXPRESSION PROCESSING
@BOX 2.0
TYPE DECLARATIONS
@BOX 3.0
DATAVECS FOR BASIC SUPPLIED FUNCTIONS
VARIABLE DECLARATIONS [BSC07/2]
@BOX 4.0
INTERFACE PROCEDURES
EXPR [BSC07.1]
IN.EXPR [BSC07.2]
CODE.EXPR [BSC07.3]
EVAL.EXPR [07.4]
SAVE.NODE.SUBS [07.5]
CODE.NODE [07.6]
PL.CD.SEQ [07.7]
PL.STK.LB [07.8]
PL.COND.JUMP [07.9]
CODE.LET [07.10]
CODE.MAT [07.11]
OUT.AS [07.12]
CODE.SUBS [BSC07.13]
GET.TEMP [BSC07.14]
INIT.STAT.7[BSC07.15]
DECL.ARITH.CONST[BSC07.16]
CODE.STR.EXPR[BSC07.17]
DECL.STR.CONST[BSC07.18]
@BOX 5.0
INITIALISATION PROC
@BOX 6.0
END
@BOX 7.0
INTERNAL PROCEDURES
REC.EXPR [07.20]
REDUCE.EXPR [07.21]
PLANT.NUM.FN [07.22]
PLANT.STR.FN [07.23]
CHECK.CONST [07.24]
LOAD.A.FROM.T [07.25]
SET.A.TYPE [07.26]
PL.PROC.CALL [BSC07.27]
PL.EXPR.CODE [BSC07.28]
CNT.STR.OPNDS[BSC07.29]
CODE.STR.OPNDS[BSC07.30]
PL.BFN.CALL[BSC07.31]
@BOX 8.0
DATAVECS OF RUNTIME
SUPPORT PROCEDURES [BSC07/3]
@BOX 1.1
#BSC07/1
MODULE (EXPR, IN.EXPR, CODE.EXPR, PL.CD.SEQ, PL.STK.LB, PL.COND.JUMP,
CODE.STR.EXPR, CODE.NODE, AS, WP, AP,
PL.STR.COMP, DECL.ARITH.CONST, BIO.CLOSE.ALL.FN, BIO.END.RUN.FN,
BIO.READ.FN, BIO.END.READ.FN, BIO.MARGIN.FN, BIO.ZONE.FN, BIO.OPEN.FN,
G.LIT.16.0,G.LIT.16.1, G.LIT.32.0,CD.MN.0, LAB.MN, GET.TEMP, INIT.STAT.7, SET.A.
TYPE,
EVAL.EXPR,SAVE.NODE.SUBS, CODE.LET, CODE.MAT, OUT.AS, CODE.SUBS, INIT.S7, A.AP);
@BOX 2.1
TYPE TEMP.E IS  $LO16 TYP, DIM, TLN;
@BOX 3.1
*GLOBAL 6;
DATAVEC TL.OPS($LO8)
%7F 15 15 15 15 15 15 9
%7F %7F 11 %7F %7F 12 %7F %7F
%7F 8 2 0
END
#BSC07/2
$LI BIO.FN.Z=128;
$LI /ADDR[$LO8] NIL =;
$LI TEMP.Z = 256;
*GLOBAL 5;
$LO32[BIO.FN.Z] BIO.FN;
$LO8[BIO.FN.Z] BIO.FN.RES;
TEMP.E[TEMP.Z] TEMP.T;
$LO16 G.LIT.16.0,G.LIT.16.1;
$LO32 G.LIT.32.0;
$IN EXPR.AP.0, EXPR.AP.1, EXPR.AP.2;
$LO16 CD.MN.0,CD.MN.1;
$IN CUR.A.TYPE, A.AP, B.AP, T.AP, LAST.T, AP, WP, TFN, LAB.MN;
$IN STR.COMP.MN;
$IN16 [AS.Z] AS;
$IN16 [WS.Z] WS;
$IN END.AP;
@BOX 4.1
PSPEC GET.TEMP ($IN,$IN)/$LO16;
P.SPEC EXPR ($IN,$IN)/$IN;
P.SPEC IN.EXPR ($IN)/$IN;
P.SPEC CODE.EXPR ($IN,$IN)/$IN;
P.SPEC CODE.NODE($IN,$IN);
P.SPEC EVAL.EXPR ($IN, ADDR CLIST.E, $IN) / $IN;
P.SPEC SAVE.NODE.SUBS ($IN);
P.SPEC PL.CD.SEQ(ADDR[$LO16]);
P.SPEC PL.STK.LB($IN);
P.SPEC PL.COND.JUMP($IN,$IN);
LSPEC OUT.AS();
PSPEC SET.A.TYPE($IN);
PSPEC CODE.LET(ADDR[$IN],$IN,$IN);
PSPEC CODE.MAT($IN,$IN);
PSPEC CHECK.CONST($IN,$IN,$IN)/$IN;
PSPEC LOAD.A.FROM.T();
PSPEC PLANT.NUM.FN($IN,$IN);
PSPEC PLANT.STR($IN,$IN,$IN,$IN);
PSPEC CODE.SUBS($IN,$IN);
PSPEC PL.PROC.CALL($IN);
PSPEC REC.EXPR($IN)/$IN;
PSPEC REDUCE.EXPR($IN,$IN);
PSPEC PL.EXPR.CODE($IN,$IN)/$IN;
PSPEC INIT.STAT.7();
PSPEC DECL.ARITH.CONST(ADDR CLIST.E, $IN);
PSPEC DECL.STR.CONST(ADDR[$LO8],$IN)/$IN;
PSPEC CODE.STR.EXPR($IN,$IN);
PSPEC CNT.STR.OPNDS($IN)/$IN;
PSPEC CODE.STR.OPNDS($IN, $IN, $IN)/$IN;
PSPEC PL.BFN.CALL($IN);
PSPEC PL.STR.COMP($IN, ADDR[$LO8], $IN);
#BSC07.1
#BSC07.2
#BSC07.3
#BSC07.4
#BSC07.5
#BSC07.6
#BSC07.7
#BSC07.8
#BSC07.9
#BSC07.10
#BSC07.11
#BSC07.12
#BSC07.13
#BSC07.14
#BSC07.15
#BSC07.16
#BSC07.17
#BSC07.18
#BSC07.19
@BOX 7.1
#BSC07.20
#BSC07.21
#BSC07.22
#BSC07.23
#BSC07.24
#BSC07.25
#BSC07.26
#BSC07.27
#BSC07.28
#BSC07.29
#BSC07.30
#BSC07.31
@BOX 5.1
PSPEC INIT.S7();
PROC INIT.S7;
$IN I;
FOR I < BIO.FN.Z DO
    0 => BIO.FN[I];
OD
END;
@BOX 6.1
*END
@BOX 8.1
*GLOBAL 6;
#BSC07/3
*GLOBAL 0;
@END
///17 22.JUL.83
@TITLE BSC07/1(1,11)
@COL 1S-7R-2R-3R-4R-5R-6F
@FLOW 1-7-2-3-4-5-6
@BOX 1.0
IMPORTS
@BOX 2.0
TYPES
@BOX 3.0
VARIABLES
@BOX 4.0
VECTORS
@BOX 5.0
PROCEDURES
@BOX 6.0
END
@BOX 1.1
::BEGIN
@BOX 2.1
TYPE CLIST.E IS $IN32 INT.C
             OR $RE64 REAL.C;
TYPE ITYPE IS $LO8 TAG,ST $LO16 IND;
TYPE NLIST.ENT IS $LO16 BASIC.N, HASH, MUTLN, DETAIL, DETAIL1
        $LO8 K, T;
@BOX 7.1
IMPORT LITERAL ZERO,STR.N,DEF.STR.Z, MFN.I16;
IMPORT LITERAL KFN, KVAR, KMAT, KVEC, AS.Z, WS.Z, NLIST.Z, CLIST.Z;
IMPORT LITERAL ARRAYS.Z,STR.LIST.Z,PARAMS.Z,BADDR,B.NIL.N, MAT.STR.N;
IMPORT LITERAL KUNDEF, KSUB, BSTR;
IMPORT LITERAL T.OP.KEY, T.OP.NON.KEY, TSTRING, TCONST;
IMPORT LITERAL $LO16 PI,PIBY2,RADIANS,DEGREES,ONE;
IMPORT LITERAL $LO8 BADDRTY;
@BOX 3.1
ITYPE LB,PLUS,MINUS,D.NOT,RB,HASH.D,COMMA,COLON;
$IN DATA.MN, B.INT, B.RE, OPEN.ID.MN, GO.SUB.LABS, GO.SUB.PTR, LAST.MN;
$IN EXLINE.MN, EXTYPE.MN, DEF.BASE;
$IM $LI LBUFFZ;
ITYPE [LBUFF.Z] LBUFF;
$IN[ARRAYS.Z] ARRAYS;
$LO8[PARAMSZ] PARAMS;
$IN IPTR;
$LO8[32] TL.TYP;
$IN LAST.C, C.EXIT.LAB, OPTIONS, CUR.PROC;
@BOX 4.1
NLIST.ENT [NLIST.Z] NLIST;
CLIST.E[CLIST.Z] CLIST;
$LO8[STR.LIST.Z] STR.LIST;
@BOX 5.1
PSPEC DECL.TL.PSPEC($IN,ADDR[$LO8]);
PSPEC MONITOR.P ($IN, $IN);
PSPEC MONITOR ($IN);
PSPEC MONITOR.S($IN,ADDR[$LO8]);
PSPEC GET.N(ITYPE)/$IN;
PSPEC SUPPLIED.FN($IN)/$IN;
PSPEC IMPL.S.VAR($IN);
LSPEC FIND.N (ADDR [$LO8],$IN)/$LO32;
@BOX 6.1
::END
@END
///12
@TITLE BSC07/2(1,11)
@COL 1S-2R
@BOX 1.0
DATA STRUCTURES FOR PROCESSING
BASIC SUPPLIED FUNCTIONS
@BOX 2.0
SPECIFICATION TABLE - BFN.ARG[BSC07/2.1]
SPECIFICATION INDEX TABLE - BFN.ARG.I[BSC07/2.2]
LITERALS FOR SUBLIST LENGTHS[BSC07/2.3]
IN BFN.ARG.I
SPECIFICATION SELECTION TABLE - BFN.SEL[BSC07/2.4]
BASIC SUPPLIED FUNCTION - BFN.K[BSC07/2.5]
KIND TABLE
CODE TABLES FOR FUNCTIONS - BFN.CODE[BSC07/2.6]
CODE SEQUENCE LENGTH LITERALS [BSC07/2.7]
CODE INDEX TABLE - BFN.CODE.I[BSC07/2.8]
@BOX 1.1
::BSC07/2
@BOX 2.1
#BSC07/2.1
#BSC07/2.2
#BSC07/2.3
#BSC07/2.4
#BSC07/2.5
#BSC07/2.6
#BSC07/2.7
#BSC07/2.8
@END
//15
@TITLE BSC07/2.1(1,11)
@COL 1S-2R-3R
@BOX 1.0
BASIC FUNCTION SPECIFICATION
@BOX 2.0
SPECIFICATION TABLE
@BOX 3.0
LITERALS FOR LENGTHS OF SPECS IN TABLE
@BOX 1.1
::BSC07/2.1
@BOX 2.1
::%01  means  1-D array of any type
::%02  means  2-d array of any type
::Bit 2 = 1 means simple variables only
DATAVEC BFN.ARG($LO8)
%10  1  %10            ::0 (RE32)RE32
%18  1  %18            ::1 (RE64)RE64
%48  1  %48            ::2 (IN16)IN16
%50  1  %50            ::3 (IN32)IN32
%10  2  %10  %10       ::4 (RE32,RE32)RE32
%18  2  %18  %18       ::5 (RE64,RE64)RE64
%10  0                 ::6 ()RE32
%10  2  %10  %18       ::7 (RE32,I16)RE32
%18  2  %18  %48       ::8 (RE64,I16)RE32
%C0  1  %48            ::9 (IN16)STR
%C0  0                 ::10 ()STR
%48  1  %C0            ::11 (STR)IN16
%C0  1  %C0            ::12 (STR)STR
%10  2  %C0  %C0       ::13 (STR,STR)RE32
%10  3  %C0  %C0  %48  ::14 (STR,STR,IN16)RE32
%10  1  %C0            ::15 (STR)RE32
%48  1  %C1            ::16 (STRARRAY())IN16
%48  1  %C2            ::17 (STRARRAY(,))IN16
%C0  1  %10            ::18 (RE32)STR
%C0  1  %18            ::19 (RE64)STR
BADDR.TY  1  %01            ::20 (ARRAY())ADDR
BADDR.TY  2  %01  %48        ::21 (ARRAY(),IN16)ADDR
%10  1  %12            ::22 (RE32ARRAY(,))RE32
%18  1  %1A            ::23 (RE64ARRAY(,))RE64
%10  2  %11  %11       ::24 (RE32ARRAY,RE32ARRAY)RE32
%18  2  %19  %19       ::25 (RE64ARRAY,RE64ARRAY)RE64
%11  1  BADDR.TY            ::26 (ADDR)RE32ARRAY()
%12  2  BADDR.TY  BADDR.TY       ::27 (ADDR,ADDR)RE32ARRAY(,)
%19  1  BADDR.TY            ::28 (ADDR)RE64ARRAY()
%1A  2  BADDR.TY  BADDR.TY       ::29 (ADDR,ADDR)RE64ARRAY(,)
%C1  0                 ::30 ()STR.ARRAY()
%12  1  %12            ::31 (RE32ARRAY(,))RE32ARRAY(,)
%1A  1  %1A            ::32 (RE64ARRAY(,))RE64ARRAY(,)
%C2  0                 ::33 ()STR.ARRAY(,)
%C1  1  %50            ::34 (IN32)STR.ARRAY()
%C2  2  %50  %50       ::35 (IN32,IN32)STRARRAY(,)
%48 2 %48 %48          ::36 (IN16,IN16)IN16
%50 2 %50 %50          ::37 (IN32,IN32)IN32
%11  0                 ::38 ()RE32ARRAY()
%12  0                 ::39 ()RE32ARRAY(,)
%19  0                 ::40 ()RE64ARRAY()
%1A  0                 ::41 ()RE64ARRAY(,)
BADDRTY 1 %02                ::42 (ARRAY(,))ADDR
BADDRTY 2 %02 %48             ::43 (ARRAY(,), IN16)ADDR
BADDRTY  1  %C4             ::44 (SIMPLE.STR.VAR)IN16
END
@BOX 3.1

LITERAL/$LO8  E0=0,E1=E0+3,E2=E1+3,E3=E2+3,
              E4=E3+3,E5=E4+4,E6=E5+4,E7=E6+2,
              E8=E7+4,E9=E8+4,E10=E9+3,E11=E10+2,
              E12=E11+3,E13=E12+3,E14=E13+4,E15=E14+5,
              E16=E15+3,E17=E16+3,E18=E17+3,E19=E18+3,
              E20=E19+3,E21=E20+3,E22=E21+4,E23=E22+3,
              E24=E23+3,E25=E24+4,E26=E25+4,E27=E26+3,
              E28=E27+4,E29=E28+3,E30=E29+4,E31=E30+2,
              E32=E31+3,E33=E32+3,E34=E33+2,E35=E34+3,
              E36=E35+4,E37=E36+4,E38=E37+4,E39=E38+2,
              E40=E39+2,E41=E40+2,E42=E41+2,E43=E42+3,
              E44=E43+4, E45=E44+3;
@END
//15
@TITLE BSC07/2.2
@COL 1S
@BOX 1.0
SPECIFICATION INDEX TABLE - BFN.ARG.I
@BOX 1.1
DATAVEC BFN.ARG.I ($LO8)
E2  E3  E0  E1        ::ABS
E0  E1                ::ATN
E0  E1                ::ACOS
E0  E1                ::ASIN
E4  E5                ::ANGLE
E0  E1                ::COS
E0  E1                ::COT
E0  E1                ::CSC
E38 E39 E40 E41 E26 E27 E28 E29 ::CON
E0  E1                ::CEIL
E0  E1                ::COSH
E9                    ::CHR$
E0  E1                ::DEG
E6  E22 E23           ::DET
E24 E25               ::DOT
E6                    ::DATE
E10                   ::DATE$
E0  E1                ::EPS
E0  E1                ::EXP
E6      ::EXLINE
E6       ::EXTYPE
E0  E1                ::FP
E0  E1                ::IP
E6                    ::INF
E0  E1                ::INT
E38 E39 E40 E41 E26 E27 E28 E29 ::IDN
E31 E32               ::INV
E15                   ::LEN
E0  E1                ::LOG
E0  E1                ::LOG2
E0  E1                ::LOG10
E20 E21 E43           ::LBOUND
E12                   ::LCASE$
E12                   ::LTRIM
E36  E37  E4  E5        ::MAX
E36  E37  E4  E5        ::MIN
E36  E37  E4  E5        ::MOD
E44 E16 E17           ::MAXLEN
E30 E33 E34 E35       ::NULL
E11                   ::ORD
E6                    ::PI
E13 E14               ::POS
E0  E1                ::RAD
E36 E37 E4  E5        ::REM
E0                    ::RND
E7  E8                ::ROUND
E12                   ::RTRIM$
E0  E1                ::SEC
E2  E3  E0  E1        ::SGN
E0  E1                ::SIN
E0  E1                ::SQR
E0  E1                ::SINH
E20 E21 E42 E43       ::SIZE
E18 E19               ::STR
E0  E1                ::TAN
E31 E32               ::TRN
E0  E1                ::TANH
E6                    ::TIME
E10                   ::TIME$
E7  E8                ::TRUNCATE
E20 E21 E43           ::UBOUND
E12                   ::UCASE$
E15                   ::VAL
E38 E39 E40 E41 E26 E27 E28 E29 ::ZERO
END
@END
///15
@TITLE BSC07/2.3
@COL 1S
@BOX 1.0
LITERALS FOR SUBLIST LENGTHS
WITHIN BFN.ARG.I
@BOX 1.1
LITERAL/$LO8 ABS.A=0, ATN.A=ABS.A+4, ACOS.A=ATN.A+2,
ASIN.A=ACOS.A+2, ANGLE.A=ASIN.A+2,
COS.A=ANGLE.A+2, COT.A=COS.A+2, CSC.A=COTA+2,
CON.A=CSC.A+2, CEIL.A=CON.A+8, COSH.A=CEIL.A+2,
CHRS.A=COSH.A+2,
DEG.A=CHRS.A+1, DET.A=DEG.A+2, DOT.A=DET.A+3,
DATE.A=DOT.A+2, DATES.A=DATE.A+1,
EPS.A=DATES.A+1, EXP.A=EPS.A+2,
EXLINE.A = EXP.A + 2, EXTYPE.A = EXLINE.A +1,
FP.A=EXTYPE.A+1,
IP.A=FP.A+2, INF.A=IP.A+2, INT.A=INF.A+1,
IDN.A=INT.A+2, INV.A=IDN.A+8,
LEN.A=INV.A+2, LOG.A=LEN.A+1, LOG.2.A=LOG.A+2,
LOG10.A=LOG2.A+2, LBOUND.A=LOG10.A+2, LCASES.A=LBOUND.A+3,
LTRIM.A=LCASES.A+1,
MAX.A=LTRIM.A+1, MIN.A=MAX.A+4, MOD.A=MIN.A+4,
MAX.LEN.A=MOD.A+4,
NULL.A=MAXLEN.A+3,
ORD.A=NULL.A+4,
PI.A=ORD.A+1, POS.A=PI.A+1,
RAD.A=POS.A+2, REM.A=RAD.A+2, RND.A=REM.A+4,
ROUND.A=RND.A+1, RTRIMS.A=ROUND.A+2,
SEC.A=RTRIMS.A+1, SGN.A=SEC.A+2, SIN.A=SGN.A+4,
SQR.A=SIN.A+2, SINH.A=SQR.A+2, SIZE.A=SINH.A+2,
STR.A=SIZE.A+4,
TAN.A=STR.A+2, TRN.A=TAN.A+2, TANH.A=TRN.A+2,
TIME.A=TANH.A+2, TIMES.A=TIME.A+1, TRUNCATE.A=TIMES.A+1,
UBOUND.A=TRUNCATE.A+2, UCASES.A=UBOUND.A+3,
VAL.A=UCASES.A+1,
ZERO.A=VAL.A+1,
END.A=ZERO.A+8;
@END
///5
@TITLE BSC07/2.4(1,11)
@COL 1S
@BOX 1.0
SPECIFICATION SELECTION TABLE
@BOX 1.1
DATAVEC BFN.SEL($LO8)
ABS.A ATN.A ACOS.A ASIN.A ANGLE.A
COS.A COT.A CSC.A CON.A CEIL.A COSH.A CHRS.A
DEG.A DET.A DOT.A DATE.A DATES.A
EPS.A EXP.A EXLINE.A EXTYPE.A
FP.A
IP.A INF.A INT.A IDN.A INV.A
LEN.A LOG.A LOG2.A LOG10.A LBOUND.A LCASES.A LTRIM.A
MAX.A MIN.A MOD.A MAXLEN.A
NULL.A
ORD.A
PI.A POS.A
RAD.A REM.A RND.A ROUND.A RTRIMS.A
SEC.A SGN.A SIN.A SQR.A SINH.A SIZE.A STR.A
TAN.A TRN.A TANH.A TIME.A TIMES.A TRUNCATE.A
UBOUND.A UCASES.A
VAL.A
ZERO.A
END.A
END
@END
///7
@TITLE BSC07/2.5(1,11)
@COL 1S
@BOX 1.0
BASIC SUPPLIED FUNCTION KIND TABLE - BFN.K
@BOX 1.1
:: Bits 0 - 3 encoded as 4 array value, 5 array function,
::          7 numeric and string functions
:: Bit  7 = 1 means inspect first two parameters in
::            selection of specific function
DATAVEC BFN.K($LO8);
9[5]           ::ABS ATN ACOS ASIN ANGLE
9[3]  4  9[3]  ::COS COT CSC CON CEIL COSH CHR$
9[5]           ::DEG DET DOT DATE DATE$
9[4]           ::EPS EXP EXLINE EXTYPE
9              ::FP
9[3]  4  5     ::IP INF INT IDN INV
9[7]           ::LEN LOG LOG2 LOG10 LBOUND LCASE$ LTRIM$
%89[3] 9       ::MAX MIN MOD MAXLEN
4              ::NULL
9              ::ORD
9[2]           ::P1 POS
9 %89 9[3]     ::RAD REM RND ROUND RTRIM$
9[7]           ::SEC SGN SIN SQR SINH SIZE STR$
9  5  9[4]     ::TAN TRN TANH TIME TIME$ TRUNCATE
9[2]           ::UBOUND UCASE$
9              ::VAL
4              ::ZERO
END
@END
//17 10-AUG-83
@TITLE BSC07/2.6(1,11)
@COL 1S-2R
@FLOW 1-2
@BOX 1.0
CODE TABLES FOR BASIC SUPPLIED FUNCTIONS
@BOX 2.0
CODE SEQUENCE TABLE - BFN.CODE
INDEXED BY BASIC FUNCTION CODE INDEX
@BOX 3.0
@BOX 1.1
::BSC07/2.6
@BOX 2.1
DATAVEC BFN.CODE($LO16)
%C009  %3600         ::ABS0
%C00A  %3000         ::ABS1
%C002  %3000         ::ABS2
%C003  %3000         ::ABS3
%C002  %3016  %4000         ::ATN0
%C002  %3016  %4000         ::ATN1
%C002  %3015  %4000         ::ACOS0
%C003  %3015  %4000         ::ACOS1
%C002  %3014  %4000         ::ASIN0
%C003  %3014  %4000         ::ASIN1
%102E  %C802  %C902  %A000  %4000  ::ANGLE0
%102F  %C803  %C903  %A000  %4000  ::ANGLE1
%2000  %C002  %300F         ::COS0
%2000  %C003  %300F         ::COS1
%C002  %2000  %2A    PIBY2  %3013  ::COT0
%C003  %2000  %2A    PIBY2  %3013  ::COT1
%2000  %C002  %300E  %2D  ONE      ::CSC0
%2000  %C003  %300E  %2D  ONE      ::CSC1
1       ::CON0,1,2,3,4,5,6,7
%1030  %C802  %A000         ::CEIL0
%1031  %C803  %A000         ::CEIL1
%2000  %C002  %301A         ::COSH0
%2000  %C003  %301A         ::COSH1
%5002 %46 %80  %22 %8009 %61 %8015 %02 %8008 %64 %0 %20 %1004 %C008 %61 %8015
%02 %8009 %64 %0 %20 %1004 %46 %83 %21 %8015
       ::CHRS0
%C002  %2B    DEGREES       ::DEG0
%C003  %2B    DEGREES       ::DEG1
%1072 %A000 %46 %1C       ::DET0
%106F %B001 %A000 %46 %0C       ::DET1
%1070 %B001 %A000 %46 %1C       ::DET2
%1073 %B001 %B011 %A000 %46 %0C       ::DOT0
%1074 %B001 %B011 %A000 %46 %1C       ::DOT1
%1032  %A000          ::DATE0
%5009 %1059 %46 %83 %21 %8015 %6000 %A000 %46 %83 %21 %8015
       ::DATES0
%1033  %C802  %A000         ::EPS0
%1034  %C803  %A000         ::EPS1
%C002  %3011         ::EXP0
%C003  %3011         ::EXP1
%46 %0C %22 %8013   ::EXLINE
%46 %0C %22 %8014    ::EXTYPE
%1036  %C802  %A000         ::FP0
%1037  %C803  %A000         ::FP1
%1038  %C802  %A000         ::IP0
%1039  %C803  %A000         ::IP1
%1035  %A000         ::INF0
%103A  %C802  %A000         ::INT0
%103B  %C803  %A000         ::INT1
%2       ::IDN0,1,2,3,4,5,6,7
%1       ::INV0 INV1
%7001 %46 %80 %2 %8008 %64 %0 %22 %1004 %45 %44 %45 %0C  ::LEN0
%C002  %3010         ::LOG0
%C003  %3010         ::LOG1
%103C  %C802  %A000         ::LOG20
%103D  %C803  %A000         ::LOG21
%C002  %3012         ::LOG100
%C003  %3012         ::LOG101
%1075 %B000 %46 %44 %22 ONE %6000 %A000  ::LBOUND0
%1075 %B000 %C909 %A000  ::LBOUND1
%1075 %B000 %C909 %A000  ::LBOUND2
%5000 %9000 %105B %46 %83 %21 %8015 %6000 %A000 %46 %83 %21 %8015        ::LCASE
S0
%5000 %9000 %105D %46 %83 %21 %8015 %6000 %A000 %46 %83 %21 %8015     ::LTRIM0
%C009  %3C07  %C109  %3609  ::MAX0
%C00A  %3807  %C10A  %3009  ::MAX1
%C002  %3807  %C102  %3009  ::MAX2
%C003  %3807  %C103  %3009  ::MAX3
%C009  %3C0A  %C109  %360C  ::MIN0
%C00A  %380A  %C10A  %300C  ::MIN1
%C002  %380A  %C102  %300C  ::MIN2
%C003  %380A  %C103  %300C  ::MIN3
%C009  %3C01  %C109  %3602  ::MOD0
%C00A  %3801  %C10A  %3002  ::MOD1
%C002  %3801  %C102  %3002  ::MOD2
%C003  %3801  %C103  %3002  ::MOD3
%46 %83 %F000 %45 %404C %29 ONE       ::MAXLEN0
%46 %44 %D000       ::MAXLEN1
%46 %44 %D000       ::MAXLEN2
       ::NULL0
       ::NULL1
       ::NULL2
%7000 %105F %6000 %A000 %45 %0C      ::ORD0
%46    %0C    %22    PI     ::PI0
%1060 %7000 %6000 %E000 %6000 %46 %44 %22 %8009 %6000 %A000
%45 %0C       ::POS0
%1060 %7000 %6000 %E000 %6000 %C209 %6000 %A000
%45 %0C    ::POS1
%C002 %2B    RADIANS       ::RAD0
%C003 %2B    RADIANS       ::RAD1
%103E  %C809  %C909  %A000  ::REM0
%103F  %C80A  %C90A  %A000  ::REM1
%1040  %C802  %C902  %A000  ::REM2
%1041  %C803  %C903  %A000  ::REM3
%1042  %A000         ::RND0
%1043  %C802  %C909  %A000  ::ROUND0
%1044  %C803  %C909  %A000  ::ROUND1
%5000 %9000 %105E %46 %83 %21 %8015 %6000 %A000 %46 %83 %21 %8015  ::RTRIMS0
%2000  %C002  %300F  %2D    ONE    ::SEC0
%2000  %C003  %300F  %2D    ONE    ::SEC1
%1045  %C809  %A000         ::SGN0
%1046  %C80A  %A000         ::SGN1
%C002 %301C  ::SGN2
%C003 %301C  ::SGN3
%2000  %C002  %300E         ::SIN0
%2000  %C003  %300E         ::SIN1
%2000  %C002  %300D         ::SQR0
%2000  %C003  %300D         ::SQR1
%2000  %C002  %3019         ::SINH0
%2000  %C003  %3019         ::SINH1
%1078 %B000 %A000         ::SIZE0
%1077 %B000 %C909 %A000    ::SIZE1
%1078 %B000 %A000          ::SIZE2
%1097 %B000 %C909 %A000    ::SIZE3
%1061 %C002 %6000 %5000 %46 %83 %21 %8015 %6000 %A000 %46 %83 %21 %8015   ::STR0
%1062 %C003 %6000 %5000 %46 %83 %21 %8015 %6000 %A000 %46 %83 %21 %8015  ::STR1
%2000  %C002  %3013         ::TAN0
%2000  %C003  %3013         ::TAN1
%0       ::TRN0 TRN1
%C002  %301B         ::TANH0
%C003  %301B         ::TANH1
%1047  %A000          ::TIME0
%5009 %105A %46 %83 %21 %8015 %6000 %A000 %46 %83 %21 %8015 ::TIMES0
%1048  %C802  %C909  %A000  ::TRUNCATE0
%1049  %C803  %C909  %A000  ::TRUNCATE1
%1076 %B000 %46 %44 %22 ONE %6000 %A000    ::UBOUND0
%1076 %B000 %C909 %A000    ::UBOUND1
%1076 %B000 %C909 %A000    ::UBOUND2
%5000 %9000 %105C %46 %83 %21 %8015 %6000 %A000 %46 %83 %21 %8015 ::UCASES0
%1063 %7000 %6000 %A000    ::VAL0
%0       ::ZERO0,1,2,3,4,5,6,7
END;
@END
//17 25.JUL.83
@TITLE BSC07/2.7(1,11)
@COL 1S
@BOX 1.0
LITERALS FOR CODE SEQUENCE LENGTHS
@BOX 1.1
LITERAL/$LO16 ABS0=0,ABS1=ABS0+2, ABS2=ABS1+2, ABS3=ABS2+2,
ATN0=ABS3+2, ATN1=ATN0+3,
ACOS0=ATN1+3, ACOS1=ACOS0+3,
ASIN0=ACOS1+3, ASIN1=ASIN0+3,
ANGLE0=ASIN1+3, ANGLE1=ANGLE0+5,
COS0=ANGLE1+5, COS1=COS0+3,
COT0=COS1+3, COT1=COT0+5,
CSC0=COT1+5, CSC1=CSC0+5,
CON0=CSC1+5, CON1=CON0, CON2=CON1, CON3=CON2, CON4=CON3,CON5=CON4,CON6=CON5,CON7
=CON6,
CEIL0=CON0+1, CEIL1=CEIL0+3,
COSH0=CEIL1+3, COSH1=COSH0+3,
CHRS0=COSH1+3,
DEG0=CHRS0+26, DEG1=DEG0+3,
DET0=DEG1+3, DET1=DET0+4, DET2=DET1+5,
DOT0=DET2+5, DOT1=DOT0+6,
DATE0=DOT1+6,
DATES0=DATE0+2,
EPS0=DATES0+12,EPS1=EPS0+3,
EXP0=EPS1+3, EXP1=EXP0+2,
EXLINE0=EXP1+2, EXTYPE0=EXLINE0+4,
FP0=EXTYPE0+4, FP1=FP0+3,
IP0=FP1+3,IP1=IP0+3,
INF0=IP1+3,
INT0=INF0+2, INT1=INT0+3,
IDN0=INT1+3, IDN1=IDN0, IDN2=IDN1, IDN3=IDN2, IDN4=IDN3,
IDN5=IDN4, IDN6=IDN5, IDN7=IDN6,
INV0=IDN0+1, INV1=INV0,
LEN0=INV0+1,
LOG0=LEN0+13, LOG1=LOG0+2,
LOG20=LOG1+2, LOG21=LOG20+3,
LOG100=LOG21+3, LOG101=LOG100+2,
LBOUND0=LOG101+2, LBOUND1=LBOUND0+8,LBOUND2=LBOUND1+4,
LCASES0=LBOUND2+4,
LTRIM0=LCASES0+13,
MAX0=LTRIM0+13, MAX1=MAX0+4, MAX2=MAX1+4, MAX3=MAX2+4,
MIN0=MAX3+4, MIN1=MIN0+4, MIN2=MIN1+4, MIN3=MIN2+4,
MOD0=MIN3+4, MOD1=MOD0+4, MOD2=MOD1+4, MOD3=MOD2+4,
MAXLEN0=MOD3+4, MAXLEN1=MAXLEN0+7, MAXLEN2=MAXLEN1+3,
NULL0=MAXLEN2+3, NULL1=NULL0, NULL2=NULL1, NULL3=NULL2,
ORD0=NULL3,
PI0=ORD0+6,
POS0=PI0+4, POS1=POS0+13,
RAD0=POS1+10, RAD1=RAD0+3,
REM0=RAD1+3, REM1=REM0+4, REM2=REM1+4, REM3=REM2+4,
RND0=REM3+4,
ROUND0=RND0+2, ROUND1=ROUND0+4,
RTRIMS0=ROUND1+4,
SEC0=RTRIMS0+13, SEC1=SEC0+5,
SGN0=SEC1+5, SGN1=SGN0+3, SGN2=SGN1+3, SGN3=SGN2+2,
SIN0=SGN3+2, SIN1=SIN0+3,
SQR0=SIN1+3, SQR1=SQR0+3,
SINH0=SQR1+3, SINH1=SINH0+3,
SIZE0=SINH1+3, SIZE1=SIZE0+3,SIZE2=SIZE1+4,SIZE3=SIZE2+3,
STR0=SIZE3+4, STR1=STR0+14,
TAN0=STR1+14, TAN1=TAN0+3,
TRN0=TAN1+3, TRN1=TRN0,
TANH0=TRN0+1, TANH1=TANH0+2,
TIME0=TANH1+2,
TIMES0=TIME0+2,
TRUNCATE0=TIMES0+12, TRUNCATE1=TRUNCATE0+4,
UBOUND0=TRUNCATE1+4, UBOUND1=UBOUND0+8, UBOUND2=UBOUND1+4,
UCASES0=UBOUND2+4,
VAL0=UCASES0+13,
ZERO0=VAL0+4, ZERO1=ZERO0, ZERO2=ZERO1, ZERO3=ZERO2, ZERO4=ZERO3,
ZERO5=ZERO4, ZERO6=ZERO5, ZERO7=ZERO6,
LAST.CODE.I=ZERO1+1;
@END
//15
@TITLE BSC07/2.8(1,11)
@COL 1S-2R
@FLOW 1-2
@BOX 1.0
CODE SEQUENCE INDEX TABLE - BFN.CODE.I
@BOX 2.0
BFN.CODE.I
@BOX 1.1
::BSC07/2.7
@BOX 2.1
DATAVEC BFN.CODE.I($LO16)
ABS0 ABS1 ABS2 ABS3
ATN0 ATN1
ACOS0 ACOS1
ASIN0 ASIN1
ANGLE0 ANGLE1
COS0 COS1
COT0 COT1
CSC0 CSC1
CON0 CON1 CON2 CON3 CON4 CON5 CON6 CON7
CEIL0 CEIL1
COSH0 COSH1
CHRS0
DEG0 DEG1
DET0 DET1 DET2
DOT0 DOT1
DATE0
DATES0
EPS0 EPS1
EXP0 EXP1
EXLINE0
EXTYPE0
FP0 FP1
IP0 IP1
INF0
INT0 INT1
IDN0 IDN1 IDN2 IDN3 IDN4 IDN5 IDN6 IDN7
INV0 INV1
LEN0
LOG0 LOG1
LOG20 LOG21
LOG100 LOG101
LBOUND0 LBOUND1 LBOUND2
LCASES0
LTRIM0
MAX0 MAX1 MAX2 MAX3
MIN0 MIN1 MIN2 MIN3
MOD0 MOD1 MOD2 MOD3
MAXLEN0 MAXLEN1 MAXLEN2
NULL0 NULL1 NULL2 NULL3
ORD0
PI0
POS0 POS1
RAD0 RAD1
REM0 REM1 REM2 REM3
RND0
ROUND0 ROUND1
RTRIMS0
SEC0 SEC1
SGN0 SGN1 SGN2 SGN3
SIN0 SIN1
SQR0 SQR1
SINH0 SINH1
SIZE0 SIZE1 SIZE2 SIZE3
STR0 STR1
TAN0 TAN1
TRN0 TRN1
TANH0 TANH1
TIME0
TIMES0
TRUNCATE0 TRUNCATE1
UBOUND0 UBOUND1 UBOUND2
UCASES0
VAL0
ZERO0 ZERO1 ZERO2 ZERO3 ZERO4 ZERO5 ZERO6 ZERO7
LASTCODE.I
END
@END
//17 9-AUG-83
@TITLE BSC07/3(1,11)
@COL 1S-2R
@COL 3R-4R-5R
@BOX 1.0
DATAVECS FOR RUNTIME SUPPORT PROCEDURES
@BOX 2.0
PROCEDURE NAME TABLE
@BOX 3.0
NAME LENGTHS
@BOX 4.0
INDEX TABLE TO PROCEDURES NAMES
@BOX 5.0
PROCEDURE IDENTIFIERS
@BOX 1.1
@BOX 2.1
DATAVEC BIO.NAMES($LO8)
"BIOREAD"
"BIOENDREAD"
"BIOINPUT"
"BIOELAPSED"
"BIOSKIPREST"
"BIOSETREC"
"BIOOUTPUT"
"BIOENCFORMAT"
"BIOPRINTSEP"
"BIOSEP"
"BIOPRINTNL"  ::10
"BIOPRINTTAB"
"BIOENCRUNFORMAT"
"BIOEXCEPTION"
"BIOENDRUN"
"BIOMARGIN"  ::15
"BIOZONE"
"BIOOPEN"
"BIOPRINTI16"
"BIOPRINTI32"
"BIOPRINTR32"
"BIOPRINTR64"
"BIOPRINTSTRING"
"BIOMATPRINTI8"
"BIOMATPRINTI16"
"BIOMATPRINTI32"
"BIOMATPRINTR32"
"BIOMATPRINTR64"
"BIOMATPRINTSTRING"
"BIOCLOSEALL"  ::29
"BIOFORMAT"  ::30
"BIOINI16"  ::31
"BIOINI32"
"BIOINR32"
"BIOINR64"
"BIOINSTR"
"BIOLINEINSTR"  ::36
"BIOMATINI8"
"BIOMATINI16"
"BIOMATINI32"
"BIOMATINR32"  ::40
"BIOMATINR64"
"BIOMATINSTR"  ::42
"BIOINITRUN"
"BIOSTRASS" ::44
"BIOSTRCOMP" ::45
"ANGLE"  ::46
"DANGLE"
"BIOCEIL"
"BIODCEIL"
"BIODATE"   ::50
"EPS"
"DEPS"
"BIOINF"
"BIOFP"     ::54
"BIODFP"
"RIP"
"DIP"
"BIOINT"    ::58
"BIODINT"
"LOG2"
"DLOG2"
"BIOI16REM" ::62
"BIOI32REM"
"BIOREM"
"BIODREM"
"BIORND"    ::66
"BIOROUND"
"BIODROUND"
"I16XSIGN"
"I32XSIGN"  ::70
"BIOTIME"
"BIOTRUNCATE"
"BIODTRUNCATE"
"BIOHANDLER"   ::74
"BIOEXITHANDLER"
"BIOSETACCESS"
"BIOSETORGANISATION"
"BIOSETRECTYPE"  ::78
"BIOSETRKIND"
"BIOSETRLENGTH"
"BIOCLOSE"
"BIOASK"
"BIOASKSTRING"
"BIOASKINT"  ::84
"BIOENDINPUT"
"BIOENDOUTPUT"
"BIOERASE"
"BIORESET"
"BIOSDATE"
"BIOSTIME"
"BIOLCASE"
"BIOUCASE"
"BIOLTRIM"
"BIORTRIM"
"BIOORD"
"BIOPOS"
"BIOSTR"
"BIODSTR"
"BIOVAL"
"BIOCAUSE"  ::100
"BIOPARCHAN"  ::101
"BIOMATR32SCALE"  ::102
"BIOMATR64SCALE"  ::103
"BIOMATR32CONST"  ::104
"BIOMATR64CONST"  ::105
"BIOMATR32UNARY"  ::106
"BIOMATR64UNARY"
"BIOMATR32DYADIC" ::108
"BIOMATR64DYADIC"
"BIOMATSTRASS"    ::110
"BIODETR32"
"BIODETR64"       ::112
"BIOCDETR32"
"BIOCDETR64"      ::114
"BIODOTR32"
"BIODOTR64"       ::116
"BIOLBOUND"
"BIOUBOUND"       ::118
"BIODSIZE"
"BIOSIZE"         ::120
"BIOREDIM1"
"BIOREDIM2"          ::122
END;
@BOX 3.1
$LI/$LO16 B0=0, B1=B0+7, B2=B1+10, B3=B2+8,
          B4=B3+10, B5=B4+11, B6=B5+9, B7=B6+9,
          B8=B7+12, B9=B8+11, B10=B9+6, B11=B10+10,
          B12=B11+11, B13=B12+15, B14=B13+12, B15=B14+9,
          B16=B15+9, B17=B16+7, B18=B17+7, B19=B18+11,
          B20=B19+11, B21=B20+11, B22=B21+11, B23=B22+14,
          B24=B23+13, B25=B24+14, B26=B25+14, B27=B26+14,
          B28=B27+14, B29=B28+17, B30=B29+11, B31=B30+9,
          B32=B31+8, B33=B32+8, B34=B33+8, B35=B34+8,
          B36=B35+8, B37=B36+12, B38=B37+10, B39=B38+11,
          B40=B39+11, B41=B40+11, B42=B41+11, B43=B42+11,
          B44=B43+10, B45=B44+9,B46=B45+10;
$LI/$LO16 B47=B46+5, B48=B47+6, B49=B48+7,
          B50=B49+8, B51=B50+7, B52=B51+3, B53=B52+4,
          B54=B53+6, B55=B54+5, B56=B55+6, B57=B56+3,
          B58=B57+3, B59=B58+6, B60=B59+7, B61=B60+4,
          B62=B61+5, B63=B62+9, B64=B63+9, B65=B64+6,
          B66=B65+7, B67=B66+6, B68=B67+8, B69=B68+9,
          B70=B69+8, B71=B70+8, B72=B71+7, B73=B72+11,
          B74=B73+12, B75=B74+10, B76=B75+14, B77=B76+12,
          B78=B77+18, B79=B78+13, B80=B79+11, B81=B80+13,
          B82=B81+8, B83=B82+6, B84=B83+12, B85=B84+9,
          B86=B85+11, B87=B86+12, B88=B87+8, B89=B88+8,
      B90=B89+8, B91=B90+8, B92=B91+8, B93=B92+8,
      B94=B93+8, B95=B94+8, B96=B95+6, B97=B96+6,
      B98=B97+6, B99=B98+7, B100=B99+6, B101=B100+8,
      B102=B101+10, B103=B102+14, B104=B103+14,B105=B104+14,
      B106=B105+14, B107=B106+14, B108=B107+14, B109=B108+15,
      B110=B109+15, B111=B110+12, B112=B111+9, B113=B112+9,
      B114=B113+10, B115=B114+10, B116=B115+9, B117=B116+9,
      B118=B117+9,  B119=B118+9,  B120=B119+8, B121=B120+7,
      B122=B121+9,  B123=B122+9;
@BOX 4.1
DATAVEC BIO.IND($LO16)
B0  B1  B2  B3
B4  B5  B6  B7
B8  B9  B10 B11
B12 B13 B14 B15
B16 B17 B18 B19
B20 B21 B22 B23
B24 B25 B26 B27
B28 B29 B30 B31
B32 B33 B34 B35
B36 B37 B38 B39
B40 B41 B42 B43
B44 B45 B46 B47
B48 B49 B50 B51
B52 B53 B54 B55
B56 B57 B58 B59
B60 B61 B62 B63
B64 B65 B66 B67
B68 B69 B70 B71
B72 B73 B74 B75
B76 B77 B78 B79
B80 B81 B82 B83
B84 B85 B86 B87
B88 B89 B90 B91
B92 B93 B94 B95
B96 B97 B98 B99
B100 B101 B102 B103
B104 B105 B106
B107 B108 B109
B110 B111 B112
B113 B114 B115
B116 B117 B118
B119 B120 B121
B122 B123
END;
@BOX 5.1
$LI/$LO8 BIO.READ.FN=0, BIO.END.READ.FN=1, BIO.END.RUN.FN=14,
         BIO.MARGIN.FN=15, BIO.ZONE.FN=16, BIO.OPEN.FN=17,
        BIO.CLOSE.ALL.FN=29;
@END
///9
@TITLE BSC07.1(1,11)
@COL 1S-2R-5T-3R-4F
@COL 6R
@ROW 3-6
@FLOW 1-2-5N-3-4
@FLOW 5Y-6-4
@BOX 1.0
EXPR(KIND,CODE.INFO) REG.INFO
@BOX 2.0
READ IN EXPRESSION AND
PROCESS IMPLICIT DECLARATIONS
[07.2]
@BOX 3.0
CODE EXPRESSION
[07.3]
@BOX 4.0
END
@BOX 5.0
STRING EXPRESSION?
@BOX 6.0
CODE STRING EXPRESSION
[07.17]
@BOX 1.1
PROC EXPR(K,CODE);
$IN AP;
@BOX 2.1
IN.EXPR(K) => AP;
@BOX 3.1
CODE.EXPR(AP,CODE) => EXPR;
@BOX 4.1
END
@BOX 5.1
IF AS[AP] & %C000 = %C000
@BOX 6.1
0 => EXPR;
CODE.STR.EXPR(AP,0);
@END
//14
@TITLE BSC07.2(1,11)
@COL 1S-2R-3R-4T-5T-6T-7T-8F
@COL 9C-10C-11C-12C
@ROW 5-9
@FLOW 1-2-3-4N-5N-6N-7N-8
@FLOW 4Y-9
@FLOW 5Y-10
@FLOW 6Y-11
@FLOW 7Y-12
@BOX 1.0
IN.EXPR(KIND) EXPR.AP
@BOX 2.0
RECOGNISE EXPR[07.20]
@BOX 3.0
PROCESS IMPLICIT DECLARATIONS AND
TYPE OUT EXPR[07.21]
@BOX 4.0
EXPR TYPE INCORRECT?
@BOX 5.0
CALL EXPR AND EXPR NOT
A SUBROUTINE
@BOX 6.0
INCORRECT USE OF ARRAY NAME
@BOX 7.0
SIMPLE VARIABLE EXPECTED AND
EXPR IS NOT ONE
@BOX 8.0
END
@BOX 9.0
FAULT
@BOX 10.0
FAULT
@BOX 11.0
FAULT
@BOX 12.0
FAULT
@BOX 1.1
PROC IN.EXPR(KIND);
$IN AP,TY,W0,EK;
@BOX 2.1
REC.EXPR(KIND) => AP => IN.EXPR;
@BOX 3.1
REDUCE.EXPR(AP,KIND);
@BOX 4.1
AS[AP] => W0 ->> 14 & 3 => TY;
IF KIND & 1 /=0 AND TY = 3
OR KIND & 2 /=0 AND TY < 2
OR KIND & 4 /= 0  AND TY = 2
@BOX 5.1
W0 & %FF => EK;
IF KIND & %20 /=0 AND EK /=%86
@BOX 6.1
IF EK =%83 AND KIND & %40 = 0
@BOX 7.1
IF KIND & %80 /=0 AND EK /= %81
@BOX 8.1
END
@BOX 9.1
MONITOR(%101A);
@BOX 10.1
MONITOR(%101B);
@BOX 11.1
MONITOR(%101C);
@BOX 12.1
MONITOR(%101D);
@END
///11
@TITLE BSC07.3(1,11)
@COL 1S-2R-3T-4T-5R-6R-7T-8R-9T-10T-11R-12R-13F
@FLOW 1-2-3N-4N-5-6-7N-8-9N-10N-11-12-13
@FLOW 3Y-6
@FLOW 4Y-6
@FLOW 7Y-9Y-13
@FLOW 10Y-12
@BOX 1.0
CODE.EXPR(AP,LOAD.INFO)
@BOX 2.0
SELECT A FOR EXPR EVALUATION
@BOX 3.0
EXPR NOT REQUIRED IN B REGISTER?
@BOX 4.0
EXPR TYPE NOT INTEGER?
@BOX 5.0
SELECT B FOR EXPR EVALUATION
@BOX 6.0
PLANT CODE FOR EXPRESSION[07.28]
@BOX 7.0
CONVERSION NOT REQUIRED?
@BOX 8.0
PLANT CONVERSION
@BOX 9.0
A TO B REGISTER TRANSFER
NOT REQUIRED?
@BOX 10.0
B NOT IN USE?
@BOX 11.0
PLANT B => STACK
NOTE B STACKED
@BOX 12.0
PLANT B=A
NOTE A NOT IN USE
NOTE B IN USE
@BOX 13.0
END
@BOX 1.1
PROC CODE.EXPR(AP,INF);
$IN R;
@BOX 2.1
0 => R;
@BOX 3.1
IF INF & %100 = 0
@BOX 4.1
IF AS[AP] & %C000 /= %4000
@BOX 5.1
%100 => R;
@BOX 6.1
PL.EXPR.CODE(AP,INF & %FEFF ! R) => CODE.EXPR;
@BOX 7.1
IF INF & %1F = 0 OR R=%100 OR CUR.A.TYPE=INF & %1F
@BOX 8.1
SET.A.TYPE(INF & %1F ! %100);
@BOX 9.1
IF INF & %100=0 OR R=%100
@BOX 10.1
IF B.AP =< 0
@BOX 11.1
TL.PL(%47,%2000);
1 +> AS[B.AP];
@BOX 12.1
TL.PL(%2,%3000);
-1 => A.AP;
AP => B.AP;
@BOX 13.1
END
@END
///11
@TITLE BSC07.4(1,11)
@COL 1S-2T-3R-4F
@FLOW 1-2N-3-4
@FLOW 2Y-4
@BOX 1.0
EVAL.EXPR(TYPE, CONST.PTR, EXPR.AP) CONST.TYPE
@BOX 2.0
EXPR NOT A CONSTANT OF REQUIRED TYPE
@BOX 3.0
SET UP CONSTANT VALUE
@BOX 4.0
END
@BOX 1.1
PROC EVAL.EXPR(T, PTR, AP);
@BOX 2.1
0 => EVAL.EXPR;
IF AS[AP] & %FF /= %80
   OR AS[AP] ->> 11 & %18 /= T & %18
@BOX 3.1
CLIST[AS[AP+2]] => PTR^;
AS[AP] ->> 11 => EVAL.EXPR;
@BOX 4.1
END
@END
///7
@TITLE BSC07.5(1,11)
@COL 1S-2R-3F
@FLOW 1-2-3
@BOX 1.0
SAVE.NODE.SUBS(AP)
@BOX 2.0
TBC
@BOX 3.0
END
@BOX 1.1
PROC SAVE.NODE.SUBS(AP);
@BOX 2.1
::TBC
@BOX 3.1
END
@END
//16 21.JUL.83
@TITLE BSC07.6(1,11)
@COL 1S-4T-2R-3F
@COL 5R-6R-7R-8R
@ROW 2-5
@FLOW 1-4N-2-3
@FLOW 4Y-5-6-7-8-3
@BOX 1.0
CODE.NODE(FN, AP)
@BOX 2.0
CALL PLANT NUM FN FOR NUMERIC OPCODES [07.22]
@BOX 3.0
END
@BOX 4.0
STRING NODE
@BOX 5.0
GET TEMPORARY FOR CONCATENATION VECTOR
@BOX 6.0
SET UP STRING OPERAND FOR A
@BOX 7.0
SET UP STRING ASSIGN OPERAND IN VECTOR
@BOX 8.0
PLANT CALL TO CONCATENATE STRING OPERANDS
@BOX 1.1
PROC CODE.NODE(FN, AP);
$IN TN;
@BOX 2.1
PLANT.NUM.FN (TL.OPS[FN], AP);
@BOX 3.1
END
@BOX 4.1
IF AS[AP] & %C000 = %C000
@BOX 5.1
GET.TEMP(STR.N, 2) => TN;
@BOX 6.1
PLANT.STR(TN, 1, 0,0);
@BOX 7.1
PLANT.STR(TN, 0, AP, 1);
@BOX 8.1
DATAVEC SEQ($LO16)
%102C
%46 %8012
%21 %800E
%6000
%46 %44
%22 %8009
%6000
%22 %8009
%6000
%A000
END;
TN => CD.MN.0;
PL.CD.SEQ(^SEQ);
@END
///17 22.JUL.83
@TITLE BSC07.7(1,11)
@COL 18C-19R-20C-21R-22C-23R-24C-25R-26C-27R-28C-29R-31C-32R-33C-34R-35C-36R-37C
-38R
@COL 1S-2R-3T-4R-12C-5R-13C-6T-7R-8T-9R-10R
@COL 41C-42R-11F-14C-15R-39C-40R-16C-17R-30R
@ROW 4-11
@FLOW 1-2-3N-4
@FLOW 6N-7-3
@FLOW 6Y-8N-9-7
@FLOW 8Y-10-3
@FLOW 12-5-3Y-11
@FLOW 14-15-3
@FLOW 16-17-30-3
@FLOW 18-19-3
@FLOW 20-21-3
@FLOW 22-23-3
@FLOW 24-25-3
@FLOW 26-27-3
@FLOW 28-29-3
@FLOW 13-6
@FLOW 39-40-3
@FLOW 31-32-3
@FLOW 33-34-3
@FLOW 35-36-3
@FLOW 37-38-3
@FLOW 41-42-3
@BOX 1.0
PL.CD.SEQ(CODE.SEQUENCE)
@BOX 2.0
GET SIZE OF CODE SEQUENCE
@BOX 3.0
ALL SEQUENCE CODED?
@BOX 4.0
SWITCH ON CODING ACTION
@BOX 5.0
CALL TL.REG
@BOX 6.0
TL.PL OPERAND ENCODED?
@BOX 7.0
CALL TL.PL
FORGET CURRENT A TYPE IF
OPCODE IS EITHER AMODE OR ACONV
@BOX 8.0
STKLB TO RUNTIME PROCEDURE
@BOX 9.0
GET OPERAND
@BOX 10.0
PLANT STK LB
[BSC07.8]
@BOX 11.0
END
@BOX 12.0
8
@BOX 13.0
0
@BOX 14.0
13
@BOX 15.0
PLANT CODE TO SET ELEMENT SIZE
OF STRING ARRAY
@BOX 16.0
12
@BOX 17.0
SELECT EXPR
@BOX 18.0
1
@BOX 19.0
PLANT STACKLINK TO LIB PROC
@BOX 20.0
2
@BOX 21.0
CONVERT DEGREES TO RADIANS IF NECESSARY
@BOX 22.0
3
@BOX 23.0
PLANT MUTL MFN
@BOX 24.0
4
@BOX 25.0
CONVERT RADIANS TO DEGREES IF NECESSARY
@BOX 26.0
6
@BOX 27.0
STACK A RESET A USE
@BOX 28.0
10
@BOX 29.0
PLANT ENTER
@BOX 30.0
CODE EXPRESSION
STACK A AND RESET A USE IF REQUESTED
@BOX 31.0
5
@BOX 32.0
DECLARE TEMP STRING
MUTL NAME => CD.MN.0
@BOX 33.0
7
@BOX 34.0
CODE.STR.EXPR(EXPR0)
@BOX 35.0
9
@BOX 36.0
CODE.STR.EXPR(EXPR0, CD.MN.0)
@BOX 37.0
4
@BOX 38.0
CODE.STR.EXPR(EXPR1)
@BOX 39.0
15
@BOX 40.0
PLANT A=(REF) OF FIRST
PARAMETER
@BOX 41.0
11
@BOX 42.0
PLANT STACK REF TO ARRAY STORAGE IF REQUESTED
         AND STACK REF TO ARRAY DESCRIPTOR
         FOR REQUESTED PARAMETER
@BOX 1.1
PROC PL.CD.SEQ(CD);
$IN Z,I,E,TEMP0,T,N,MN;
$LO16 OPC,OPD;
@BOX 2.1
SIZE(CD) => Z;
-1 => I;
@BOX 3.1
IF 1+>I >= Z
@BOX 4.1
CD^[I+1] => OPD;
SWITCH CD^[I] => OP.C ->> 12\
SW0,SW1,SW2,SW3,SW4,SW5,SW6,SW7,
SW8,SW9,SW10,SW11,SW12,SW13,SW14,SW15;
@BOX 5.1
TL.REG(OPD);
@BOX 6.1
IF OPD & %8000 /= 0
@BOX 7.1
TL.PL(OPC,OPD);
IF OPC = %45 OR OPC = %46 THEN
   -1 => CUR.A.TYPE;
FI
@BOX 8.1
IF OPD & %4000 /=0
@BOX 9.1
ALTERNATIVE OPD & %FF FROM
   DATAMN => OPD;   ::0
   DATAMN+1 => OPD; ::1
   TL.TYP[B.INT->>3] => OPD;  ::2
   BEGIN                      ::3
      TL.C.LIT16(%44,G.LIT.16.0);
      0 => OPD;
   END
   LAB.MN => OPD;             ::4
   OPEN.ID.MN => OPD;         ::5
   GO.SUB.LABS => OPD;        ::6
   GO.SUB.PTR => OPD;         ::7
   ZERO => OPD;               ::8
   ONE => OPD;                ::9
   LAST.MN+1 => OPD;          ::10
   BEGIN                      ::11
      TL.CLIT.32(%4C,G.LIT.32.0);
      0 => OPD;
   END
   LAST.MN+2 => OPD;          ::12
   C.EXIT.LAB => OPD;        ::13
   CD.MN.0 => OPD;  ::14
   BEGIN
      TL.C.LIT.16(%44,G.LIT.16.1);
      0 => OPD;
   END
   CD.MN.1 => OPD;      ::16
   CUR.PROC => OPD;   ::17
   STR.N + 3=> OPD;   ::18
   EXLINE.MN => OPD; ::19
   EXTYPE.MN => OPD; ::20
   TEMP.0 => OPD; ::21
END;
@BOX 10.1
PL.STK.LB(OPD & %FF);
@BOX 11.1
END;
@BOX 12.1
SW8:;
1 +> I;
@BOX 13.1
SW0:;
1 +> I;
@BOX 14.1
SW13:;
@BOX 15.1
IF DETAIL1 OF NLIST[AS[EXPR.AP.0 + 2] => N] & %20 /= 0 THEN
   TL.PL(%22, MUTLN OF NLIST[N] - 1 => MN);
   TL.PL(%29, ONE);
ELSE
   TL.CLIT.16(%44, ARRAYS[DETAIL OF NLIST[N] -1] - 1);
   TL.PL(%22, 0);
FI
@BOX 30.1
CODE.EXPR(E,OP.C & %FF);
IF OP.C & %800 /=0 THEN
   TL.PL(%41,%3000);
   -1 => A.AP;
FI
@BOX 16.1
SW12:;
@BOX 17.1
IF OPC & %700 => E = 0 THEN
   EXPR.AP.0 => E;
ELSE IF E = %100 THEN
   EXPR.AP.1 => E;
ELSE
   EXPR.AP.2 => E;
FI FI
@BOX 18.1
SW1:;
@BOX 19.1
PL.STK.LB (OPC & %FFF);
@BOX 20.1
SW2:;
@BOX 21.1
IF OPTIONS & 1 /= 0 THEN
   TL.PL(%2B,RADIANS);
FI
@BOX 22.1
SW3:;
@BOX 23.1
IF OPC & %400 /= 0 AND MFN.I16 = 0 THEN
   TL.PL(%45, %4C);
   -1 => CUR.A.TYPE;
FI
TL.PL(%32,OPC & %1FF);
IF OPC & %200 /= 0 AND MFN.I16 = 0 THEN
   TL.PL(%45, %44)
FI
IF OPC & %800 /= 0 THEN
   -1 => A.AP;
FI
@BOX 24.1
SW4:;
@BOX 25.1
IF OPTIONS & 1 /= 0 THEN
   TL.PL(%2B,DEGREES);
FI
@BOX 26.1
SW6:;
@BOX 27.1
TL.PL(%41,%3000);
-1 => A.AP;
@BOX 31.1
SW5:;
@BOX 32.1
IF OPC & %FFF => OPC = 0 THEN
   DEF.STR.Z  + 1=> OPC;
FI
GET.TEMP(%80, OPC) => TEMP.0;
@BOX 33.1
SW7:;
@BOX 34.1
CODE.STR.EXPR(EXPR.AP.0, OP.C & %FFF);
@BOX 35.1
SW9:;
@BOX 36.1
CODE.STR.EXPR(EXPR.AP.0, TEMP.0 ! %4000);
@BOX 37.1
SW14:;
@BOX 38.1
CODE.STR.EXPR(EXPR.AP.1, 0);
@BOX 28.1
SW10:;
@BOX 29.1
TL.PL(%42,%0);
-1 => CUR.ATYPE;
@BOX 39.1
SW15:;
@BOX 40.1
DETAIL1 OF NLIST[AS[EXPR.AP.0 + 2] => N] ->> 5 & 1 + %21 => T;
TL.PL(T, MUTLN OF NLIST[N]);
@BOX 41.1
SW11:;
@BOX 42.1
IF OPC & %F0 = 0 THEN
   EXPR.AP.0 => E;
ELSE
   EXPR.AP.1 => E;
FI
DETAIL1 OF NLIST[AS[E + 2] => N] ->> 5 & 1 + %21 => T;
MUTLN OF NLIST[N] => MN;
IF OPC & %F = 1 THEN
   SET.A.TYPE(T OF NLIST[N] ->> 3 ! %C00);
   TL.PL(T, MN);
   TL.PL(%41, %3000);
FI
SET.A.TYPE(%C00 ! B.ADDR);
TL.PL(T, MN + 1);
TL.PL(%41, %3000);
@END
///13
@TITLE BSC07.8(1,11)
@COL 1S-2T-3R-4R-5F
@FLOW 1-2N-3-4-5
@FLOW 2Y-4
@BOX 1.0
PL.STK.LB(BIO.PROC.ID)
@BOX 2.0
FIND.N INDEX OF BIO PROC
ALREADY KNOWN?
@BOX 3.0
CREATE WRITEABLE COPY OF NAME
GET FIND.N AND RESULT TYPE OF BIO PROC
ISSUE FAULT IF NOT FOUND
@BOX 4.0
PLANT STK LB
@BOX 5.0
END
@BOX 1.1
PROC PL.STK.LB(P.ID);
$LO32 FN;
$LO8[32] BUF;
ADDR [$LO8] P;
$IN S,F,I;
@BOX 2.1
IF BIO.FN[P.I.D] => FN /= 0
@BOX 3.1
BIO.IND[P.ID] => S;
BIO.IND[P.ID+1] => F;
FOR I < F-S DO
   BIO.NAMES[S+I] => BUF[I];
OD;
PART(^BUF,0,F-S-1) => P;
IF FIND.N(P,0) => BIO.FN[P.ID] => FN = 0 THEN
   MONITOR.S(%19,P);
ELSE
   FIND.P(FN, -1, FIND.P(FN, -1, 0) + 1) => BIO.FN.RES[P.I.D];
FI
@BOX 4.1
TL.C.LIT32(%8C,FN);
TL.PL(%48,BIO.FN.RES[P.I.D]);
@BOX 5.1
END
@END
 ///3
@TITLE BSC07.9(1,11)
@COL 1S-2T-3T-4R-5R-6R-7F
@COL 8R
@ROW 4-8
@FLOW 1-2N-3N-4-5-6-7
@FLOW 2Y-8-6
@FLOW 3Y-5
@BOX 1.0
PL.COND.JUMP(TEST,LABEL)
TEST Bits 0-7
   0 - Acc loaded with TRUE/FALSE
   /= 0 - The following T condition status represents a
          TRUE for the relational expression
          1 =,2 /=,3 >=,4 <,5 =<,6 >
   Bit 8 = 0/1 Jump if relational expression is true/false
@BOX 2.0
VALUE OF RELATIONAL EXPRESSION IN ACC?
@BOX 3.0
JUMP IF TRUE REQUIRED?
@BOX 4.0
REVERSE TEST
@BOX 5.0
SET UP OPCODE
@BOX 6.0
PLANT COND JUMP
@BOX 7.0
END
@BOX 8.0
SET UP OPCODE
@BOX 1.1
PROC PL.COND.JUMP(TST,LAB);
$IN OPC;
DATAVEC REV.TEST($LO8)
0  ::  NOT USED
2  ::  =   ->  /=
1  ::  /=  ->  =
4  ::  >=  ->  <
3  ::  <   ->  >=
6  ::  =<  ->  >
5  ::  >   ->  <=
END;
@BOX 2.1
IF TST & %FF = 0
@BOX 3.1
IF TST & %100 = 0
@BOX 4.1
REV.TEST[TST & %F] => TST;
@BOX 5.1
%48 +> TST;
@BOX 6.1
TL.PL(TST,LAB);
@BOX 7.1
END;
@BOX 8.1
TL.PL(%2F, ZERO);
(IF TST /=0 THEN
 0 ELSE 1) + %49 => TST;
@END
///11
@TITLE BSC07.10(1,11)
@COL 1S-17T-2R-3T-4R-5R-6T-7R-8T-9R-10T-11R-12T-13R-14R-15T-16F
@COL 18R
@ROW 3-18
@FLOW 1-17N-2-3N-4-5-6N-7-8N-9-10N-11-12N-13-14-15N-16
@FLOW 3Y-6Y-8Y-10Y-12Y-14
@FLOW 17Y-18
@FLOW 15Y-8
@BOX 1.0
CODE LET([LHS.OPERANDS],NO.OF.LH.OPERANDS,RHS.EXPR)
@BOX 2.0
CODE RHS EXPRESSION [07.3]
NOTE CURRENT ACC TYPE
@BOX 3.0
SCAN LIST OF LHS ITEMS
ITEMS ALL OF SAME TYPE AND PRECISION?
@BOX 4.0
GET TEMPORARY VARIABLE FOR RHS
@BOX 5.0
PLANT A => (NON DESTRUCT) TEMP
@BOX 6.0
ONLY ONE LHS ITEM?
@BOX 7.0
SCAN LHS LIST AND CODE ANY
NON-CONSTANT SUBSCRIPT AND SUBSTRING
EXPRESSIONS
@BOX 8.0
ACC TYPE SAME AS CURRENT LHS ITEM OR
TYPE OF RHS EXPR
@BOX 9.0
SET ACC MODE TO RHS EXPR TYPE
LOAD ACC FROM TEMP
@BOX 10.0
ACC TYPE SAME AS CURRENT LHS ITEM
@BOX 11.0
PLANT ACONV
@BOX 12.0
NEXT LHS ITEM IS OF SAME TYPE AS ACC
OR ACC IS OF RHS TYPE OR LAST LHS ITEM
@BOX 13.0
NOTE NON DESTRUCT STORE REQUIRED
@BOX 14.0
PLANT A => LHS ITEM
@BOX 15.0
MORE LHS ITEMS?
@BOX 16.0
END
@BOX 17.0
STRING ASSIGNMENT?
@BOX 18.0
CODE STRING LET [07.10.1]
@BOX 1.1
PROC CODE.LET(LH,Z,RAP);
$IN W0,ET,I,T,N,AT,LI,LT,RN;
@BOX 2.1
CODE.EXPR(RAP,ET);
0 => LI;
ET => AT;
@BOX 3.1
AS[LH^[0]] & %F800 => T;
1 => I;
WHILE I < Z DO
   IF AS[LH^[I]] & %F800 = T THEN
      1 +> I;
   ELSE
      1+Z => I;
   FI
OD
IF I = Z
@BOX 4.1
GET.TEMP(ET,0) => N;
@BOX 5.1
TL.REG(2);
TL.PL(%20,N);
@BOX 6.1
IF Z =< 1
@BOX 7.1
FOR I < Z DO
   SAVE.NODE.SUBS(LH^[I]);
OD
@BOX 8.1
IF AS[LH^[LI]] ->> 11 & %1F => LT = AT OR AT = ET
@BOX 9.1
SET.A.TYPE(ET=>AT);
TL.PL(%22,N);
@BOX 10.1
IF LT = AT
@BOX 11.1
SET.A.TYPE(LT => AT ! %100);
@BOX 12.1
IF LI+1 = Z OR AT=ET
   OR AS[LH^[LI+1]]->>11 & %1F = AT
@BOX 13.1
TL.REG(2);
@BOX 14.1
PLANT.NUM.FN(0,LH^[LI]);
@BOX 15.1
IF 1 +> LI < Z
@BOX 16.1
END
@BOX 17.1
IF AS[RAP] => W0 ->> 11 & %1F => ET & %18 = %18
@BOX 18.1
#BSC07.10.1
@END
//16 21.JUL.83
@TITLE BSC07.10.1(1,11)
@COL 1S-2R-3R-4R-5R-6R-7F
@FLOW 1-2-3-4-5-6-7
@BOX 1.0
CODE STRING ASSIGNMENT
@BOX 2.0
COUNT NO OF LHS ITEMS AND
RH STRINGS
@BOX 3.0
GET STRING SPECIFIER VECTOR OF
SUFFICIENT LENGTH
@BOX 4.0
FOR EACH LHS ITEM
PLANT CODE TO ADD STRING SPECIFICATION
ENTRY TO VECTOR
@BOX 5.0
FOR EACH STRING IN RHS EXPR
PLANT CODE TO ADD STRING SPECIFICATION
ENTRY TO VECTOR
@BOX 6.0
PLANT CALL TO STRING
ASSIGNMENT PROCESSOR
@BOX 7.0
END
@BOX 1.1
@BOX 2.1
CNT.STR.OPNDS(RAP) => R.N;
@BOX 3.1
GET.TEMP(STR.N,Z+R.N) => N;
@BOX 4.1
FOR I < Z DO
   PLANT.STR(N,I,LH^[I], 1);
OD
@BOX 5.1
CODE.STR.OPNDS(N,Z,RAP);
@BOX 6.1
BEGIN
DATAVEC CD.SEQ($LO16)
%48  %C02C
%46  %8012
%21  %800E
%41  %3000
%46  %44
%22  %8003
%41  %3000
%22  %800F
%41  %3000
%42  %0
END;
N => CD.MN.0;
Z => G.LIT.16.0;
RN => G.LIT.16.1;
PL.CD.SEQ(^CD.SEQ);
END;
@BOX 7.1
@END
///16 21.JUL.83
@TITLE BSC07.11(1,11)
@COL 11R-12R-14R
@COL 1S-17R-2T-3T-4T-5T-6T-7T-8R-9R-10F
@COL 15R-16R
@ROW 11-4
@ROW 3-15
@ROW 12-6-16
@FLOW 1-17-2N-3N-4N-5N-6N-7N-8-10
@FLOW 2N-15
@FLOW 3Y-11-8
@FLOW 4Y-16-10
@FLOW 5Y-12-14-10
@FLOW 6Y-9-10
@FLOW 7Y-14
@BOX 1.0
CODE.MAT(LHS.AP, RHS.AP)
@BOX 2.0
STRING MATRIX?
@BOX 3.0
NOTE NUMERIC TYPE
RHS AN ARRAY?
@BOX 4.0
RHS AN ARRAY FUNCTION REFN?
@BOX 5.0
RHS AN ARRAY VALUE?
@BOX 6.0
IMMEDIATE LH OPERAND OF
RHS NOT A NUMERIC EXPRESSION
@BOX 7.0
IMMEDIATE RH OPERAND OF
RHS AN ARRAY VALUE
@BOX 8.0
PLANT CALL TO MAT.SCALE
@BOX 9.0
PLANT CALLS TO MAT.DIADIC
FOR RHS EXPRESSION
@BOX 10.0
END
@BOX 11.0
NOTE SCALAR MULTIPLIER IS ONE
@BOX 12.0
NOTE SCALAR MULTIPLIER IS ONE
@BOX 14.0
PLANT CALL TO MAT.CONST
IF ARRAY VALUE SIZE GIVEN ADD 1
    IF ARRAY BASE IS ZERO
@BOX 15.0
PLANT CODE FOR
STRING MATRIX ASSIGNMENT [07.11.4]
@BOX 16.0
PLANT CALL TO
MAT UNARY
@BOX 17.0
NOTE WRITE ACCESS IN PROPERTIES
@BOX 1.1
PROC CODE.MAT(LHS.AP, RHS.AP);
$IN TY, RHS.0, T, L.0, R, SC, ARR.AP, SC.AP, ARR.T, FN, N;
$IN VEC.MN, VEC.IND, STR.CNT, P;
PSPEC CD.DIADIC($IN, $IN, $IN);
PSPEC STK.ARRAY.PTRS($IN, $IN);
#BSC07.11.1
#BSC07.11.3
@BOX 2.1
IF AS[LHS.AP] & %F800 => TY = %C000
@BOX 3.1
RHS.AP => ARR.AP;
0 => SC;
AS[RHS.AP] => RHS.0 ->> 11 & %1F => ARR.T & 1 => R;
IF RHS.0 & %8F => T = %83
@BOX 4.1
IF T = %85
@BOX 5.1
IF T = %84
@BOX 6.1
AS[RHS.AP + 3] => ARR.AP;
IF AS[AS[RHS.AP+2] => SC.AP] => L.0 & %8F = %83
   OR L.0 & %380 = %200
@BOX 7.1
IF AS [ARR.AP] & %8F = %84
@BOX 8.1
PL.STK.LB (R+102);
STK.ARRAY.PTRS (ARR.AP, ARR.T);
STK.ARRAY.PTRS (LHS.AP, ARR.T);
IF SC = 0 THEN
   CODE.EXPR (SC.AP, ARR.T);
ELSE
   SET.A.TYPE (ARR.T);
   TL.PL (%22, ONE);
FI
TL.PL (%41, %3000);
TL.PL (%42, 0);
@BOX 9.1
CD.DIADIC (RHS.AP, LHS.AP, ARR.T);
@BOX 10.1
END
@BOX 11.1
1 => SC;
@BOX 12.1
1 => SC;
@BOX 14.1
PL.STK.LB (R + 104);
STK.ARRAY.PTRS (LHS.AP, ARR.T);
IF AS[ARR.AP] & %100 /= 0 AND
   AS[AS[ARR.AP+3] => P] => N > 0 THEN
   CODE.EXPR(AS[P+1], B.ADDR);
   IF DEF.BASE = 0 THEN


      TL.PL(%28, ONE);
   FI
   %40 => FN;
ELSE
   0 => FN => N;
   SET.A.TYPE (B.ADDR);
   TL.PL(%22,ONE);
FI
TL.PL(%41, %3000);
-1 => A.AP;
IF N > 1 THEN
   CODE.EXPR (AS[P+2],B.ADDR);
   IF DEF.BASE = 0 THEN
      TL.PL(%28, ONE);
   FI
ELSE
   SET.A.TYPE(B.ADDR);
   TL.PL(%22,ONE);
FI
TL.PL(%41, %3000);
-1 => A.AP;
IF SC = 0 THEN
   CODE.EXPR (SC.AP, ARR.T);
   %20 !> FN;
ELSE
   SET.A.TYPE (ARR.T);
   TL.PL(%22, ONE);
FI
-1 => A.AP;
TL.PL(%41, %3000);
IF K OF NLIST[AS[LHS.AP+2]] = 2 THEN
   %10 !> FN;
FI
TL.C.LIT.16(%44,BFN.CODE[BFN.CODE.I[AS[ARR.AP+2]]] + FN);
SET.A.TYPE(%9);
TL.PL(%22,0);
TL.PL(%41,%3000);
TL.PL(%42,0);
@BOX 15.1
#BSC07.11.4
@BOX 16.1
PL.STK.LB(R+106);
STK.ARRAY.PTRS(AS[AS[RHS.AP + 3] + 1], ARR.T);
STK.ARRAY.PTRS(LHS.AP, ARR.T);
TL.CLIT.16(%44, BFN.CODE[BFN.CODE.I[AS[RHS.AP+2]]]);
SET.A.TYPE(9);
TL.PL(%22,0);
TL.PL(%41,%3000);
TL.PL(%42,0);
@BOX 17.1
8 !> DETAIL1 OF NLIST[AS[LHS.AP+2]];
@END
///15
@TITLE BSC07.11.1(1,11)
@COL 1S-2R-3R-4R-6R-7R-8R-9F
@FLOW 1-2-3-4-6-7-8-9
@BOX 1.0
CD.DIADIC.NODE(NODE.AP, LHS.AP, TYPE)
@BOX 2.0
PLANT STACKLINK TO
APPROPRIATE MAT.DIADIC PROC
@BOX 3.0
STACK PARAMETERS FOR
LH 'ARRAY' OF NODE
[07.11.3]
@BOX 4.0
STACK PARAMETERS FOR
RH 'ARRAY' OF NODE
[07.11.3]
@BOX 6.0
STACK PARAMETERS FOR RESULT
MATRIX [07.11.3]
@BOX 7.0
STACK FUNCTION
@BOX 8.0
PLANT ENTER
@BOX 9.0
END
@BOX 1.1
PROC CD.DIADIC (OPD, RES, TY);
$IN R;
@BOX 2.1
PL.STK.LB (TY & 1 + 108);
@BOX 3.1
STK.ARRAY.PTRS(AS[OPD+2],TY);
@BOX 4.1
STK.ARRAY.PTRS(AS[OPD+3],TY);
@BOX 6.1
STK.ARRAY.PTRS(RES,TY);
@BOX 7.1
SET.A.TYPE(%9);
TL.C.LIT.16(%44, TL.OPS[AS[OPD] & %1F]);
TL.PL(%22,0);
TL.PL(%41, %3000);
@BOX 8.1
TL.PL(%42,0);
@BOX 9.1
END
@END
///15
@TITLE BSC07.11.3(1,11)
@COL 1S-2R-3F
@FLOW 1-2-3
@BOX 1.0
STK.ARRAY.PTRS(ARRAY.AP, TYPE)
@BOX 2.0
STACK PTR TO ARRAY STORAGE
STACK PTR TO ARRAY DESCRIPTOR
@BOX 3.0
END
@BOX 1.1
PROC STK.ARRAY.PTRS (AP,TY);
$IN OPC, N;
@BOX 2.1
SET.A.TYPE(%C00 ! TY);
IF DETAIL1 OF NLIST [AS[AP+2] => N] & %20 = 0 THEN
   %21 => OPC;
ELSE
   %22 => OPC;
FI
TL.PL (OP.C, MUTLN OF NLIST[N] => N);
TL.PL (%41,%3000);
SET.A.TYPE (%C00 ! B.ADDR);
TL.PL (OP.C, N+1);
TL.PL (%41, %3000);
@BOX 3.1
END
@END
///15
@TITLE BSC07.11.4(1,11)
@COL 1S-3R-5R-4R-6R-7F
@FLOW 1-3-5-4-6-7
@BOX 1.0
CODE STRING ARRAY ASSIGN
@BOX 3.0
GET VECTOR FOR STRING ARRAY
OPERAND DESCRIPTIONS
@BOX 4.0
SET FIRST STRING ARRAY OPERAND
TO LHS [07.11.6]
@BOX 5.0
SET UP DESCRIPTIONS OF RHS
OPERANDS IN VECTOR [07.11.5]
@BOX 6.0
PLANT CALL TO BIO.MAT.STR.ASS
@BOX 7.0
EXIT
@BOX 1.1
PSPEC CD.STR.ARRAY.OPD($IN);
PSPEC CD.STR.ARRAY.OPDS($IN)/$IN;
PSPEC CD.STR.ARRAY($IN);
PSPEC SET.FIELD($IN);
PSPEC CD.SCAL.STR.VAL($IN);
PSPEC SEL.OPD.DESC();
PSPEC PUT.KIND($IN);
PSPEC CD.MAT.STRING.SUBS($IN);
#BSC07.11.5
#BSC07.11.6
#BSC07.11.7
#BSC07.11.8
#BSC07.11.9
#BSC07.11.10
#BSC07.11.11
#BSC07.11.12
@BOX 3.1
GET.TEMP(MAT.STR.N,3) => VEC.MN;
TL.SELECT.VAR();
1 +> LAST.MN;
@BOX 4.1
0 => VEC.IND;
CD.STR.ARRAY.OPD(LHS.AP);
@BOX 5.1
1 => VEC.IND;
CD.STR.ARRAY.OPDS(RHS.AP) => STR.CNT;
@BOX 6.1
BEGIN
DATAVEC CD.SEQ($LO16)
%106E         ::STK LNK BIOMATSTRASS
%46    %800E  ::AMODE = ARRAY.STR.OPND
%21    %8010  ::A = REF VEC OF ARRAY.STR.OPDS
%6000         ::STACK A
%46    %44    ::AMODE = IN16
%22    %8003  ::A=RHS OPND CNT
%6000         ::STACK A
%A000         ::ENTER
END
MAT.STR.N + 3 => CD.MN.0;
VEC.MN => CD.MN.1;
STR.CNT => G.LIT.16.0;
PL.CD.SEQ (^CD.SEQ);
END
@BOX 7.1
EXIT;
@END
///16
@TITLE BSC07.11.5(1,11)
@COL 8R
@COL 1S-2T-3T-4T-20R-5R-6R-7F
@COL 10R-11R-12R-13R-14R-15T-16R-17T-18R-19R
@ROW 8-5
@ROW 3-10
@FLOW 1-2N-3N-4N-20-5-6-7
@FLOW 2Y-10-12-13-14-15N-16-17N-18-19-7
@FLOW 15Y-19
@FLOW 17Y-19
@FLOW 3Y-11-12
@FLOW 4Y-8-7
@BOX 1.0
CD.STR.ARRAY.OPDS (NODE.AP)
@BOX 2.0
NODE IS 'NULL'
@BOX 3.0
RHS OPERAND OF NODE IS 'NULL'
@BOX 4.0
NODE IS AN ARRAY?
@BOX 5.0
CODE STRING ARRAYS IN LHS [07.11.6]
@BOX 6.0
CODE STRING ARRAYS IN RHS [07.11.6]
@BOX 7.0
END
@BOX 8.0
CODE STRING ARRAY [07.11.7]
@BOX 10.0
PLANT A=REL BASIC NIL STRING
@BOX 11.0
REDUCE STRING OPERAND COUNT BY ONE
PLANT A=REF OF SCALAR STRING VALUE
@BOX 12.0
PLANT CODE TO SELECT NEXT
STRING ARRAY OPERAND DESCRIPTION [07.11.9]
@BOX 13.0
PLANT CODE TO PUT PTR
TO SCALAR STRING VALUE IN OPERAND DESCRIPTION
@BOX 14.0
NOTE KIND
@BOX 15.0
'NULL' WITH NO ARGUMENTS
@BOX 16.0
CODE EXPRESSION FOR FIRST DIMENSION SIZE
AND PUT VALUE IN DESCRIPTION
ADD ONE IF ARRAY BASE IS ZERO
@BOX 17.0
NULL WITH 1 PARAMETER
@BOX 18.0
CODE EXPRESSION FOR SECOND DIMENSION SIZE
AND PUT VALUE IN DESCRIPTION
ADD ONE IF ARRAY BASE IS ZERO
@BOX 19.0
PLANT CODE TO PUT KIND
IN OPERAND DESCRIPTION
@BOX 20.0
CODE ANY ARRAY SUBSCRIPTS
[07.11.11]
@BOX 1.1
PROC CD.STR.ARRAY.OPDS(AP);
$IN N0, R0, R.AP, K, P;
@BOX 2.1
1 => CD.STR.ARRAY.OPDS;
IF AS[AP] => N0 & %8F = %84
@BOX 3.1
IF AS[AS[AP+3] => R.AP] => R.0 & %8F = %84
@BOX 4.1
IF N0 & %8F = %83
@BOX 5.1
2 => CD.STR.ARRAY.OPDS;
CD.STR.ARRAY.OPD (AS[AP+2]);
@BOX 6.1
CD.STR.ARRAY.OPD(RAP);
@BOX 7.1
END
@BOX 8.1
CD.STR.ARRAY(AP);
@BOX 10.1
SET.A.TYPE(%C18);
TL.PL(%21,B.NIL.N);
@BOX 11.1
CODE.STR.EXPR(AS[AP+2],0);
1 -> STR.CNT;
R.AP => AP;
@BOX 12.1
SEL.OPD.DESC();
@BOX 13.1
SET.FIELD(1);
@BOX 14.1
3 => K;
@BOX 15.1
IF AS[AP] & %100 = 0
@BOX 16.1
CODE.EXPR(AS[AS[AP+3] => P+1],B.ADDR);
IF DEF.BASE = 0 THEN
   TL.PL(%28, ONE);
FI
SET.FIELD(2);
-1 => A.AP;
1 => K;
@BOX 17.1
IF AS[P] < 2
@BOX 18.1
CODE.EXPR(AS[P+2],B.ADDR);
IF DEF.BASE = 0 THEN
   TL.PL(%28, ONE);
FI
SET.FIELD(3);
-1 => A.AP;
@BOX 19.1
PUT.KIND(K OF NLIST[AS[LHS.AP+2]]+K <<- 1);
@BOX 20.1
CD.MAT.STRING.SUBS(AP);
@END
///15
@TITLE BSC07.11.6(1,11)
@COL 6R
@COL 1S-2T-7R-5F
@ROW 6-7
@FLOW 1-2N-7-5
@FLOW 2Y-6-5
@BOX 1.0
CD.STR.ARRAY.OPD(AP)
@BOX 3.0
OPERAND IS A SCALAR STRING VALUE?
@BOX 2.0
OPERAND IS AN ARRAY?
@BOX 5.0
END
@BOX 7.0
CODE SCALAR STRING VALUE [07.11.8]
@BOX 6.0
CODE STRING ARRAY [07.11.7]
@BOX 1.1
PROC CD.STR.ARRAY.OPD(AP);
$IN N0;
@BOX 2.1
IF AS[AP] => N0 & %8F = %83
@BOX 5.1
END;
@BOX 6.1
CD.STR.ARRAY(AP);
@BOX 7.1
CD.SCAL.STR.VAL(AP);
@END
///15
@TITLE BSC07.11.7(1,11)
@COL 1S-2R-3R-4T-5R-6R-7R-8F
@FLOW 1-2-3-4N-5-6-7-8
@FLOW 4Y-7
@BOX 1.0
CD.STR.ARRAY(AP)
@BOX 2.0
PLANT CODE TO SELECT
NEXT STRING ARRAY OPERAND DESCRIPTOR
[07.11.9]
@BOX 3.0
PLANT CODE TO PUT PTRS TO
ARRAY STORAGE, ELEMENT SIZE, AND
ARRAY DESCRIPTOR IN ARRAY OPERAND DESCRIPTOR
@BOX 4.0
NO SUBSTRINGS?
@BOX 5.0
CODE LOWER SUBSTRING EXPRESSION
AND PUT IN ARRAY OPERAND DESCRIPTOR
@BOX 6.0
CODE UPPER SUBSTRING EXPRESSION
AND PUT IN ARRAY OPERAND DESCRIPTOR
@BOX 7.0
PLANT CODE TO PUT KIND IN
ARRAY OPERAND DESCRIPTOR
@BOX 8.0
END
@BOX 1.1
PROC CD.STR.ARRAY(AP);
$IN OPC, N, K, Z.MN, M;
@BOX 2.1
SEL.OPD.DESC();
@BOX 3.1
SET.A.TYPE(%C18);
IF DETAIL1 OF NLIST [AS[AP+2] => N] & %20 = 0 THEN
   %21 => OP.C;
ELSE
   %22 => OP.C;
FI
TL.PL(OP.C, MUTL.N OF NLIST[N] => M);
SET.FIELD(1);
SET.A.TYPE(%C00 ! BADDR);
TL.PL(OPC,M+1);
SET.FIELD(4);
SET.A.TYPE(9);
IF OP.C = %22 THEN
   N - 1 => Z.MN;
ELSE
   TL.CLIT.16(%44, ARRAYS[DETAIL OF NLIST[N] - 1]);
   0 => Z.MN;
FI
TL.PL(%22, Z.MN);
SET.FIELD(5);
@BOX 4.1
0 => K;
IF AS[AP] & %200 = 0
@BOX 5.1
1 => K;
CODE.EXPR(AS[AP+4],B.ADDR);
SET.FIELD(2);
-1 => A.AP;
@BOX 6.1
CODE.EXPR(AS[AP+5],B.ADDR);
SET.FIELD(3);
-1 => A.AP;
@BOX 7.1
PUT.KIND(K);
@BOX 8.1
END;
@END
///15
@TITLE BSC07.11.8(1,11)
@COL 1S-2R-3R-4R-5F
@FLOW 1-2-3-4-5
@BOX 1.0
CD.SCAL.STR.VAL (AP)
@BOX 2.0
PLANT CODE TO SELECT
NEXT STRING ARRAY OPERAND DESCRIPTOR
[07.11.9]
@BOX 3.0
CODE SCALAR STRING VALUE
AND PUT PTR TO IT IN STRING ARRAY OPERAND DESCRIPION
@BOX 4.0
PLANT CODE TO
PUT KIND IN STRING ARRAY OPERAND DESCRIPTOR
@BOX 5.0
END
@BOX 1.1
PROC CD.SCAL.STR.VAL(AP);
@BOX 2.1
SEL.OPD.DESC();
@BOX 3.1
CODE.STR.EXPR(AP,0);
SET.FIELD(1);
@BOX 4.1
PUT.KIND(2);
@BOX 5.1
END;
@END
///15
@TITLE BSC07.11.9(1,11)
@COL 1S-2R-3F
@FLOW 1-2-3
@BOX 1.0
SEL.OPD.DESC
@BOX 2.0
PLANT CODE TO SELECT
NEXT VAILABLE ELEMENT IN
STRING ARRAY OPERAND DESCRIPTOR VECTOR
@BOX 3.0
END
@BOX 1.1
PROC SEL.OPD.DESC;
@BOX 2.1
TL.PL(%61,VEC.MN);
TL.C.LIT.16(%44, VEC.IND);
1 +> VEC.IND;
TL.PL(2,0);
TL.PL(%64,0);
TL.PL(%60,VEC.MN+1);
@BOX 3.1
END
@END
///15
@TITLE BSC07.11.10(1,11)
@COL 1S-2R-3F
@FLOW 1-2-3
@BOX 1.0
PUT.KIND (KIND)
@BOX 2.0
PUT KIND IN STRING ARRAY
OPERAND DESCRIPTION
@BOX 3.0
END
@BOX 1.1
PROC PUT.KIND(K);
@BOX 2.1
TL.CLIT.16(%44,K);
SET.A.TYPE(%8);
TL.PL(%22,0);
SET.FIELD(0);
@BOX 3.1
END;
@END
///15
@TITLE BSC07.11.11(1,11)
@COL 1S-2R-3F
@FLOW 1-2-3
@BOX 1.0
CD.MAT.STRING.SUBS(AP)
@BOX 2.0
CODE ALL SUBSCRIPT EXPRESSIONS
IN STRING EXPRESSION
@BOX 3.0
END
@BOX 1.1
PROC CD.MAT.STRING.SUBS(AP);
@BOX 2.1
::TBC
@BOX 3.1
END
@END
///15
@TITLE BSC07.11.12(1,11)
@COL 1S-2R-3F
@FLOW 1-2-3
@BOX 1.0
SET.FIELD(N)
@BOX 2.0
PLANT CODE TO PUT ACC
IN N TH FIELD OF
CURRENTLY SELECTED STRING OPERAND
DESCRIPTION
@BOX 3.0
END
@BOX 1.1
PROC SET.FIELD(N);
@BOX 2.1
TL.PL(%62,VEC.MN+1);
TL.PL(%63,N);
TL.PL(%20,%1004);
@BOX 3.1
END;
@END
///6
@TITLE BSC07.12(1,11)
@COL 1S-2R-3F
@FLOW 1-2-3
@BOX 1.0
OUT.AS()
@BOX 2.0
PRINT OUT ANALYSIS
RECORD
@BOX 3.0
END
@BOX 1.1
PROC OUT.AS;
ADDR A;
@BOX 2.1
CAPTION(%"$L   ANALYSIS RECORD : ");
OUT.HEX(BYTE(^AS)=>A,8);
CAPTION(%"    END.AP :  ");
OUT.HEX(END.AP,4);
OUT.STACK(A,A+512);
CAPTION(%"$L  WS$L");
OUT.STACK(BYTE(^WS),BYTE(^WS)+256);
@BOX 3.1
END
@END
///17 22.JUL.83
@TITLE BSC07.13(1,11)
@COL 1S-20R-2R-17R-6T-7R-8T-19R-21T-9R-10R-18R-14T-15R-16F
@COL 22R-23R
@ROW 9-22
@FLOW 1-20-2-17-6N-7-8N-19-21N-9-10-18-14N-15-16
@FLOW 8Y-16
@FLOW 14Y-16
@FLOW 6Y-8
@FLOW 21Y-22-23-18
@BOX 1.0
CODE SUBS(ARR.PROPS,SUBS.AP)
@BOX 2.0
CODE FIRST SUBSCRIPT EXPR IN B
[07.3]
@BOX 6.0
RANGE CHECKING REQUIRED?
@BOX 7.0
PLANT RANGE CHECK
@BOX 8.0
ONE DIMENSIONAL ARRAY?
@BOX 9.0
ADD B+ NODE TO EXPR TREE
FOR SECOND SUBSCRIPT
@BOX 10.0
CODE 2ND SUBSCRIPT EXPR IN B [07.3]
@BOX 14.0
RANGE CHECKING NOT REQUIRED?
@BOX 15.0
PLANT RANGE CHECK
@BOX 16.0
END
@BOX 17.0
PLANT CODE TO DECREMENT B WITH
BOUND FROM ARRAY DESC
@BOX 18.0
PLANT CODE TO DECREMENT B WITH
BOUND FROM ARRAY DESC
@BOX 19.0
MULTIPLY B BY SIZEFROM
ARRAY DESC
@BOX 20.0
NOTE IF PARAMETRIC ARRAY
GET MUTL NAMES OF SELECT VARIABLES FOR
DIMENSION SIZES AND BOUNDS
@BOX 21.0
2ND SUBSCRIPT COMPATIBLE WITH
B ARITHMETIC?
@BOX 22.0
CODE 2ND SUBSCRIPT EXPR IN B
[07.3]
@BOX 23.0
PLANT B + STACK
@BOX 1.1
PROC CODE.SUBS (P.ID,AP);
$IN MN;
$IN N,P,BND,E;
SELECT NLIST[P.ID];
@BOX 2.1
CODE.EXPR(AS[AP+1],B.INT ->> 3 ! %100);
@BOX 6.1
::TBC
@BOX 7.1
::TBC
@BOX 8.1
IF AS[AP] = 1
@BOX 9.1
B.INT <<- 8 => AS[END.AP];
B.AP => AS[END.AP+2];
AS[AP+2] => AS[END.AP+3];
4 +> END.AP;
@BOX 10.1
CODE.EXPR(END.AP-4,B.INT ->> 3 ! %100);
@BOX 14.1
::TBC
@BOX 15.1
::TBC
@BOX 16.1
END;
@BOX 17.1
TL.PL(%62,MN);
TL.PL(%09,%1004);
@BOX 18.1
TL.PL(%62,MN + 2);
TL.PL(%09,%1004);
@BOX 19.1
TL.PL(%62,MN + 3);
TL.PL(%0B,%1004);
@BOX 20.1
ARRAYS[DETAIL] => MN;
@BOX 21.1
IF AS[AP+2] ->> 11 => E & %18 /= 8 OR
   E & %1F > BINT
@BOX 22.1
CODE.EXPR(AS[AP+2],B.INT ->> 3 ! %100);
@BOX 23.1
TL.PL(%08,%1003);
@END
///7
@TITLE BSC07.14(1,11)
@COL 1S-2T-3R-4R-5F
@COL 6R
@ROW 3-6
@FLOW 1-2N-3-4-5
@FLOW 2Y-6-5
@BOX 1.0
GET.TEMP(TYPE,DIM)
P1 specifies TYPE see NLIST.E
    -1 means select variable
P2 0-scalar, > 1 array
@BOX 2.0
SCAN LIST OF CURRENT TEMPS
TEMPORARY AVAILABLE?
@BOX 3.0
DECLARE TEMP VARIABLE TO MUTL
@BOX 4.0
ADD TO LIST OF TEMPORARIES
@BOX 5.0
END
@BOX 6.0
GET ITS MUTL NAME
@BOX 1.1
PROC GET.TEMP(T,D);
$IN I,F;
@BOX 2.1
-1 => I => F;
WHILE F<0 AND 1+>I =< LAST.T DO
   IF TYP OF TEMP.T[I] = T AND
      DIM OF TEMP.T[I] = D THEN
         0 => F;
   FI
OD
IF F = 0
@BOX 3.1
IF T /= -1 THEN
   TL.S.DECL(NIL,T,D);
ELSE
   TL.SELECT.VAR();
FI
@BOX 4.1
SELECT TEMP.T[1+LAST.T]; ::TEMP FRIG TO FORCE UNIQUE ALLOCATION
%80 !T => TYP;
D => DIM;
1 +> LAST.MN => TL.N => GET.TEMP;
@BOX 5.1
END
@BOX 6.1
TL.N OF TEMP.T[I] => GET.TEMP;
@END
///7
@TITLE BSC07.15(1,11)
@COL 1S-2R-3R-4F
@FLOW 1-2-3-4
@BOX 1.0
INIT.STAT.7
@BOX 2.0
RESET A,B,T INFO
RESET CURRENT A TYPE
RESET EXPR ANALYSIS RECORD
@BOX 3.0
MAKE AVAILABLE ALL TEMP
VARIABLES
@BOX 4.0
END
@BOX 1.1
PROC INIT.STAT.7;
$IN I;
@BOX 2.1
-1 => A.AP => B.AP => T.AP;
-1 => CUR.A.TYPE;
1 => AP => WP => END.AP;
@BOX 3.1
FOR I < LAST.T+1 DO
   %7F & TYP OF TEMP.T[I]
OD
@BOX 4.1
END;
@END
///14
@TITLE BSC07.16(1,11)
@COL 1S-2R-3C-4R-5C-6R-7F
@COL 8C-9R
@ROW 3-8
@FLOW 1-2
@FLOW 3-4-7
@FLOW 5-6-7
@FLOW 8-9-7
@BOX 1.0
DECL ARITH CONST(CONSTANT,TYPE)
@BOX 2.0
SWITCH ON TYPE
@BOX 3.0
REAL 32 BIT
@BOX 4.0
DECLARE REAL CONSTANT
@BOX 5.0
INTEGER OR
LOGICAL
@BOX 6.0
DECLARE INTEGER CONSTANT
@BOX 7.0
END
@BOX 8.0
REAL 64 BIT
@BOX 9.0
DECLARE REAL CONSTANT
@BOX 1.1
PROC DECL.ARITH.CONST(CONST,TYP);
$RE32 R;
$LO32 L;
@BOX 2.1
IF TYP = %2, -> B3;
IF TYP = %3, -> B8;
-> B5;
@BOX 3.1
B3:;
@BOX 4.1
TL.CLIT32(%C,REAL.C OF CONST^ => R => L);
@BOX 5.1
B5:;
@BOX 6.1
TL.CLIT32(TL.TYP[TYP],INT.C OF CONST^);
@BOX 7.1
END;
@BOX 8.1
B8:;
@BOX 9.1
TL.CLIT.64(%1C,REAL.C OF CONST^);
@END
//16 21.JUL.83
@TITLE BSC07.17(1,11)
@COL 13R
@COL 1S-12T-2T-3R-4R-10R-11R-5R-6R-14T-7R-8F
@COL 15T-9R
@ROW 15-3
@ROW 13-3
@ROW 5-9
@FLOW 1-12N-2N-3-4-10-11-5-6-14N-7-8
@FLOW 2Y-15N-9-8
@FLOW 12Y-13-10
@FLOW 14Y-8
@FLOW 15Y-3
@BOX 1.0
CODE.STR.EXPR(AP, ACTION)
ACTION = 0 Load string expr refn in A
       = 1 Load refn in D
       > 1 Copy string expr, Bits 0-13 of ACTION gives MUTL name of string
       Bit 14 = 0 means MUTL name of pointer to string
              = 1 means MUTL name of string
@BOX 2.0
EXPR JUST A VARIABLE, FN REFN,
ARRAY ELEMENT OR CONSTANT WITHOUT
SUBSTRING SPECIFIER
@BOX 3.0
DETERMINE NO OF OPERANDS IN
EXPRESSION [07.29]
@BOX 4.0
GET TEMPORARY STRING FOR EXPRESSION VALUE
@BOX 5.0
FOR EACH OPERAND IN EXPRESSION
CODE REFN TO IT AND SET UP STRING OPERAND
DESCRIPTOR IN CONCATENATION VECTOR
[07.30]
@BOX 6.0
PLANT CALL TO CONCATENATE STRING OPERANDS
@BOX 7.0
PLANT CODE TO LOAD REFN TO RESULT STRING
@BOX 8.0
END
@BOX 9.0
PLANT CODE TO LOAD REFN TO STRING
[BSC07.23]
@BOX 10.0
GET TEMPORARY FOR CONCATENATION VECTOR
@BOX 11.0
SET UP STRING ASSIGN OPERAND DESCRIPTOR IN
CONCATENATION VECTOR
@BOX 12.0
COPY REQUESTED ?
@BOX 13.0
DETERMINE NO OF OPERANDS
IN EXPRESSION [07.29]
@BOX 14.0
COPY REQUESTED ?
@BOX 15.0
FN REFN AND REFN IN D REQUESTED
@BOX 1.1
PROC CODE.STR.EXPR(AP, CY);
$IN N, MN,TN,FN,T;
@BOX 2.1
IF AS[AP] & %28F => T >= %80 < %82 OR T = %87 OR T = %89
@BOX 3.1
CNT.STR.OPNDS(AP) => N;
@BOX 4.1
GET.TEMP(%80,DEF.STR.Z+1) => MN;
%21 => FN;
@BOX 5.1
CODE.STR.OPNDS(TN, 1, AP);
@BOX 6.1
BEGIN
DATAVEC CD.SEQ($LO16)
%48  %C02C
%46  %8012
%21  %800E
%6000
%46  %44
%22  %8009
%6000
%22  %8003
%6000
%A000
END;
TN => CD.MN.0;
N => G.LIT.16.0;
PL.CD.SEQ(^CD.SEQ);
END;
@BOX 7.1
%61 => T;
IF CY = 0 THEN
   %21 => T;
   TL.PL(%46,%83);
FI
TL.PL(T,MN);
@BOX 8.1
END
@BOX 9.1
PLANT.STR(CY, 0, AP, 0);
@BOX 10.1
GET.TEMP(STR.N,N+1) => TN;
@BOX 11.1
BEGIN
DATAVEC CD.SEQ($LO16)
%61  %8010
%02 %8008
%64 %0
%63  %0
%20  %1004
%46  %44
%22  %8008
%61  %8010
%02 %8008
%64 %0
%63  %1
%20  %1004
%22 %8003
%61  %8010
%02 %8008
%64 %0
%63  %2
%20  %1004
END;
TL.PL(%46,%83);
TL.PL(FN,MN);
DEF.STR.Z => G.LIT.16.0;
TN => CD.MN.1;
PL.CD.SEQ(^CD.SEQ);
END;
@BOX 12.1
IF CY > 1
@BOX 13.1
CNT.STR.OPNDS(AP) => N;
CY & %FFF => MN;
IF CY & %4000 /= 0 THEN
   %21 => FN;
ELSE
   %22 => FN;
FI
@BOX 14.1
IF CY > 1
@BOX 15.1
IF CY = 1 AND [T = %87 OR T = %89]
@END
///14
@TITLE BSC07.18(1,11)
@COL 1S-2R-3R-4F
@FLOW 1-2-3-4
@BOX 1.0
DECL.STR.CONST(STR.LIST,INDEX)MUTLN
@BOX 2.0
DECLARE INCODE BYTE VECTOR FOR CONSTANT
@BOX 3.0
ASSIGN SIZE OF VALUE TO FIRST BYTE
@BOX 4.0
END
@BOX 5.0
@BOX 1.1
PROC DECL.STR.CONST(LIST,I);
$IN N;
@BOX 2.1
TL.S.DECL(NIL,%80,-1);
1 +> LAST.MN => DECL.STR.CONST;
@BOX 3.1
-1 => N;
WHILE LIST^[1+>N+I] /= 0 DO OD;
TL.ASS(DECL.STR.CONST,-1);
TL.C.LIT.16(%80,N);
TL.ASS.VALUE(0,1);
TL.C.LIT.S(%80,PART(LIST,I,I+N-1));
TL.ASS.VALUE(0,1);
TL.ASS.END();
@BOX 4.1
END
@END
///14
@TITLE BSC07.19(1,11)
@COL 1S-2T-3R-4R-5R-6R-8R-7F
@FLOW 1-2N-3-4-5-6-8-7
@FLOW 2Y-5
@BOX 1.0
PL.STR.COMP(STR MUTLNAME,STRING LIST, INDEX)
@BOX 2.0
STRING PREVIOUSLY COMPARED?
@BOX 3.0
DECLARE VARIABLE FOR 2 STRING OPERANDS
@BOX 4.0
SET UP STRING VARIABLE OPERAND
@BOX 5.0
SET UP STRING CONSTANT OPERAND
@BOX 6.0
PLANT CALL TO COMPARE STRING
@BOX 7.0
END
@BOX 8.0
SET AMODE TO INT 16
PLANT A COMP 0
@BOX 1.1
PROC PL.STR.COMP(MN,LIST,I);
@BOX 2.1
DEF.STR.Z => G.LIT16.0;
IF MN & %4000 /= 0
@BOX 3.1
TL.S.DECL(NIL,STR.N,2);
1 +> LAST.MN => STR.COMP.MN;
@BOX 4.1
DATAVEC CD.SEQ($LO16);
%61  %800E
%02  %800F
%64  %0
%63  %0
%46  %83
%21  %8010
%20  %1004
%46  %44
%22  %8008
%61  %800E
%02  %800F
%64  %0
%63  %1
%20  %1004
%22  %8003
%61  %800E
%02  %800F
%64  %0
%63  %2
%20  %1004
END
0 => G.LIT16.1;
STR.COMP.MN => CD.MN.0;
MN => CD.MN.1;
PL.CD.SEQ(^CD.SEQ);
@BOX 5.1
DECL.STR.CONST(LIST,I) => CD.MN.1;
1 => G.LIT.16.1;
STR.COMP.MN => CD.MN.0;
PL.CD.SEQ(^CD.SEQ);
@BOX 6.1
DATAVEC COMP.SEQ($LO16)
%46  %8012
%21  %800E
%102D
%6000
%46  %44
%22  %8009
%6000
%22  %8009
%6000
%A000
END;
PL.CD.SEQ(^COMP.SEQ);
@BOX 7.1
END
@BOX 8.1
SET.A.TYPE(%209);
TL.PL(%2F, ZERO);
@END

///12
@T BSC07.20(1,11)
@COL 10R-23R-13R
@C 1S-3R-4T-5T-6T-15T-16R-20T-7R-22T-12N
@C 14C-8F-21R
@R 5-14
@R 7-8
@R 10-7
@F 1-3-4N-5N-6N-15Y-20N-7-22N-12-4
@F 4Y-10-4
@F 5Y-23-13
@FLOW 15Y-16-4
@F 6Y-21-22Y-13-10
@F 14-8
@FLOW 20Y-23
@B 1.0
PROC REC.EXPR (TYPE) EXPR.PTR
@B 3.0
PUT INITIAL OPERATOR ON WS
SET LAST ITEM TO OPERATOR
@B 4.0
NEXT ITEM AN OPERATOR
@B 5.0
LAST ITEM AN OPERAND?
@B 6.0
NEXT ITEM A NAME?
@B 7.0
PROCESS A CONSTANT
[07.20.3]
@B 8.0
FAULTY EXPRESSION
END
@B 10.0
PROCESS OPERATOR
[07.20.1]
@B 13.0
SET ITEM TO
EXPR TERMINATOR
@B 14.0
FAULT
@BOX 15.0
ITEM NOT (?
@BOX 16.0
PROCESS PARENTHESISED
EXPRESSION [27.20.4]
@BOX 20.0
NOT A CONSTANT ?
@BOX 21.0
PROCESS A NAME
[07.20.2]
@BOX 22.0
SINGLE OPERAND EXPRESSIONS?
@BOX 23.0
RESET IPTR
@B 1.1
PROC REC.EXPR(TY);
$IN L.I, L.TYP, T, SV, OP, C, I, E.L, TAG, IND,
    NAP;
::LI 0 OPERATOR, 1 OPERAND
I.TYPE ITEM,SEP;
DATAVEC PREC($LO8)
8 4[6] 3
3  0  2  6  7  2  1  1
3
END
DATAVEC OPT($LO8)
3  0  0  2  3  3  2  2  2  2  2  3
2  2  2  2  2  2  2  2  2  2  2  0
2  0  2  2  2  3  2  2  2  2  2  0
2  0  0  2  2  3  2  2  2  2  2  0
0  0  0  0  3  3  2  2  2  2  2  0
0  0  0  0  0  3  2  2  2  2  2  0
0  0  0  0  0  0  2  2  2  2  2  0
0  0  0  0  0  0  0  2  2  2  2  0
0  0  0  0  0  0  0  0  1  0  0  0
0  0  0  0  0  0  0  0  2  2  2  0
0  0  0  0  0  0  0  0  2  0  2  0
3  4  4  4  4  3  4  4  4  4  4  3
END;
@B 3.1
0 => WS[WP] => L.I;  ::OPERATOR
-1 => WS[WP+1];
2 +> WP;
@B 4.1
LBUFF[1+>IPTR] => ITEM;
IND OF ITEM => IND;
IF TAG OF ITEM => TAG = T.OP.NON.KEY OR TAG = T.OP.KEY
@B 5.1
IF L.I = 1
@B 6.1
IF TAG > 3
@B 7.1
#BSC07.20.3
@B 8.1
MONITOR(%101E);
END;
@B 10.1
%FF &> IND;
#BSC07.20.1
@B 13.1
0 => IND;
@B 14.1
FAULT:;
@BOX 15.1
IF ITEM /= LB
@BOX 16.1
#BSC07.20.4
@BOX 20.1
IF TAG /= T.STRING /= T.CONST
@BOX 21.1
#BSC07.20.2
@BOX 22.1
IF TY & %90 /= 0
@BOX 23.1
1 -> IPTR;
@E
///8
@T BSC07.20.1(1,11)
@C 1S-2T-7R-6F
@C 9C-10R
@R 2-9
@F 1-2N-7-6
@F 2Y-10-6
@F 9-10
@B 1.0
PROCESS OPERATOR
@B 2.0
LAST ITEM AN OPERAND?
@B 6.0
END
@B 7.0
PROCESS UNARY OPERATORS
[07.20.1.2]
@B 9.0
OPERATOR SWITCH
@B 10.0
SWITCH DEPENDING ON OPERATOR
AND LAST OPERATOR ON WS
REMOVE [BSC07.20.1.1]
STACK OPERATOR [BSC07.20.1.1]
ILLEGAL USE OF SYMBOL [BSC07.20]
REMOVE UNARY PLUS [BSC07.20.1.1]
TERMINATOR [BSC07.20.1.1]
@B 1.1
@B 2.1
IF L.I = 1
@B 6.1
::END
@B 7.1
#BSC07.20.1.2
@B 9.1
OP.SWITCH:
@B 10.1
SWITCH OPT [PREC[WS[WP-3]]*12+PREC[IND]] => SV\
STACK, TERMINATOR, REMOVE,
FAULT, UNARYPLUS;
#BSC07.20.1.1
@E
///7
@T BSC07.20.1.1(1,11)
@C 1S-2C-3R-4R-5R-6C-7R-8R
@C 9C-10R-11F-12C-14R-15R
@R 2-9
@F 2-3-4-5
@F 6-7-8
@F 9-10-11
@F 12-14-15
@B 2.0
REMOVE
@B 3.0
POP OPD/OPR/OPD FROM WS
CREATE OPR NODE ON AS
@B 4.0
PUSH OPR NODE PTR TO WS
@B 5.0
OPERATOR SWITCH
@B 6.0
REMOVE UNARY PLUS
@B 7.0
REDUCE TRIPLE ON TOP OF
WS TO SINGLE OPERAND
@B 8.0
OPERATOR SWITCH
@B 9.0
STACK OPERATOR
@B 10.0
PUSH OPR ENTRY TO WS
NOTE LAST ITEM AN OPERATOR
@B 11.0
END
@B 12.0
END OF EXPR
@B 14.0
REMOVE INIT OPR ([) FROM WS
DECREASE LINE PTR
@B 15.0
EXIT - OK
@B 1.1
@B 2.1
REMOVE:
@B 3.1
WS[WP-3] => AS[AP];
WS[WP-4] => AS[AP+2];
WS[WP-1] => AS[AP+3];
WS[WP-2] => AS[AP+1];
@B 4.1
AP => WS[WP-4];
4 +> AP;
3 -> WP;
@B 5.1
-> OP.SWITCH;
@B 6.1
UNARYPLUS:
@B 7.1
WS[WP-1] => WS[WP-4];
3 -> WP;
@B 8.1
-> OP.SWITCH;
@B 9.1
STACK:
@B 10.1
IND => WS[WP];
IPTR => WS[WP+1];
2 +> WP;
0 => LI;
@B 11.1
::END
@B 12.1
TERMINATOR :
@B 14.1
3 -> WP;
WS[WP+2] => REC.EXPR;
AP => END.AP;
@B 15.1
EXIT;
@E
///7
@T BSC07.20.1.2(1,11)
@C 8R
@C 1S-2T-3T-4R-5R
@C 10R-11R-12R-13R
@R 8-4
@R 3-10
@F 1-2N-3N-4-5-12
@F 2Y-10-11-12-13
@F 3Y-8
@B 1.0
PROCESS UNARY OPERATORS
@B 2.0
OPERATOR '+', '-'?
@B 3.0
ITEM NOT NOT
@B 4.0
SET OPD TO -1
@B 5.0
SET OPERATOR TO NON-EQUIV
@B 8.0
FAULT
@B 9.0
NEXT ITEM A CONSTANT?
@B 10.0
SET OPD REQUIRED TO ZERO
@B 11.0
SET OPR TO HIGH
PRECEDENCE '+' OR '-'
@B 12.0
PUSH CONSTANT TERMINAL NODE TO AS
PUSH NODE PTR TO WS
@B 13.0
OPERATOR SWITCH
@B 1.1
@B 2.1
IF ITEM = PLUS
OR ITEM = MINUS
@B 3.1
IF ITEM /= D.NOT
@B 4.1
-1 => C;
@B 5.1
16 => OP;
@B 8.1
-> FAULT;
@B 10.1
0 => C;
@B 11.1
(IF ITEM = MINUS THEN
14 ELSE 15) => OP;
@B 12.1
%4880 => AS[AP];
C => INT.C OF CLIST[1->LAST.C];
IPTR => AS[AP+1];
LAST.C => AS[AP+2];
AP => WS[WP] +3 => AP;
1 +> WP;
@B 13.1
-> OP.SWITCH;
@E
///14
@T BSC07.20.2(1,11)
@C 1S-2R-3R-15T-4T-5R-6R-7T-8T-9R-12C
@C 11F-13T-14R
@R 5-11
@R 8-13
@R 9-14
@F 1-2-3-15N-4N-5-6-7N-8N-9-4Y-11
@F 7Y-13N-14-11
@F 13Y-12
@F 8Y-12
@F 15Y-11
@B 1.0
PROCESS A NAME
@BOX 2.0
IF NAME HAS PARAM LIST ALLOW REM
GET NLIST INDEX FOR IDENTIFIER
@B 3.0
CREATE A 3 WORD TERMINAL NODE ON AS
PUSH NODE^ TO WS
NOTE LAST ITEM PROCESSED = OPERAND
@B 4.0
NEXT ITEM /= '('
@B 5.0
GET NEXT ITEM
ALLOCATE 3 EXTRA WORDS FOR
TERMINAL NODE IF PROCESSING FIRST LIST
@B 6.0
PROCESS AN EXPR LIST[07.20.2.1]
@B 7.0
UPDATE NODE INFO FOR
LIST TYPE SUBSTRING
EXPR LIST
@B 8.0
SUBSCRIPTS OR ARGUMENTS
ALREADY INPUT ?
@B 9.0
COPY EXPR COUNT AND EXPR A/R TO AS
@B 11.0
END
@BOX 12.0
EXPR FAULT
[????]
@B 13.0
EXPR CNT /= 2 ?
@B 14.0
COPY BOTH EXPR
PTRS TO AS
@BOX 15.0
SINGLE SIMPLE VARIABLE EXPRESSION?
@B 1.1
@B 2.1
IF TY & %80 = 0 AND LBUFF[IPTR +1] = LB THEN
   %DF &> TAG OF ITEM;
FI
GETN(ITEM) => IND;
@B 3.1
IF IND >= 0 THEN   ::RP
   %8F => AS[AP];
ELSE
   %CF => AS[AP];
   0 -:> IND;
FI
IPTR => AS[AP+1];
IND => AS[AP+2];
AP => NAP => WS[WP] + 3 => AP;
1 +> WP;
1 => L.I;
@B 4.1
IF LBUFF[IPTR+1] /= LB
@B 5.1
IF NAP+ 3 = AP THEN
3 +> AP;
FI
1 +> IPTR;
@B 6.1
#BSC07.20.2.1
@B 7.1
AS[NAP] => T ! L.TYP => AS[NAP];
IF L.TYP = %200
@B 8.1
IF T & %100 /= 0
@B 9.1
AP => AS[NAP+3];
EL => AS[AP];
1 + AP => T + EL => AP;
WP - EL => WP;
WHILE 1 -> EL >= 0 DO
WS[WP+EL] => AS[T+EL] OD;
@B 11.1
::END
@B 12.1
-> FAULT;
@B 13.1
IF EL /= 2
@B 14.1
WS[WP-2] => AS[NAP + 4];
WS [WP-1] => AS[NAP + 5];
2 -> WP;
@BOX 15.1
IF TY & %80 /= 0
@E
//14
@T BSC07.20.2.1(1,11)
@C 15R
@C 1S-2R-3T-4R-21T-22T-16R-7R-8T-18T-5T-19R-20R-14F
@COL 23R
@R 7-23
@R 15-7
@F 1-2-3N-4-21N-22N-16-7-8N-18Y-14
@F 18N-5N-19-4
@F 3Y-15-14
@F 8Y-4
@F 5Y-20
@FLOW 21Y-16
@FLOW 22Y-23
@B 1.0
PROCESS AN EXPR LIST
@B 2.0
NOTE LIST TYPE AS SUBSCRIPT/ARGUMENT
SET EXPR CNT = ZERO
@B 3.0
NEXT ITEM ')'
@B 4.0
INCR EXPR CNT
@B 5.0
ITEM /= ':'
@B 7.0
SAVE EXPR PTR ON WS
@B 8.0
NEXT ITEM ',' ?
@B 14.0
END
@B 15.0
GET NEXT ITEM
@B 16.0
RECOGNISE EXPR
NOTE EXPR NODE AS CHANNEL EXPR
IF NECESSARY
@B 18.0
ITEM = ) ?
@B 19.0
NOTE LIST TYPE
AS SUBSTRING
@BOX 20.0
FAULT
@BOX 21.0
NEXT SYMBOL NOT #
@BOX 22.0
NOT SUBROUTINE CALL
@BOX 23.0
FAULT
@B 1.1
@B 2.1
0 => EL;
%100 => L.TYP;
@B 3.1
IF LBUFF[IPTR+1] => ITEM = RB
@B 4.1
1 +> EL;
@B 5.1
IF SEP /=COLON
@B 7.1
1 +> WP;
@B 8.1
IF LBUFF[1+>IPTR] => SEP = COMMA
@B 14.1
::END
@B 15.1
1 +> IPTR;
@B 16.1
T !> AS[REC.EXPR(0) => WS[WP]];
@B 18.1
IF SEP = RB
@B 19.1
%200 => L.TYP;
@B 20.1
-> FAULT;
@BOX 21.1
0 => T;
IF LBUFF[1 + IPTR] /= HASH.D
@BOX 22.1
1 +> IPTR;
%40 => T;
IF TY & %20 = 0
@BOX 23.1
-> FAULT;
@E
///17 22.JUL.83
@TITLE BSC07.20.3(1,11)
@COL 10R
@COL 1S-5T-6T-7R-8R-2R-3R-4F
@COL 9R
@ROW 10-8-9
@FLOW 1-5N-6N-7-8-2-3-4
@FLOW 5Y-10-2
@FLOW 6Y-9-2
@B 1.0
PROCESS A CONSTANT
@B 2.0
PUSH TERMINAL NODE TO AS
PUSH NODE PTR TO WS
@B 3.0
NOTE LAST ITEM PROCESSED = OPD
@B 4.0
END
@BOX 5.0
STRING CONSTANT
@BOX 6.0
NOT INTEGER CONSTANT WITH
REAL BINDING
@BOX 7.0
CONVERT CONSTANT TO REAL
@BOX 8.0
SET NODE
@BOX 9.0
SET NODE
@B 1.1
CONSTANT :
@B 2.1
I=> AS[AP+2];
IPTR => AS[AP+1];
AP => WS[WP];
3 +> AP;
1 +> WP;
@B 3.1
1 => LI;
@B 4.1
::END
@BOX 5.1
IND OF LBUFF[IPTR] => I;
IF TAG OF LBUFF[IPTR] = TSTRING
@BOX 6.1
IF ST OF LBUFF[IPTR] => C & %C7 /= %40
@BOX 7.1
INT.C OF CLIST[I] => REAL.C OF CLIST[I];
@BOX 8.1
B.RE <<- 8 ! %80 => AS[AP];
@BOX 9.1
C & %F8 <<- 8 ! %80 => AS[AP];
@BOX 10.1
%C080 => AS[AP];
@E
//15
@TITLE BSC07.20.4(1,11)
@COL 1S-2T-3R-4T-5T-6R-7F
@COL 8C-9C
@ROW 3-8
@ROW 6-9
@FLOW 1-2N-3-4N-5N-6-7
@FLOW 2Y-8
@FLOW 4Y-9
@FLOW 5Y-7
@BOX 1.0
PROCESS PARENTHESISED EXPRESSION
@BOX 2.0
SINGLE OPERAND ONLY ALLOWED
@BOX 3.0
RECOGNISE NESTED EXPRESSION
PUSH EXPR PTR ON WS
NOTE ITEM KIND IS OPERAND
@BOX 4.0
NEXT ITEM NOT )
@BOX 5.0
NOT IN A STRING ARRAY EXPRESSION
@BOX 6.0
MARK BRACKETED EXPR AS A
PARENTHESISED EXPR IN A STRING ARRAY EXPR
@BOX 7.0
END
@BOX 8.0
FAULT
@BOX 9.0
FAULT
@BOX 1.1
::27.20.4
@BOX 2.1
IF TY & %90 /= 0
@BOX 3.1
REC.EXPR(0) => WS[WP] => T;
1 +> WP;
1 => LI;
@BOX 4.1
IF LBUFF[1 +> IPTR] /= RB
@BOX 5.1
IF TY & %F800 /= %C000
@BOX 6.1
%400 !> AS[T];
@BOX 7.1
::END
@BOX 8.1
-> FAULT;
@BOX 9.1
-> FAULT;
@END
///15
@TITLE BSC07.21(1,11)
@COL 11C-20T-21R-12T-13R-14R-17T-18T-19R
@COL 1S-2T-3R-4R-5T-6T-7R-8T-9T-10F
@COL 16R-15C
@ROW 11-6
@ROW 12-7
@ROW 9-17
@ROW 3-16
@ROW 10-15
@FLOW 1-2N-3-4-5N-6N-7-8N-9N-10
@FLOW 2Y-16-8Y-17N-18N-19
@FLOW 5Y-11
@FLOW 6Y-20Y-12N-13-8
@FLOW 9Y-15
@FLOW 12Y-14-8
@FLOW 17Y-10
@FLOW 18Y-10
@FLOW 20N-21
@BOX 1.0
REDUCE EXPRESSION(EXPR NODE PTR,TYPE)
@BOX 2.0
TERMINAL NODE?
@BOX 3.0
REDUCE EXPR FOR L.H.NODE
[07.21]
@BOX 4.0
REDUCE EXPR FOR R.H.NODE
[07.21]
@BOX 5.0
NODE TYPES NOT COMPATIBLE?
@BOX 6.0
GET OPERATOR
EITHER OPERAND A TERMINAL
ARRAY OPERAND OR AN
ARRAY EXPRESSION?
@BOX 7.0
PROCESS EXPR NODE
[07.21.3]
@BOX 8.0
NOT A CHANNEL EXPR?
@BOX 9.0
INVALID NODE FOR
CHANNEL EXPR?
@BOX 10.0
END
@BOX 11.0
FAULT
@BOX 12.0
CONCATENATION OPERATOR?
@BOX 13.0
PROCESS NUMERIC
ARRAY EXPR NODE
[07.21.2]
@BOX 14.0
PROCESS STRING ARRAY EXPR NODE
[07.21.4]
@BOX 15.0
FAULT
@BOX 16.0
TYPE NODE
[07.21.1]
@BOX 17.0
NOT A PARENTHESISED EXPR IN
A STRING ARRAY EXPRESSION
@BOX 18.0
NODE A VALID STRING EXPRESSION
@BOX 19.0
FAULT
@BOX 20.0
ARRAY EXPRESSION EXPECTED?
@BOX 21.0
FAULT
@BOX 1.1
PROC REDUCE.EXPR(AP,TY);
PSPEC TYPE.NODE($IN,$IN);
#BSC07.21.1
$IN T,HT,OP,N,S0,S,J;
$IN N0, LAP, RAP, LH0, RH0, R, RTY, LTY, F.PTR;
DATAVEC TYPE.CH($LO8)
0  0  %FF  %FF
0  1  %FF  %FF
%FF  %FF  %02 %FF
%FF  %FF  %FF  3
END;
@BOX 2.1
AS[AP + 1] => F.PTR;
IF AS[AP] => N0 & %80 /= 0
@BOX 3.1
REDUCE.EXPR(AS[AP+2] => LAP,TY);
@BOX 4.1
REDUCE.EXPR(AS[AP+3] => RAP,TY);
@BOX 5.1
AS[LAP] => LH0 ->> 14 & 3 => LTY;
AS[RAP] => RH0 ->> 14 & 3 => RTY;
IF TYPE.CH[LTY * 4 + RTY] => R = %FF
@BOX 6.1
N0 & %3F => OP;
IF [LH0 & %80 => HT /=0]
      AND [LH0 & %8F => T = %83 OR T = %84 OR T = %85]
   OR [HT = 0 AND LH0 & %200 /= 0]
   OR [RH0 & %80 => HT /=0
      AND [RH0 & %8F => T = %83 OR T = %84 OR T = %85]]
   OR [HT = 0 AND LH0 & %200 /=0]
@BOX 7.1
#BSC07.21.3
@BOX 8.1
IF AS[AP] => N0 & %40 = 0
@BOX 9.1
IF N0 ->> 14 & 3 > 1
   OR [N0 & %80 = 0 AND N0 & %300 /=0]
   OR [N0 & %80 = 0 AND N0 & %F > 2 < 7]
@BOX 10.1
END;
@BOX 11.1
MONITOR.P(%101F,FPTR);
@BOX 12.1
IF OP = 8
@BOX 13.1
#BSC07.21.2
@BOX 14.1
#BSC07.21.4
@BOX 15.1
MONITOR.P(%1020,FPTR);
@BOX 16.1
TYPE.NODE(AP,TY);
@BOX 17.1
IF N0 & %400 = 0
@BOX 18.1
IF N0 & %C000 = %C000 AND
   [N0 & %380 = 0 OR
      [N0 & %80 /=0 AND[N0 & %F => T < 3 OR T = 7 OR T = 9]]]
@BOX 19.1
MONITOR.P(%1021,FPTR);
@BOX 20.1
IF TY & %FB /= 0
@BOX 21.1
MONITOR.P(%1022,FPTR);
@END
///4
@TITLE BSC07.21.1(1,11)
@COL 8R
@COL 1S-2T-3T-4R-5T-6R-11T-7T-9R-10F
@COL 12R-13R
@ROW 7-12
@FLOW 1-2N-3N-4-5N-6-11N-7N-9-10
@FLOW 2Y-10
@FLOW 3Y-5
@FLOW 5Y-11
@FLOW 11Y-12-13-10
@FLOW 7Y-8-10
@ROW 8-9
@B 1.0
TYPE NODE (AP,TYPE)
Bit 5=1 of P2 Subroutine call
@B 2.0
GET IPTR FOR NODE
CONSTANT ?
@B 3.0
NO EXPR LIST ?
@B 4.0
REDUCE EXPR IN LIST
@B 5.0
NO SUBSTRING SPECIFIED ?
@B 6.0
REDUCE SUBSTRING SPECIFIER
EXPRESSIONS [07.21]
@B 7.0
NAME WITHOUT SUBSCRIPTS
OR ARGUMENTS ?
@B 8.0
PROCESS NAME WITHOUT
SUBSCRIPTS OR ARGS
[07.21.1.1]
@B 9.0
PROCESS NAME WITH
SUBSCRIPTS OR ARGS
[07.21.1.2]
@B 10.0
END
@BOX 11.0
GET PROPERTY INDEX
NAME UNDEFINED AND A
CALL OPERAND
@BOX 12.0
UPDATE PROPS FOR
IMPLICIT SUBROUTINE
@BOX 13.0
PROCESS FN/SUBR REFN
[BSC07.21.1.3]
@B 1.1
PROC TYPE.NODE (AP,TY);
$IN N, S0, N0;
PSPEC PROC.REFN($IN,$IN,$IN);
#BSC07.21.1.3
$IN PI, PK, I, Z, F.I.PTR, TT, ID, F, J;
$IN B.I.D, B.K;
@B 2.1
AS [AP + 1] => F.I.PTR;
IF AS [AP] => N0 & %F = 0
@B 3.1
IF N0 & %100 = 0
@B 4.1
AS [AS [AP+ 3] => I] => Z;
WHILE 1 -> Z >= 0 DO
   REDUCE.EXPR (AS [I+ Z + 1],0)
OD;
@B 5.1
IF N0 & %200 = 0
@B 6.1
REDUCE.EXPR (AS [AP+4],0);
REDUCE.EXPR (AS [AP + 5],0);
@B 7.1
IF N0 & %100 = 0
@B 8.1
#BSC07.21.1.1
@B 9.1
#BSC07.21.1.2
@B 10.1
END
@BOX 11.1
SELECT NLIST[AS[AP+2] => ID];
IF K = KUNDEF AND TY & %20 /= 0
@BOX 12.1
%400 !> DETAIL1;
KSUB => K;
@BOX 13.1
PROC.REFN(ID,AP,TY);
@END
//16
@TITLE BSC07.21.1.1(1,11)
@COL 1S-2T-3T-4T-5T-6C-7T-22T-23T-24T-25R-26R-8R-9R-10F-11R
@COL 12T-13T-18T-19T-14R-20T-21R-15R-16T-17R
@ROW 3-12
@ROW 8-14
@FLOW 1-2N-3N-4N-5N-6
@FLOW 2Y-12N-13N-18N-19N-14-9-10
@FLOW 12Y-20Y-15-16N-17-10
@FLOW 16Y-11
@FLOW 13Y-20
@FLOW 3Y-16
@FLOW 4Y-9
@FLOW 5Y-7N-22N-23N-24Y-8-10
@FLOW 7Y-11
@FLOW 18Y-14
@FLOW 19Y-20N-21
@FLOW 22Y-8
@FLOW 23Y-26
@FLOW 24N-25
@BOX 1.0
PROCESS NAME WITHOUT
PARAMETERS/SUBSCRIPT LIST
@BOX 2.0
NAME NOT DEFINED?
@BOX 3.0
NAME A VARIABLE?
@BOX 4.0
NAME A PROCEDURE?
@BOX 5.0
NAME AN ARRAY?
@BOX 6.0
FAULT
@BOX 7.0
ILLEGAL USE OF SUBSTRING
@BOX 8.0
UPDATE TYPE AND KIND OF NODE FOR AN
ARRAY
@BOX 9.0
PROCESS FN/SUBR REFN
[BSC07.21.1.3]
@BOX 10.0
END
@BOX 11.0
FAULT
@BOX 12.0
NAME NOT A BASIC
SUPPLIED FN NOR A
ARRAY FUNCTION OR ARRAY VALUE
@BOX 13.0
BUILT IN FN HAS
PARAMETERS
@BOX 14.0
NOTE BUILT IN FN ID
@BOX 15.0
DECLARE IMPLICIT
VARIABLE
@BOX 16.0
ILLEGAL USE OF
SUBSTRING
@BOX 17.0
UPDATE NODE WITH
TYPE AND KIND
@BOX 18.0
NEITHER ARRAY FUNCTION
NOR ARRAY VALUE
@BOX 19.0
NOT AN ARRAY EXPR
@BOX 20.0
NAME ALLOWED AS A SIMPLE
VARIABLE?
@BOX 21.0
FAULT
@BOX 22.0
NOT IN AN ARRAY EXPRESSION?
@BOX 23.0
ARRAY HAS INCORRECT NUMBER OF DIMENSIONS
@BOX 24.0
ARRAY OF CORRECT TYPE?
@BOX 25.0
FAULT
@BOX 26.0
FAULT
@BOX 1.1
::BSC07.21.1.1
@BOX 2.1
IF K = KUNDEF
@BOX 3.1
IF K = KVAR
@BOX 4.1
IF K = KSUB OR K = KFN
@BOX 5.1
IF K = KMAT OR K = KVEC
@BOX 6.1
MONITOR.P(%1023,F.I.PTR);
@BOX 7.1
IF N0 & %200 /= 0 AND T & %F8 /= %C0 AND TY & %300 = 0
@BOX 8.1
T <<- 8 ! 3 !(N0 & %07F0) => AS[AP];
@BOX 9.1
PROC.REFN(ID,AP, TY);
@BOX 10.1
::END
@BOX 11.1
MONITOR.P(%1024,F.I.PTR);
@BOX 12.1
IF SUPPLIED.FN(ID) => B.ID < 0
@BOX 13.1
IF BFN.ARG[BFN.ARG.I[BFN.SEL[B.ID]]+1] /= 0
@BOX 14.1
B.ID ! %8000 => ID;
@BOX 15.1
IMPL.S.VAR(ID);
@BOX 16.1
IF N0 & %200 /= 0 AND
   T & %C0 /= %C0
@BOX 17.1
T & %F8 <<- 8 ! 1 ! (N0 & %07F0) => AS[AP];
@BOX 18.1
IF BFN.K[B.ID] => B.K /= 4 /= 5
@BOX 19.1
IF TY & %300 = 0
@BOX 20.1
IF N0 & %10 = 0
@BOX 21.1
MONITOR.P(%1014,F.I.PTR);
@BOX 22.1
IF TY & %F800 = 0
@BOX 23.1
IF TY ->> 8 & %3 /= K
@BOX 24.1
IF TY ->> 8 & %F8 = T
@BOX 25.1
MONITOR(%106C);
@BOX 26.1
MONITOR(%106D);
@END
//15
@T BSC07.21.1.2(1,11)
@COL 8T-16T-17R-9T-10R-11R-12R
@COL 1S-2T-3T-4T-5R-6R-7F
@COL 13T-14R-15R
@ROW 3-13
@ROW 8-4
@FLOW 1-2N-3N-4N-5
@FLOW 2Y-13N-14-6-7
@FLOW 13Y-15
@FLOW 3Y-8N-16Y-9N-10-7
@FLOW 8Y-12
@FLOW 9Y-11
@FLOW 4Y-6
@FLOW 16Y-17
@BOX 1.0
PROCESS NAME WITH
PARAMETER/SUBSCRIPT LIST
@BOX 2.0
NAME NOT DEFINED?
@BOX 3.0
ARRAY
@BOX 4.0
FUNCTION OR SUBROUTINE
@BOX 5.0
FAULT
@BOX 6.0
PROCESS FN SUBR REFN[07.21.1.3]
@BOX 7.0
END
@BOX 8.0
INCORRECT NO. OF
SUBSCRIPTS IN LIST
@BOX 9.0
INCORRECT USE OF
SUBSTRING
@BOX 10.0
UPDATE NODE FOR
ARRAY ELEMENT
@BOX 11.0
FAULT
@BOX 12.0
FAULT
@BOX 13.0
NAME NOT A BASIC
BUILT IN FUNCTION
@BOX 14.0
NOTE BUILT IN FN.ID
@BOX 15.0
FAULT
@BOX 16.0
SUBSCRIPT EXPR OF CORRECT TYPE
@BOX 17.0
FAULT
@BOX 1.1
::BSC07.21.1.2
@BOX 2.1
IF K = KUNDEF
@BOX 3.1
IF K = KMAT OR K = KVEC
@BOX 4.1
IF K = KSUB OR K = KFN
@BOX 5.1
MONITOR.P(%1023,F.I.PTR);
@BOX 6.1
PROC.REFN(ID,AP,TY);
@BOX 7.1
::END
@BOX 8.1
AS[AS[AP+3]] => N;
IF [K = KVEC AND N /= 1] OR
   [K = KMAT AND N /= 2]
@BOX 9.1
IF T & %18 /= %18 AND N0 & %200 /= 0
@BOX 10.1
T <<- 8 ! 2 ! (N0 & %07F0) => AS[AP];
@BOX 11.1
MONITOR.P(%1024,F.I.PTR);
@BOX 12.1
MONITOR.P(%1025,F.I.PTR);
@BOX 13.1
IF SUPPLIED.FN(ID) => B.ID < 0
@BOX 14.1
B.ID ! %8000 => ID;
@BOX 15.1
MONITOR.P(%1023,F.I.PTR);
@BOX 16.1
0 => F;
FOR J < N DO
   IF AS[I+J+1]  => S0 & %8000 /=0  OR
      [S0 & %80 /=0 AND S0 & %F > 2 /= 7 /= 9]  OR
      [S0 & %80 = 0 AND S0 & %300 /=0] THEN
         1 => F;
   FI
OD
IF F=0
@BOX 17.1
MONITOR.P(%1026,F.I.PTR);
@END
///15
@TITLE BSC07.21.1.3(1,11)
@COL 1S-11R-2T-6R-3T-4R-14R-12T-5T-7F
@COL 15T-16R-8R-17T-9R-18R-13R-10R
@COL 19T-20T-21N
@ROW 19-16
@ROW 15-6
@ROW 7-10
@FLOW 1-11-2N-6-3N-4-7
@FLOW 2Y-15N-16-8-17N-9-5Y-10
@FLOW 12N-5-7
@FLOW 3Y-14-12Y-13
@FLOW 15Y-19N-20N-21-9
@FLOW 17Y-18
@FLOW 19Y-9
@FLOW 20Y-18
@BOX 1.0
PROCESS FUNCTION/SUBROUTINE REFN
PROC.REFN(ID,NODE.AP,KIND)
ID : Bit 15 = 0 Bits 0-14 give procedure namelist ID
     Bit 15 = 1 Bits 0-14 give Basic Supplied ID
KIND context information of IN.EXPR
@BOX 2.0
BASIC SUPPLIED FUNCTION?
@BOX 3.0
SPEC ALREADY DEFINED?
@BOX 4.0
DECLARE IMPLICIT PROC SPEC [BSC04]
@BOX 5.0
CHECK ARG LIST FAULTY?
@BOX 6.0
UPDATE NODE FOR PROC REFN
@BOX 7.0
END
@BOX 8.0
EXAMINE PARAMETER LIST TO
SELECT APPROPRIATE VERSION OF
SUPPLIED FUNCTION
@BOX 9.0
OBTAIN SPECIFIC SUPPLIED FUNCTION SPEC
UPDATE NODE WITH SPECIFIC INFORMATION
@BOX 10.0
FAULT
@BOX 11.0
CREATE SPECIFICATION VECTOR OF CALL
@BOX 12.0
INCORRECT NUMBER OF PARAMETERS ?
@BOX 13.0
FAULT
@BOX 14.0
GET SPECIFICATION VECTOR
@BOX 15.0
SELECT FIRST VARIANT OF BUILT IN FN
NO PARAMETERS IN REFERENCE
@BOX 16.0
DETERMINE PRINCIPLE PARAMETER TYPE
@BOX 17.0
NO SUITABLE VARIANT OF BUILT IN FN
@BOX 18.0
FAULT
@BOX 19.0
FUNCTION RESULT NOT AN ARRAY?
@BOX 20.0
SELECT VARIANT WITH REQUIRED RESULT
NO SUITABLE VARIANT?
@BOX 1.1
PROC PROC.REFN (ID, AP, KIND);
ADDR[$LO8] PR.PARS;
$IN N0,PR.I,PT,PR.PT,F,I,N,PK,PAR.AP,P0,S,F.PT,S.ID,PT2,RT,P,J;
$LO8[256] PARS;
KIND ->> 8 => KIND;
@BOX 2.1
IF ID & %8000 /= 0
@BOX 3.1
IF DETAIL OF NLIST[ID] /= 0
@BOX 4.1
T OF NLIST[ID] => PARS[0];
DECL.TL.PSPEC(ID,^PARS);
@BOX 5.1
0 => F;
-1 => I;
WHILE 1+>I < N AND F=0 DO
   IF [PARS[I+2] => PT = PR.PARS^[PR.I+I+2] => J & %FB => PR.PT
      OR [PT ! PR.PT & 3 = 0 AND
         PT & %C0 < %80 AND PR.PT & %C0 < %80]
      OR [PR.PT = 1 AND PT & 3 = 1]
      OR [PR.PT = 2 AND PT & 3 = 2] ]
      AND [ J & 4 = 0 OR [J & 4 /= 0 AND AS[AS[PAR.AP+I+1]] & %38F = %81]] THEN
      ::NO IF CODE
   ELSE
      AS[AS[PAR.AP+I+1]+1] => F;
FI
OD
IF F /= 0
@BOX 6.1
T OF NLIST[ID] <<- 8 ! (AS[AP] & %07F0)
   ! K OF NLIST[ID] => AS[AP];
@BOX 7.1
END;
@BOX 8.1
-1 => S.ID;
WHILE S < F AND S.ID < 0 DO
   IF BFN.ARG[BFN.ARG.I[S] => I + 1] = N THEN
      IF BFN.ARG[I+2] & %FB => FPT & 3 = 0 THEN
         IF FPT & %C7 = PT & %C7 THEN
            IF PT & %38 =< FPT & %38 OR S+1 = F OR BFN.ARG [BFN.ARG.I[S+1]+1] /=
 N THEN
               S => S.ID;
            FI
         ELSE
            IF FPT & %C7 = 0 AND PT & %C7 = %40
                  OR FPT & %C7 = %40 AND PT & %C7 = 0 AND [S+1 = F OR BFN.ARG [B
FN.ARG.I [S+1]+1]/= N] THEN
               S => S.ID
            FI
         FI
   ELSE
      IF FPT = PT OR [FPT = 1 AND PT & 3 = 1] OR [FPT = 2 AND PT & 3 = 2] THEN
         S => S.ID
      FI
FI
      FI
IF BFN.ARG[I] => RT & 3 /= 0 AND RT /= KIND THEN
   -1 => S.ID;
FI
   1 +> S;
OD;
@BOX 9.1
^BFN.ARG => PR.PARS;
BFN.ARG.I[S.ID] => PR.I;
S.ID => AS[AP+2];
BFN.ARG[PR.I] & %F8 <<- 8 ! (AS[AP] & %07F0) ! (BFN.K[ID] & %F) => AS[AP];
@BOX 10.1
MONITOR.P(%1051,F);
@BOX 11.1
IF AS[AP] => N0 & %100 = 0 THEN
   0 => N;
ELSE
   AS[AS[AP+3] => PAR.AP] => N;
   FOR I < N DO
      IF AS[AS[PAR.AP+1+I] => P] => P0 & %40 /= 0 THEN
         3 => PK;
      ELSE
         P0 ->> 8 & %F8 => PK;
         IF P0 & %8F = %83 THEN
            K OF NLIST[AS[P+2]] !> PK;
         FI
      FI
      PK => PARS[2+I];
   OD
FI;
N => PARS[1];
@BOX 12.1
IF PARS[1] => N /= PR.PARS^[PR.I+1]
@BOX 13.1
MONITOR.P(%1050, AS[AP+1]);
@BOX 14.1
^PARAMS => PR.PARS;
DETAIL OF NLIST[ID] => PR.I;
@BOX 15.1
BFN.SEL[%7FFF &> ID] => S.ID  => S;
BFN.SEL[ID+1] => F;
IF N = 0
@BOX 16.1
PARS[2] => PT;
IF BFN.K[ID] & %80 /= 0 AND N > 1 THEN
   IF[PT & %C7 = 0 OR PT & %C7 = %40]
      AND[PAR.S[3] => PT2 & %C7 = 0 OR PT2 & %C7 = %40] THEN
      ::BOTH NUMERIC
         IF PT & %C0 = PT2 & %C0 THEN
            IF PT2 > PT THEN
               PT2 => PT;
            FI
         ELSE
            IF PT2 & %C0 = 0 THEN
               PT2 => PT;
            FI
         FI
      FI
   FI
@BOX 17.1
IF S.ID < 0
@BOX 18.1
MONITOR.P(%1052,AS[AP+1]);
@BOX 19.1
IF BFN.ARG [BFN.ARG.I[S]] & %3 = 0
@BOX 20.1
-1 => S.ID
WHILE S < F AND S.ID < 0 DO
   IF BFN.ARG [BFN.ARG.I [S] => I+1] = 0 AND
      BFN.ARG [I] = KIND THEN
      S => S.ID;
   FI
   1 +> S;
OD
IF S.ID < 0
@END
///15
@TITLE BSC07.21.2(1,11)
@COL 9C
@COL 1S-2T-3T-4T-5T-7R-8F
@COL 11T-12T-13R
@COL 14C
@ROW 9-7
@ROW 4-11
@ROW 13-14
@FLOW 1-2N-3N-4N-5N-7-8
@FLOW 2Y-9
@FLOW 3Y-11N-12N-13-8
@FLOW 4Y-9
@FLOW 5Y-9
@FLOW 11Y-14
@FLOW 12Y-14
@BOX 1.0
PROCESS NUMERIC EXPR ARRAY NODE
@BOX 2.0
OPERATOR NOT '+' '-' OR '*'?
@BOX 3.0
L.H.OPERAND A
NUMERIC EXPR?
@BOX 4.0
L.H. NOT AN ARRAY
NAME
@BOX 5.0
RH NOT AN ARRAY
NAME
@BOX 7.0
SET UP NODE FOR
ARRAY EXPR
@BOX 8.0
END
@BOX 9.0
FAULT
@BOX 11.0
OPERATOR NOT '*' ?
@BOX 12.0
R.H.OPERAND NEITHER AN
ARRAY NAME NOR AN
ARRAY VALUE?
@BOX 13.0
SET UP RESULTANT NODE
FOR COMPLETE ARRAY EXPR
@BOX 14.0
FAULT
@BOX 1.1
::07.21.2
@BOX 2.1
IF OP /= 17 /= 7 /= 10
@BOX 3.1
IF LTY < 2 AND
   [LH0 & %80 /= 0 AND [LH0 & %F < 3 OR LH0 & %F > 6]]
      OR LH0 & %280 = 0
@BOX 4.1
IF LH0 & %8F /= %83
@BOX 5.1
IF RH0 & %8F /= %83
@BOX 7.1
N0 & %FF ! (TY & %F800) ! %200 => AS[AP];
@BOX 8.1
::END
@BOX 9.1
MONITOR.P(%1027,F.PTR);
@BOX 11.1
IF OP /= 10
@BOX 12.1
IF RH0 & %8F /= %83 /= %84
@BOX 13.1
TY & %F800 ! (N0 & %FF) ! %200 => AS[AP];
@BOX 14.1
MONITOR.P(%101F,F.PTR);
@END
///5
@TITLE BSC07.21.3(1,11)
@COL 7R
@COL 1S-2T-3T-4R-5F
@COL 8C
@ROW 7-4-8
@FLOW 1-2N-3N-4-5
@FLOW 2Y-8
@FLOW 3Y-7-5
@BOX 1.0
PROCESS NON ARRAY EXPR NODE
@BOX 2.0
CHECK TYPE PERMITTED
WITH OPERATOR
INVALID TYPES ARE
-  / * ** :STR
OR AND    :STR/REAL
@BOX 3.0
NOT RELATIONAL OPERATOR?
@BOX 4.0
SET TYPE OF RESULT
NODE TO 8-BIT LOGICAL
@BOX 5.0
END
@BOX 7.0
SET TYPE OF RESULT NODE
TO TYPE OF GREATER PRECISION
@BOX 8.0
FAULT
@BOX 1.1
DATAVEC OP.CH($LO8)
::INDEXED BY OPERATOR
::BIT i=1 if it is illegal to use type i
::      with this operator
%FF  %4  %4  %4  :: Reserved for EOS = /= >=
%4  %4  %4  %C  :: < =< > -
%7  %C  %C  %B  :: & ^ * AND
%B  %C  %C  %C  :: OR / unary - unary +
%B %C              :: unary NOT +
END
@BOX 2.1
IF OP.CH[OP] => T & (1 <<- LTY) /=0 OR
                1 <<- RTY & T /=0
@BOX 3.1
IF OP > 6
@BOX 4.1
N0 & %7FF ! %8000 => AS[AP];
@BOX 5.1
::END
@BOX 7.1
IF LTY = RTY THEN
   IF LH0 & %3800 > RH0 & %3800 THEN
         LH0 => T;
   ELSE
         RH0 => T;
   FI
ELSE
   IF LTY = R THEN
         LH0 => T;
   ELSE
         RH0 => T;
   FI
FI
R <<- 14 !(T & %3800) ! (N0 & %7FF) => AS[AP];
@BOX 8.1
MONITOR.P(%1029,F.PTR);
@END
///15
@TITLE BSC07.21.4(1,11)
@COL 1S-2T-3T-4R-5T-6R-7F
@COL 8C-9C
@ROW 4-8
@FLOW 1-2N-3N-4-5N-6-7
@FLOW 2Y-8
@FLOW 3Y-8
@FLOW 5Y-9
@BOX 1.0
PROCESS STRING ARRAY EXPR NODE
@BOX 2.0
LH OPERAND NOT A
SCALAR STRING VALUE,
AN ARRAY NAME?
@BOX 3.0
RH OPERAND NOT A
SCALAR STRING VALUE,
ARRAY NAME,
STRING ARRAY FUNCTION?
@BOX 4.0
SELECT KIND OF COERCION
@BOX 5.0
INVALID COERCION?
@BOX 6.0
UPDATE NODE
@BOX 7.0
END
@BOX 8.0
FAULT
@BOX 9.0
FAULT
@BOX 1.1
DATAVEC STR.CH($LO8)
0  2  2   ::LH SCALAR STRING VALUE
2  2  0   ::LH ARRAY NAME
::COLS ARE RH SCALAR STRING
::         RH ARRAY NAME
::         RH ARRAY FUNCTION (NULL)
::RESULT 0-INVALID, 1-PARTIAL ARRAY EXPR, 2-COMPLETE ARRAY EXPR
END
@BOX 2.1
-1 => T;
IF LH0 & %400 /=0 THEN
   0 => T;
ELSE IF LH0 & %8F = %83 THEN
   3 => T;
FI FI
IF T < 0
@BOX 3.1
-1 => S;
IF RH0 & %400 /= 0 THEN
   0 => S;
ELSE IF RH0 & %8F = %83 THEN
   1 => S;
ELSE IF RH0 & %8F = %84 THEN
   2 => S;
FI FI FI
IF S < 0
@BOX 4.1
STR.CH[T+S] <<- 8 => T;
@BOX 5.1
IF T = 0
@BOX 6.1
N0 & %FF ! T ! %C000 => AS[AP];
@BOX 7.1
::END
@BOX 8.1
MONITOR.P(%1028,F.PTR);
@BOX 9.1
MONITOR.P(%102A,F.PTR);
@END
///14
@TITLE BSC07.22(1,11)
@COL 23R
@COL 1S-10R-2T-3T-4T-5R-19T-7T-8R-11R-22T-21R-17F
@COL 12T-13R-18T-15R-16R
@ROW 23-3
@ROW 4-12
@ROW 8-16
@FLOW 1-10-2N-3N-4N-5-19N-7N-8-11-22N-21-17
@FLOW 2Y-23-19
@FLOW 3Y-12N-13-18N-15-19
@FLOW 12Y-18Y-19
@FLOW 4Y-19
@FLOW 7Y-16-11
@FLOW 22Y-17
@FLOW 19Y-11
@BOX 1.0
PLANT NUM FN(FN,AP)
@BOX 2.0
NOT LOAD FN
@BOX 3.0
A LOAD
@BOX 4.0
B NOT IN USE
@BOX 5.0
PLANT STACK B
UPDATE EXPR NODE TO
SAY OPERAND OF B ON STACK
@BOX 7.0
DEREFERENCE REQUIRED?
@BOX 8.0
NOTE D=REF REQUIRED
TO LOAD D
@BOX 10.0
GET TL.NAME OF OPERAND
SET TYPE
SET REG BITS IN TL OPCODE
@BOX 11.0
PROCESS ACCORDING TO OPERAND KIND
VARIABLE, CONST, CONST.NAME : 07.22.1:
ARRAY.EL, T : 07.22.1:
FN.REF : 07.22.2:
OTHERS : 07.22.1:
@BOX 12.0
A NOT IN USE?
@BOX 13.0
PLANT STACK A
UPDATE EXPR NODE TO SAY
OPERAND ON STACK
@BOX 18.0
FN REFN?
@BOX 15.0
SET A.TYPE : 7.26:
@BOX 16.0
NOTE D=REQUIRED TO
LOAD D
@BOX 17.0
END
@BOX 19.0
CONSTANT, T, OR STACK
@BOX 21.0
SET UP REG IN USE INFO
@BOX 22.0
NOT LOAD FUNCTION?
@BOX 23.0
NOTE TYPE AND STATUS OF REGISTER
@BOX 1.1
PROC PLANT.NUM.FN(FN,AP);
$IN REG.AP, REG.A.TYPE;
$IN P,MN,TYP,W0,DEREF,BSTK,KND,PRE.A.AP,PRE.A.TYPE;
AS[AP+2]=>P;
@BOX 2.1
IF FN & %1F/=2
@BOX 3.1
IF FN & %100 = 0
@BOX 4.1
IF B.AP < 0
@BOX 5.1
TL.PL(%47,%2000);
1 +> AS[B.AP];
-1 => B.AP;
@BOX 7.1
IF DETAIL1 & %20 /= 0
@BOX 8.1
0 => DEREF;
@BOX 10.1
IF AS[AP] => W0 & %F => KND /=0 <13 THEN
   SELECT NLIST[P];
   MUTLN => MN;
   T ->> 3 => TYP;
ELSE
   W0 ->> 11 => TYP;
   0 => MN;
FI
IF FN & %100 = 0 THEN
   %20 !> FN
FI
@BOX 11.1
SWITCH W0 & %F\
F7.22.1B27, F7.22.1B14, F7.22.1B2, F7.22.1B23,
F7.22.1B23, F7.22.1B23, F7.22.2B2, F7.22.2B2,
F7.22.2B2,  F7.22.2B2,  F7.22.1B23, F7.22.1B23,
F7.22.1B23, F7.22.1B22, F7.22.1B20, F7.22.1B23;
#BSC07.22.1
-> END.BOX.11;
#BSC07.22.2
END.BOX.11:;
@BOX 12.1
IF A.AP =< 0
@BOX 13.1
TL.PL(%47,%3000);
1 +> AS[A.AP];
-1 => A.AP;
@BOX 15.1
SET.A.TYPE(TYP);
@BOX 16.1
1 => DEREF;
@BOX 17.1
END;
@BOX 18.1
IF W0 & %F > 5 < 10
@BOX 19.1
IF KND = 0 OR KND >= 13
@BOX 21.1
IF FN & %100 /=0 THEN
   AP => B.AP;
ELSE
   AP => A.AP;
FI
AS[AP] & %FF00 ! %8C => AS[AP];
@BOX 22.1
IF FN & %1F /= 2
@BOX 23.1
IF FN & %100 = 0 THEN
   A.AP => REG.AP;
   CUR.A.TYPE => REG.A.TYPE;
ELSE
   B.AP => REG.AP;
FI
@END
//17 25.JUL.83
@TITLE BSC07.22.1(1,11)
@COL 14C-15T-16R-20C-21R-22C-26R-27C-28R-12R-10F
@COL 1S-2C-3T-4R-5R-6R-7T-8R-9R
@COL 18T-19R-23C-24R-25C
@ROW 14-2
@ROW 4-18
@FLOW 2-3N-4-5-6-7N-8-9-12
@FLOW 3Y-18N-19-4
@FLOW 18Y-4
@FLOW 7Y-9
@FLOW 14-15N-16-9
@FLOW 15Y-12-10
@FLOW 20-21-12
@FLOW 23-24-25
@FLOW 22-26-12
@FLOW 27-28-12
@BOX 1.0
PLANT NUM FN/CONT
@BOX 2.0
ARRAY EL
@BOX 3.0
B FN
@BOX 4.0
CODE SUBSCRIPTS : 07.13:
@BOX 5.0
PL LOAD D=/D=REF TLNAME
SET WRITE ACCESS IN PROPERTIES
IF OPCODE IS STORE
@BOX 6.0
PL SEL EL
RESET B IN USE INFO
@BOX 7.0
B NOT STACKED?
@BOX 8.0
SET.B.TYPE [11.28] (NOT YET)
PL B=STACK
@BOX 9.0
SET OPD TO D[]
@BOX 10.0
END
@BOX 12.0
RELOAD REGISTERS IF NECESSARY
PL FN NAME
@BOX 14.0
VARIABLE
@BOX 15.0
DEREFERENCE NOT
REQUIRED?
@BOX 16.0
PLANT D=
@BOX 18.0
B=
@BOX 19.0
STACK B
NOTE STACKED
@BOX 20.0
T
@BOX 21.0
SET NAME
NOTE T NOT IN USE
@BOX 22.0
STK
@BOX 26.0
SET NAME
@BOX 27.0
CONST
@BOX 28.0
DECL ARITH CONST
@BOX 23.0
OTHERS
@BOX 24.0
FAULT
@BOX 25.0
END
@BOX 1.1
::BSC07.22.1
@BOX 2.1
F7.22.1B2:;
@BOX 3.1
0 => BSTK;
IF FN & %100 /= 0
@BOX 4.1
CODE.SUBS(P,AS[AP+3]);
@BOX 5.1
TL.PL(%61+DEREF,MN);
@BOX 6.1
TL.PL(%64,0);
-1 => B.AP;
IF FN & %1F = 0 THEN
   8 !> DETAIL1;
FI
@BOX 7.1
IF BSTK = 0
@BOX 8.1
TL.PL(%02,%1003);
@BOX 9.1
%1004 => MN;
@BOX 10.1
::END
@BOX 12.1
IF FN & %1F /= 2 THEN
   IF FN & %100 = 0 THEN
      IF A.AP /= REG.AP THEN
         SET.A.TYPE(REG.A.TYPE);
         TL.PL(%22, %1003);
      FI
   ELSE
      IF B.AP /= REG.AP THEN
         TL.PL(%02, %1003);
      FI
   FI
FI
TL.PL(FN & %FF,MN);
@BOX 14.1
F7.22.1B14:;
@BOX 15.1
IF DEREF = 0
@BOX 16.1
TL.PL(%62,MN);
@BOX 18.1
IF FN & %1F/=2
@BOX 19.1
1 => B.STK;
TL.PL(%47,%2000);
@BOX 20.1
F7.22.1B20:;
@BOX 21.1
::TBC
@BOX 22.1
F7.22.1B22:;
@BOX 23.1
F7.22.1B23:;
@BOX 24.1
CAPTION(%"$L FN  AP :");
OUTHEX(FN, 4); SPACES(3); OUTHEX(AP, 4);
MONITOR.S(%102B, %"7.22.1 B24");
@BOX 25.1
::NO CODE
@BOX 26.1
%1003 => M.N;
@BOX 27.1
F7.22.1B27:;
@BOX 28.1
DECL.ARITH.CONST(^CLIST[AS[AP+2]],TYP);
@END
///13
@TITLE BSC07.22.2(1,11)
@COL 1S-2C-11T-3T-4R-16T-5R-6T-7R-8T-14T-15R-9R-10F
@COL 12R-13R-17R
@ROW 3-12
@FLOW 2-11N-3N-4-16N-5-6N-7-8N-14N-15-9-10
@FLOW 3Y-16
@FLOW 6Y-8Y-10
@FLOW 11Y-12-13-3
@FLOW 14Y-9
@FLOW 16Y-17-6
@BOX 1.0
PL NUM FN/CONT
@BOX 2.0
FN REF
@BOX 11.0
B FN AND A IN USE
NOTE CURRENT A TYPE
NOTE A TYPE
@BOX 3.0
REGISTER OF FN DOES NOT NEED PRESERVING
@BOX 4.0
STACK A/B
@BOX 5.0
CODE.PROC.CALL : 07.27:
@BOX 6.0
CURRENT REG IS A
@BOX 7.0
SET A PRECISION TO B PRECISION
PL A => B
CONVERT B TYPE IF NECESSARY
RESET A TYPE AND RELOAD A
IF STACKED IN BOX 12
@BOX 8.0
LOAD A OR B FUNCTION
@BOX 9.0
PL B/A REV.FN STACK
REVERSE TEST INFO
@BOX 10.0
END
@BOX 12.0
STACK A
@BOX 13.0
NOTE A USE AND
RESET A USE
@BOX 14.0
CHANGE OF PRECISION REQUIRED
@BOX 15.0
PL A CONV
@BOX 16.0
BASIC SUPPLIED FUNCTION OR
SUBPROGRAM?
@BOX 17.0
CODE CALL OF BASIC
SUPPLIED FUNCTION [BSC07.31]
@BOX 1.1
::BSC07.22.2
@BOX 2.1
F7.22.2B2:;
@BOX 3.1
IF FN & %100 = 0 AND A.AP =< 0
   OR FN & %100 /= 0 AND B.AP =< 0
@BOX 4.1
IF FN & %100 /= 0 THEN
   %2000 => M.N;
   -1 => B.AP;
ELSE
   %3000 => M.N;
   -1 => A.AP;
FI
TL.PL(%47,M.N);
@BOX 5.1
PL.PROC.CALL(AP);
@BOX 6.1
IF FN & %100 = 0
@BOX 7.1
SET.A.TYPE(BINT ->> 3 ! %100);
TL.PL(%20,%2000);
IF PRE.A.AP /=0 THEN
   SET.A.TYPE(PRE.A.TYPE);
   TL.PL(%22,%1003);
   PRE.A.AP => A.AP;
FI
@BOX 8.1
IF FN & %1F = 2
@BOX 9.1
TL.PL(FN & %FF,%1003);
@BOX 10.1
::END
@BOX 11.1
0 => PRE.A.AP;
CUR.A.TYPE => PRE.A.TYPE;
IF FN & %100 /=0 AND
   A.AP > 0
@BOX 12.1
TL.PL(%47,%3000);
@BOX 13.1
A.AP => PRE.A.AP;
-1 => A.AP;
@BOX 14.1
IF FN & %100 /=0 OR
   PRE.A.TYPE =CUR.A.TYPE
@BOX 15.1
SET.A.TYPE(PRE.A.TYPE ! %100);
@BOX 16.1
IF W0 & %F = 8 OR
   W0 & %F = 9
@BOX 17.1
PL.BFN.CALL(AP);
@END
///16 21.JUL.83
@TITLE BSC07.23(1,11)
@COL 17C-18R-32C-34C-33R
@COL 1S-30T-3R-4R-5R-6C-7R-8T-9R-10R-11R-12R-13R-31T-14R-15R-16F
@COL 20C-21R-22T-23R-24R-25C-26R-27R-28C-29R
@ROW 17-6-20
@ROW 32-25
@FLOW 1-30N-3-4-5
@FLOW 6-7-8N-9-10-11-12-13-31N-14-15-16
@FLOW 30Y-4
@FLOW 8Y-10
@FLOW 17-18-31
@FLOW 20-21-22N-23-24-31
@FLOW 22Y-24
@FLOW 25-26-27-31
@FLOW 28-29-31
@FLOW 31Y-16
@FLOW 32-33-31
@FLOW 34Y-31
@BOX 1.0
PLANT.STR(MN OF STR.SPEC.VECTOR,
         INDEX,STR.AP)
P1=0 MEANS STRING REFERENCE IN A REQUIRED
P1 = 1 MEANS STRING REFERENCE IN D REQUIRED
P3 = 0 MEANS ACC LOADED WITH STRING
P4 /= 0 WRITE ACCESS
@BOX 3.0
PLANT D=REF SPECIFICATION VECTOR
      B=INDEX
      SEL EL B
      D=>SEL.VAR
@BOX 4.0
SET AMODE TO [$LO8]
@BOX 5.0
SWITCH ON STRING OPERAND KIND
@BOX 6.0
ARRAY ELEMENT
@BOX 7.0
SET LOAD FN TO D=REF
IF STRING WRITE SET
WRITE ACCESS IN PROPERTIES
@BOX 8.0
DEREFERENCE NOT REQUIRED?
@BOX 9.0
SET FN TO D=
@BOX 11.0
PLANT D LOAD
@BOX 10.0
CODE SUBSCRIPTS IN B
:07.13:
@BOX 12.0
PLANT B * ELSIZE
      BASE B
      B = ELSIZE -1
      LIMIT B
RESET B IN USE INFO
@BOX 13.0
SET AMODE TO [$LO8]
PLANT AREFD[] UNLESS D LOAD REQUIRED
@BOX 14.0
PLANT D = SEL VAR
          SEL FLD 0
          A => D[0]
@BOX 15.0
PROCESS SUBSTRINGS [07.23.1]
@BOX 16.0
END
@BOX 17.0
FUNCTION CALL
@BOX 18.0
PLANT CALL TO FN
@BOX 20.0
VARIABLE
@BOX 21.0
SET LOAD FN TO =REF
@BOX 22.0
DEREFERENCE NOT REQUIRED
@BOX 23.0
SET FN TO A=
@BOX 24.0
PLANT A/D= SCALAR
@BOX 25.0
EXPLICIT CONSTANT
@BOX 26.0
DECLARE CONSTANT TO MUTL
@BOX 27.0
PLANT A/D=REF OF CONST
@BOX 28.0
NAMED CONSTANT
@BOX 29.0
PLANT A=REF CONST
@BOX 30.0
REFERENCE ONLY REQUIRED
@BOX 31.0
REFERENCE ONLY REQUIRED ?
@BOX 32.0
BASIC SUPPLIED FUNCTION
@BOX 33.0
CODE CALL TO BASIC
SUPPLIED FUNCTION
@BOX 34.0
ACC
@BOX 1.1
PROC PLANT.STR(VEC,IND,AP,WR);
$IN N,N0,FN,I,P,T,D,M,SZ;
@BOX 3.1
GET.TEMP(-1,0) => N;
TL.PL(%61,VEC);
TL.C.LIT.16(%44,IND);
TL.PL(%2,0);
TL.PL(%64,0);
TL.PL(%60,N);
@BOX 4.1
IF VEC /= 1 THEN
   0 => D;
   SET.A.TYPE(%C18);
ELSE
   %40 => D;
FI
@BOX 5.1
IF AP = 0, ->F7.23B34;
AS[AP+2] => I;
IF AS[AP] => N0 & %F => T = 0,->F7.23B25;
IF T = 1,->F7.23B20;
IF T = 2,->F7.23B6;
IF T = 7,->F7.23B17;
IF T=9,->F7.23B32;
MONITOR.S(%2B,%"F7.27B5");
@BOX 6.1
F7.23B6:;
@BOX 7.1
%61 => FN;
IF WR /= 0 THEN
   8 !> DETAIL1 OF NLIST[I];
FI
@BOX 8.1
IF DETAIL1 OF NLIST[I] & %20 = 0
@BOX 9.1
%62 => FN;
@BOX 11.1
TL.PL(FN,MUTL.N OF NLIST[I]);
@BOX 10.1
CODE.SUBS(I,AS[AP+3]);
@BOX 12.1
IF FN = %61 THEN
   TL.CLIT.16(%44, ARRAYS[DETAIL OF NLIST[I] - 1] => SZ);
   0 => M;
ELSE
   MUTLN OF NLIST[I] - 1 => M;
FI
TL.PL(%0B,M);
TL.PL(%66, 0);
IF M = 0 THEN
   TL.CLIT.16(%44, SZ - 1);
   TL.PL(%2, 0);
ELSE
   TL.PL(%2, M);
   TL.PL(%9, ONE);
FI
TL.PL(%67,0);
-1 => B.AP;
@BOX 13.1
IF D = 0 THEN
   SET.A.TYPE(%C18);
   TL.PL(%21,%1004);
FI
@BOX 14.1
TL.PL(%62,N);
TL.PL(%63,0);
TL.PL(%20,%1004);
@BOX 15.1
#BSC07.23.1
@BOX 16.1
END;
@BOX 17.1
F7.23B17:;
@BOX 18.1
PL.PROC.CALL(AP);
@BOX 20.1
F7.23B20:;
@BOX 21.1
%21 => FN;
@BOX 22.1
IF DETAIL1 OF NLIST[I] & %20 = 0
@BOX 23.1
%22 => FN;
@BOX 24.1
TL.PL(FN ! D,MUTLN OF NLIST[I]);
@BOX 25.1
F7.23B25:;
@BOX 26.1
DECL.STR.CONST(^STR.LIST,I) => I;
@BOX 27.1
TL.PL(%21 ! D,I);
@BOX 28.1
::UNIMPLEMENTED EXTENSION
@BOX 29.1
::UNIMPLEMENTED EXTENSION
@BOX 30.1
IF VEC < 2
@BOX 31.1
IF VEC < 2
@BOX 32.1
F7.23B32:;
@BOX 33.1
PL.BFN.CALL(AP);
@BOX 34.1
F7.23B34:;
0 => N0;
@END
///13
@TITLE BSC07.23.1(1,11)
@COL 1S-2R-3T-4R-5R-6T-7R-8R-9F
@COL 10R-11R
@ROW 4-10
@ROW 7-11
@FLOW 1-2-3N-4-5-6N-7-8-9
@FLOW 3Y-10-5
@FLOW 6Y-11-8
@BOX 1.0
PROCESS SUBSTRING SPECIFIER
@BOX 2.0
SET AMODE TO $IN16[07.26]
@BOX 3.0
NO SUBSTRING PRESENT?
@BOX 4.0
CODE INDEX EXPR FOR LOWER LIMIT
OF SUBSTRING [07.3]
@BOX 5.0
PLANT D=SEL VAR
        SEL FLD 1
        A => D[]
RESET A IN USE
@BOX 6.0
NO SUBSTRING PRESENT?
@BOX 7.0
CODE INDEX EXPR FOR UPPER LIMIT
OF SUBSTRING [07.3]
@BOX 8.0
PLANT D= SEL VAR
         SEL FLD 2
         A => D[]
RESET A IN USE
@BOX 9.0
END
@BOX 10.0
PLANT A = 0
@BOX 11.0
PLANT A = STRING LENGTH
@BOX 1.1
::PROCESS STRING SPECIFIER
@BOX 2.1
SET.A.TYPE(9);
@BOX 3.1
IF N0 & %200 = 0
@BOX 4.1
CODE.EXPR(AS[AP+4],9);
@BOX 5.1
TL.PL(%62,N);
TL.PL(%63,1);
TL.PL(%20,%1004);
-1 => A.AP;
@BOX 6.1
IF N0 & %200 = 0
@BOX 7.1
CODE.EXPR(AS[AP+5],9);
@BOX 8.1
TL.PL(%62,N);
TL.PL(%63,2);
TL.PL(%20,%1004);
-1 => A.AP;
@BOX 9.1
::END
@BOX 10.1
TL.PL(%22,ZERO);
@BOX 11.1
TL.C.LIT.16(%44,DEF.STR.Z);
TL.PL(%22,0);
@END
//14
@TITLE BSC07.24(1,11)
@COL 1S-2T-5R-6R-7F
@FLOW 1-2N-5-6-7
@FLOW 2Y-7
@BOX 1.0
CHECK.CONST(AP,CONST.TYPE,OTHER.OP.TYPE)
@BOX 2.0
CONST.TYPE REAL OR
OTHER OP.TYPE NOT REAL
@BOX 5.0
CHANGE CONSTANT TYPE
@BOX 6.0
UPDATE NODE.INFO
@BOX 7.0
END
@BOX 1.1
PROC CHECK.CONST(AP,CT,OT);
$IN I;
@BOX 2.1
CT => CHECK.CONST;
IF CT & %18 = 0 OR
   OT & %18 /=0
@BOX 5.1
INT.C OF CLIST[AS[AP+2] => I]
=> REAL.C OF CLIST[I];
@BOX 6.1
AS[AP] & %07FF ! (OT <<- 11) => AS[AP];
OT => CHECK.CONST;
@BOX 7.1
END
@END
//14
@TITLE BSC07.25(1,11)
@COL 1S-2T-5R-6R-7R-8R-9F
@FLOW 1-2N-5-6-7-8-9
@FLOW 2Y-9
@BOX 1.0
LOAD.A.FROM.T
@BOX 2.0
T NOT IN USE
@BOX 5.0
SET A TYPE TO LOGICAL
:07.26:
@BOX 6.0
PLANT A= REQUIRED FN OF T
@BOX 7.0
UPDATE NODE
@BOX 8.0
SET T AS NOT IN USE
@BOX 9.0
END
@BOX 1.1
PROC LOAD.A.FROM.T;
DATAVEC TOPS($LO16)
%0 %1008 %1009 %100A %100D %100C %100B
END;
@BOX 2.1
IF T.AP < 0
@BOX 5.1
SET.A.TYPE(%10);
@BOX 6.1
TL.PL(%22,TOPS[TFN]);
@BOX 7.1
2 -> AS[TAP];
TAP => A.AP;
@BOX 8.1
-1 => T.AP;
@BOX 9.1
END;
@END
///12
@TITLE BSC07.26(1,11)
@COL 1S-2T-11T-3T-4R-5T-6R-7R-10R-8F
@COL 9R
@ROW 9-4
@FLOW 1-2N-11N-3N-4-5N-6-7-10-8
@FLOW 2Y-8
@FLOW 3Y-9-7
@FLOW 5Y-7
@FLOW 11Y-10
@BOX 1.0
SET.A.TYPE(TYPE)
P1 BIT 8 = 0/1 - AMODE/ACONV
   BIT 9 = 1   - IMPLICIT TYPE CHANGE
   BIT 0-4     - TYPE
   BIT 10,11 = 0,1,3 - SCALAR/UNB PTR/BND PTR
@BOX 2.0
CURRENT A TYPE SAME AS REQUESTED?
@BOX 3.0
AMODE?
@BOX 4.0
SET OPCODE TO ACONV
@BOX 5.0
NOT REAL TO INTEGER CONVERSION
@BOX 6.0
SET CONV KIND TO ROUNDED
@BOX 7.0
SET TL TYPE FOR OPERAND
PLANT AMODE/ACONV
@BOX 8.0
END
@BOX 9.0
SET OPCODE TO AMODE
@BOX 10.0
NOTE A TYPE AS CURRENT
@BOX 11.0
IMPLICIT TYPE CHANGE
@BOX 1.1
PROC SET.A.TYPE(TYP);
$IN OP.C,K,T;
%FDFF &> TYP;  ::FRIG REMOVE WHEN MUTL FIXED
0 => K;
@BOX 2.1
IF TYP & %CFF => T = CUR.A.TYPE
@BOX 3.1
IF TYP & %100 = 0
@BOX 4.1
%45 => OP.C;
@BOX 5.1
IF CUR.A.TYPE & %1C /=0 OR TYP & %1C = 0
@BOX 6.1
%4000 => K;
@BOX 7.1
TL.PL(OP.C, T ->> 10 ! TL.TYP[T & %1F] ! K);
@BOX 8.1
END;
@BOX 9.1
%46 => OP.C;
@BOX 10.1
T => CUR.A.TYPE;
@BOX 11.1
IF TYP & %200 /= 0
@END
 //18 28.JUL.83
@TITLE BSC07.27(1,11)
@COL 16R
@COL 1S-2R-3R-4R-5T-6R-7R-17R-8T-9R-10R-15T-11T-12R-13F
@COL 14R
@FLOW 1-2-3-4-5N-6-7-17-5Y-8N-9-10-15N-11N-12-13
@ROW 14-12-16
@FLOW 8Y-10
@FLOW 11Y-14-13
@FLOW 15Y-16-13
@BOX 1.0
PL.PROC.CALL(PROC.AP)
@BOX 2.0
OBTAIN PROPS OF PROC
@BOX 3.0
PLANT STACK LINK
@BOX 4.0
GET START OF PARAM LIST
@BOX 5.0
NO MORE PARAMETERS
@BOX 6.0
GET ACTUAL AND FORMAL PARAMETER INFO
@BOX 7.0
PROCESS ACCORDING TO FORMAL PARAMETER
TYPE
NUMERIC SCALAR VALUE [07.27.1]
STRING SCALAR VALUE [07.27.1]
CHANNEL [07.27.1]
NUMERIC SCALAR REFN [07.27.2]
STRING SCALAR REFN [07.27.3]
ARRAY REFN [07.27.4]
ARRAY VALUE [07.27.4]
@BOX 8.0
NOT STRING FUNCTION
@BOX 9.0
GET STRING RESULT VARIABLE
AND STACK REFN TO IT
@BOX 10.0
PLANT CALL
@BOX 11.0
SUBPROGRAM
@BOX 12.0
SET AMODE FOR RESULT
@BOX 13.0
END
@BOX 14.0
SET AMODE AS UNDEFINED
@BOX 15.0
STRING FUNCTION
@BOX 16.0
SET ATYPE FOR STRING[07.26]
PLANT A= REF RESULT STRING
@BOX 17.0
NOTE A NOT IN USE
@BOX 1.1
PROC PL.PROC.CALL(AP);
$IN FPT,N,PROC.I,PAR.ST,PAR.AP;
$IN I,EXPR.AP,PROC.T,PAR.0,T,MN,RT,TY,FN, Z.MN;
$IN PAR.N;
@BOX 2.1
DETAIL OF NLIST[AS[AP+2] => PROC.I] => PAR.ST;
IF AS[AP] & %100 /= 0 THEN
   AS[AS[AP+3] => PAR.AP] => N;
ELSE
   0 => N;
FI
K OF NLIST[PROC.I] => PROC.T;
@BOX 3.1
TL.PL(%40,MUTLN OF NLIST[PROC.I]);
@BOX 4.1
-1 => I;
@BOX 5.1
IF 1+>I >= N
@BOX 6.1
PARAMS [PAR.ST + I + 2] => FPT;
AS[AS[PAR.AP+I+1] => EXPR.AP] => PAR.0;
@BOX 7.1
IF FPT & 3 => T = 0 THEN
   2 => T;
   IF PROC.T = KSUB THEN
      2 +> T;
   FI
   IF FPT = BSTR THEN
      1 +> T;
   FI
ELSE
   T + 1 ->> 2 => T;
FI
SWITCH T \
F7.27.4B1,
F7.27.1B1,
F7.27.1B3, F7.27.1B7,
F7.27.2B1, F7.27.3B1;
#BSC07.27.1
-> ENDSW;
#BSC07.27.2
-> ENDSW;
#BSC07.27.3
->ENDSW;
#BSC07.27.4
;ENDSW:;
@BOX 8.1
IF PARAMS[PAR.ST] => RT /= BSTR
@BOX 9.1
GET.TEMP(%80,DEF.STR.Z + 1) => MN;
SET.A.TYPE(%C18);
TL.PL(%21,MN);
TL.PL(%41,%3000);
@BOX 10.1
TL.PL(%42,0);
@BOX 11.1
IF PROC.T = KSUB OR
   RT = BSTR
@BOX 12.1
SET.A.TYPE(RT->>3 ! %200);
@BOX 13.1
END
@BOX 14.1
-1 => CUR.A.TYPE;
@BOX 15.1
IF RT = BSTR
@BOX 16.1
SET.ATYPE(%C18);
TL.PL(%21,MN);
@BOX 17.1
-1 => A.AP;
@END
//14
@TITLE BSC07.27.1(1,11)
@COL 1C-2R-3C-4R-5R-6F
@COL 7C-8R-9R
@ROW 3-7
@FLOW 3-4-5-6
@FLOW 1-2-5
@FLOW 7-8-9-5
@BOX 1.0
CHANNEL
@BOX 2.0
CODE PARAM EXPR IN INT16 MODE
[07.3]
@BOX 3.0
NUMERIC SCALAR
VALUE
@BOX 4.0
CODE PARAM EXPR IN A
[07.3]
@BOX 5.0
PLANT STACK A
@BOX 6.0
END
@BOX 7.0
SCALAR STRING VALUE
@BOX 8.0
GET TEMP STRING[07.14]
@BOX 9.0
PLANT CALL TO ASSIGN
STRING EXPRESSION TO TEMP [07.17]
@BOX 1.1
F7.27.1B1:;
@BOX 2.1
CODE.EXPR(EXPR.AP,%9);
@BOX 3.1
F7.27.1B3:;
@BOX 4.1
CODE.EXPR(EXPR.AP,FPT->>3);
@BOX 5.1
TL.PL(%41,%3000);
@BOX 6.1
::END
@BOX 7.1
F7.27.1B7:;
@BOX 8.1
GET.TEMP(%80,DEF.STR.Z + 1) => MN;
@BOX 9.1
CODE.STR.EXPR(EXPR.AP,MN ! %4000);
SET.A.TYPE(%C18);
TL.PL(%21, MN);
@END
///11
@TITLE BSC07.27.2(1,11)
@COL 1S-2T-4R-5R-6R-7R-8R-9R-10F
@COL 11R-12T-13R-15T-16R-17R-18R-19R
@ROW 4-11
@FLOW 1-2N-4-5-6-7-8-9-10
@FLOW 2Y-11-12N-13-15N-16-9
@FLOW 12Y-15
@FLOW 15Y-17-18-19-9
@BOX 1.0
NUMERIC SCALAR REFN
@BOX 2.0
VARIABLE OR ARRAY ELEMENT?
@BOX 4.0
GET TEMP VARIABLE
FORMAL PARAMETER TYPE
@BOX 5.0
CODE EXPR IN A [07.3]
@BOX 6.0
PLANT A => TEMP
@BOX 7.0
SET AMODE TO PTR TYPE
@BOX 8.0
PLANT A=REF TEMP
@BOX 9.0
PLANT STACK A
@BOX 10.0
END
@BOX 11.0
SET OPCODE TO LOAD REF
@BOX 12.0
DEREFERENCE NOT REQUIRED
@BOX 13.0
SET OPCODE TO LOAD
@BOX 15.0
ARRAY ELEMENT?
@BOX 16.0
SET AMODE TO PTR TYPE[07.26]
PLANT A LOAD
@BOX 17.0
CODE SUBSCRIPTS
[07.13]
@BOX 18.0
PLANT D = ARRAY REF
      SEL EL
@BOX 19.0
SET AMODE TO PTR TYPE[07.26]
PLANT A = REF D[]
@BOX 1.1
F7.27.2B1:;
@BOX 2.1
IF PAR.0 & %FF => T = %81
   OR T = %82
@BOX 4.1
GET.TEMP(TL.TYP[FPT->>3=>TY],0) => MN;
@BOX 5.1
CODE.EXPR(EXPR.AP,TY);
@BOX 6.1
TL.PL(%20,MN);
@BOX 7.1
SET.A.TYPE(%400 ! TY);
@BOX 8.1
TL.PL(%21,MN);
@BOX 9.1
TL.PL(%41,%3000);
@BOX 10.1
::END
@BOX 11.1
%21 => FN;
@BOX 12.1
IF DETAIL.1 OF NLIST[AS[EXPR.AP+2] => PAR.N] & %20 = 0
@BOX 13.1
%22 => FN;
@BOX 15.1
IF T = %82
@BOX 16.1
SET.A.TYPE(FPT->>3 ! %400);
TL.PL(FN,MUTLN OF NLIST[PAR.N]);
@BOX 17.1
CODE.SUBS(PAR.N,AS[AP+3]);
@BOX 18.1
TL.PL(FN ! %40, MUTLN OF NLIST[PAR.N]);
TL.PL(%64,0);
@BOX 19.1
SET.A.TYPE(FPT->>3 ! %400);
TL.PL(%21,%1004);
@END
///11
@TITLE BSC07.27.3(1,11)
@COL 13R-14R
@COL 1S-2T-3R-5R-6T-7R-8T-9R-10R-11R-12F
@ROW 13-3
@ROW 14-9
@FLOW 1-2N-3-5-6N-7-8N-9-10-11-12
@FLOW 2Y-13
@FLOW 6Y-8Y-14-11
@BOX 1.0
SCALAR STRING REFN
@BOX 2.0
NOT(STRING VARIABLE OR ARRAY ELEMENT)
OR SUBSTRING SPECIFIER PRESENT
@BOX 3.0
SET 'WRITE' STATUS IN PROPS
GET OPERANDS MUTLNAME
@BOX 5.0
SET OPCODE TO LOAD REF
@BOX 6.0
DEREFERENCE NOT REQUIRED?
@BOX 7.0
SET OPCODE TO LOAD
@BOX 8.0
SCALAR VARIABLE?
@BOX 9.0
CODE SUBSCRIPTS
[07.13]
@BOX 10.0
SET ATYPE TO STRING REF[07.26]
PLANT D = ARRAY REF
          SEL EL
      A = D[]
@BOX 11.0
PLANT STACK A
@BOX 12.0
END
@BOX 13.0
SCALAR STRING VALUE
[07.27.1]
@BOX 14.0
SET A TYPE TO STRING REF [07.26]
PLANT A=REF STRING
@BOX 1.1
F7.27.3B1:;
@BOX 2.1
IF PAR.0 & %FF => T /= %81 /= %82
   OR PAR.0 & %200 /= 0
@BOX 3.1
%8 !> DETAIL.1 OF NLIST[AS[AP+2]  => PAR.N];
MUTL.N OF NLIST[PAR.N] => MN;
@BOX 5.1
%21 => FN;
@BOX 6.1
IF DETAIL1 OF NLIST[PAR.N] & %20 = 0
@BOX 7.1
%22 => FN;
@BOX 8.1
IF T = %81
@BOX 9.1
CODE.SUBS(PAR.N,AS[AP+3]);
@BOX 10.1
TL.PL(FN ! %40,MN);
TL.PL(%64,0);
SET.A.TYPE(%C18);
TL.PL(%21,%1004);
@BOX 11.1
TL.PL(%41,%3000);
@BOX 12.1
::END
@BOX 13.1
->F7.27.1B7;
@BOX 14.1
SET.A.TYPE(%C18);
TL.PL(FN,MN);
@END
//16
@TITLE BSC07.27.4(1,11)
@COL 1S-2R-4R-5T-6R-11R-3R-7R-8R-9R-10F
@FLOW 1-2-4-5N-6-11-3-7-8-9-10
@FLOW 5Y-11
@BOX 1.0
ARRAY REFN
ARRAY VALUE
@BOX 2.0
SET WRITE STATUS IN PROPS
@BOX 3.0
SET ATYPE TO BOUNDED PTR OF
ARRAY ELEMENT TYPE[07.26]
@BOX 4.0
SET OPCODE TO LOAD REF
@BOX 5.0
DEREFERENCE NOT REQUIRED?
@BOX 6.0
SET OPCODE TO LOAD
@BOX 7.0
PLANT A = ARRAY REF
      STACK A
@BOX 8.0
SET ATYPE TO BOUNDED PTR OF
ADDRESS LENGTH INTEGERS[07.26]
@BOX 9.0
PLANT A LOAD
      STACK A
@BOX 10.0
END
@BOX 11.0
IF STRING ARRAY THEN STACK SIZE OF ARRAY ELEMENT
@BOX 1.1
F7.27.4B1:;
@BOX 2.1
8 !> DETAIL1 OF NLIST[AS[EXPR.AP+2]=>PAR.N];
@BOX 3.1
SET.A.TYPE(FPT->>3 ! %C00);
@BOX 4.1
%21 => FN;
@BOX 5.1
IF DETAIL1 OF NLIST[PAR.N] & %20 = 0
@BOX 6.1
%22 => FN;
@BOX 7.1
TL.PL(FN,MUTLN OF NLIST[PAR.N] => MN);
TL.PL(%41,%3000);
@BOX 8.1
SET.A.TYPE(BINT ->> 3 ! %C00);
@BOX 9.1
TL.PL(FN,MN+1);
TL.PL(%41,%3000);
@BOX 10.1
::END;
@BOX 11.1
MUTLN OF NLIST[PARN] => MN;
IF FPT & %F8 = %C0 THEN
   IF FN = %22 THEN
      MN - 1 => ZMN;
   ELSE
      TL.CLIT.16(%44, ARRAYS[DETAIL OF NLIST[PAR.N] - 1]);
      0 => Z.MN;
   FI
   SET.A.TYPE(9);
   TL.PL(%22, Z.MN);
   TL.PL(%41, %3000);
FI
@END
///10
@TITLE BSC07.28(1,10)
@COL 1S-8T-9R-2T-3R-4F
@COL 6R
@ROW 3-6
@FLOW 1-8N-9-2N-3-4
@FLOW 2Y-6-4
@FLOW 8Y-2
@BOX 1.0
PL.EXPR.CODE(AP,LOAD.INFO)
P2 BIT 8=0 A EXPR
       8=1 B EXPR
@BOX 2.0
EXPR A SINGLE NODE?
@BOX 3.0
PROCESS NODE ACCORDING TO
OPERATOR
CHARACTER COMPARE NODE:07.28.1:
EXPONENTIATION NODE:07.28.2:
OTHERS NODES:07.28.3:
@BOX 4.0
END
@BOX 6.0
PLANT NUM FN(LOAD):07.22:
@BOX 8.0
B TYPE SETTING REQUIRED?
@BOX 9.0
SET B TYPE
@BOX 1.1
PROC PL.EXPR.CODE(AP,INFO);
$IN W0,R0,L0,LT,RT,RAP,LAP,LK,RK,ET,
    LN,RN,MN;
@BOX 2.1
IF AS[AP] => W0 & %80 /=0
@BOX 3.1
AS[AS[AP+2] => LAP] => L0 ->> 11 & %1F => LT;
AS[AS[AP+3] => RAP] => R0 ->> 11 & %1F => RT;
L0 & %FF => LK;
R0 & %FF => RK;
W0 ->> 11 & %1F => ET
IF W0 & %3F = 9 THEN
#BSC07.28.2
ELSE IF LT = %18 AND W0 & %3F > 0 < 7 THEN
#BSC07.28.1
ELSE
#BSC07.28.3
FI FI
@BOX 4.1
END;
@BOX 6.1
PLANT.NUM.FN(INFO & %100 ! 2,AP);
@BOX 8.1
::TBC
@BOX 9.1
::TBC
@END
//14
@TITLE BSC07.28.1(1,11)
@COL 1S-3R-4R-12R-13R-5R-6R-7R-8R-9R-10R-11F
@FLOW 1-3-4-12-13-5-6-7-8-9-10-11
@BOX 1.0
COMPARE NODES
@BOX 3.0
COUNT NO OF STRINGS IN LHS AND RHS ITEMS
@BOX 4.0
GET STRING SPECIFICATION VECTOR OF SUFFICIENT LENGTH
FOR LHS AND RHS STRINGS
@BOX 5.0
PLANT CODE TO SET UP VECTOR
WITH LHS STRINGS
@BOX 6.0
PLANT CODE TO SET UP VECTOR
WITH RHS STRINGS
@BOX 7.0
PLANT CALL TO STRING COMPARE
PROCESSOR
@BOX 8.0
SET A MODE TO $IN8
@BOX 9.0
PLANT COMP 0
@BOX 10.0
MAKE MODE INTO A
TERMINAL NODE WITH AN
OPERAND OF T
SAVE RELATIONAL INFO IN NODE
NOTE T.IN.USE
SET CODE.EXPR.RESULT
@BOX 11.0
END
@BOX 12.0
IF T IN USE
LOAD A FROM T REGISTER
[07.25]
@BOX 13.0
IF A LOADED STACK IT
AND UPDATE NODE
@BOX 1.1
::BEGIN
@BOX 3.1
CNT.STR.OPNDS(AS[AP+2]) => LN;
CNT.STR.OPNDS(AS[AP+3]) => RN;
@BOX 4.1
GET.TEMP(STR.N,LN+RN) => MN;
@BOX 5.1
CODE.STR.OPNDS(MN,0,AS[AP+2]);
@BOX 6.1
CODE.STR.OPNDS(MN,LN,AS[AP+3]);
@BOX 7.1
BEGIN
DATAVEC CD.SEQ($LO16)
%102D
%46 %8010
%21 %800E
%6000
%46 %44
%22 %8003
%6000
%22 %800F
%6000
%A000
END;
MN => CD.MN.0;
LN => G.LIT.16.0;
RN => G.LIT.16.1;
STR.N + 3 => CD.MN.1;
PL.CD.SEQ(^CD.SEQ);
END
@BOX 8.1
SET.A.TYPE(%209);
@BOX 9.1
TL.PL(%2F,ZERO);
@BOX 10.1
AP => T.AP;
-1 => A.AP;
AS[AP] & %1F => PL.EXPR.CODE => TFN;
AS[AP] & %FF00 ! %8E => AS[AP];
@BOX 11.1
::END
@BOX 12.1
LOAD.A.FROM.T();
@BOX 13.1
IF A.AP > 0 THEN
   TL.PL(%47, %3000);
   1 +> AS[A.AP];
   -1 => A.AP;
FI
@END
///7
@TITLE BSC07.28.2(1,10)
@COL 12R
@COL 1S-2T-3T-4T-5T-6R-7T-8R-9R-10R-11F
@COL 14R-16R
@ROW 12-4
@ROW 3-14
@ROW 6-16
@FLOW 1-2N-3N-4N-5N-6R-7N-8-9-10-11
@FLOW 3Y-12-5
@FLOW 4Y-12
@FLOW 2Y-14-5
@FLOW 5-16-6
@FLOW 7Y-9
@BOX 1.0
EXPONENTIATION NODE
@BOX 2.0
RHS A CONSTANT?
@BOX 3.0
RHS NOT A TERMINAL
NODE?
@BOX 4.0
RHS A FN REFN?
@BOX 5.0
LHS A CONSTANT
@BOX 6.0
CODEEXPR FOR LHS:07.28:
@BOX 7.0
INCREASE IN PRECISION NOT
REQUIRED?
@BOX 8.0
PL A CONV
@BOX 9.0
PLANT NUM FN(**RHS):07.22:
@BOX 10.0
MAKE MODE INTO A
TERMINAL NODE
NOTE A/B IN USE
@BOX 11.0
END
@BOX 12.0
CODE.EXPR:07.28:
@BOX 14.0
CHECK.CONSTANT : 7.24:
CONVERT RHS CONST TO LHS TYPE
UNLESS RHS >= PRECISION THAN LHS
OR RHS INTEGER
@BOX 16.0
CHECK.CONSTANT : 7.24:
CONVERT LHS CONST TO RHS TYPE
UNLESS LHS >= PRECISION THAN RHS
@BOX 1.1
::BEGIN
@BOX 2.1
IF RK = %80
@BOX 3.1
IF RK < %80
@BOX 4.1
IF RK = %87 OR RK=%89
@BOX 5.1
IF LK = %80
@BOX 6.1
PL.EXPR.CODE(LAP,INFO);
@BOX 7.1
IF E.T = LT
@BOX 8.1
SET.A.TYPE(%100 ! ET);
@BOX 9.1
PLANT.NUM.FN(INFO & %100 ! %1F, RAP);
@BOX 10.1
AS[AP] & %FF00 ! %8C => AS[AP];
@BOX 11.1
::END
@BOX 12.1
PL.EXPR.CODE(RAP,INFO);
@BOX 14.1
IF RT & %18=%8 AND LT & %18 = %8 OR
   RT & %18/=%8 THEN
     CHECK.CONST(AP,RT,LT);
FI
@BOX 16.1
CHECK.CONST(AP,LT,RT);
@END
//14
@TITLE BSC07.28.3(1,10)
@COL 1S-2T-3T-4R-22R-5T-6T-7R-23R-8R-9F
@COL 18R-20R
@ROW 3-18
@ROW 6-20
@FLOW 1-2N-3N-4-22-5N-6N-7-23-8-9
@FLOW 2Y-18-5
@FLOW 3Y-5Y-20-8
@FLOW 6Y-8
@BOX 1.0
OTHER NODES
@BOX 2.0
LHS A CONST?
@BOX 3.0
LHS A TERMINAL MODE
@BOX 4.0
CODE.EXPR FOR LHS:07.28:
@BOX 5.0
RHS A CONSTANT?
@BOX 6.0
RH A TERMINAL NODE?
@BOX 7.0
CODE EXPR FOR RHS:07.28:
@BOX 8.0
CODE OPERATOR :07.28.4:
@BOX 9.0
END
@BOX 18.0
CHECK.CONSTANT : 7.24:
CONVERT LHS CONST TO RHS TYPE
UNLESS LHS >= PRECISION RHS
@BOX 20.0
CHECK CONSTANT : 7.24:
CONVERT RHS CONST TO LHS TYPE
UNLESS RHS >= PRECISION LHS
@BOX 22.0
IF IN T REG LOAD A
:7.25:
@BOX 23.0
IF IN T REG LOAD A
:7.25:
@BOX 1.1
::BEGIN
@BOX 2.1
IF LK = %80
@BOX 3.1
IF LK & %80 /= 0
@BOX 4.1
PL.EXPR.CODE(LAP,INFO);
@BOX 5.1
IF RK = %80
@BOX 6.1
IF RK & %80 /=0
@BOX 7.1
PL.EXPR.CODE(RAP,INFO);
@BOX 8.1
PSPEC CODE.OPERATOR($IN,$IN,$IN,$IN,$IN)/$IN;
#BSC07.28.4
CODE.OPERATOR(AP,LAP,RAP,LT,RT) => PL.EXPR.CODE;
@BOX 9.1
::END
@BOX 18.1
CHECK.CONST(LAP,LT,RT)=>LT;
@BOX 20.1
CHECK.CONST(RAP,RT,LT)=>RT;
@BOX 22.1
LOAD.A.FROM.T();
@BOX 23.1
LOAD.A.FROM.T();
@END
///11
@TITLE BSC07.28.4(1,10)
@COL 1S-8T-9T-10R-11R-4T-5R-12T-13R-14R-15R-16F
@COL 21R-2T-3R
@ROW 10-21
@FLOW 1-8N-9N-10-11-4N-5-12N-13-14-15-16
@FLOW 8Y-4
@FLOW 9Y-21-2N-3-11
@FLOW 12Y-14
@FLOW 4Y-12
@FLOW 2Y-11
@BOX 1.0
CODE OPERATOR(AP,LAP,RHAP,LHT,RHT)
@BOX 2.0
OPERAND NOT A CONSTANT
@BOX 3.0
CONVERT CONSTANT [BSC07.24]
@BOX 4.0
OPERAND NOT A CONSTANT
@BOX 5.0
CONVERT CONSTANT IF NECESSARY
@BOX 8.0
EITHER NODE LOADED
@BOX 9.0
OPS OF DIFFERENT TYPE?
@BOX 10.0
SELECT OP WHICH IS A FN REFN
TO LOAD FIRST.
OTHERWISE SELECT LHS TO LOAD FIRST
@BOX 11.0
PLANT NUM FN(LOAD):07.22:
@BOX 12.0
INCREASE IN PRECISION NOT REQUIRED?
@BOX 13.0
PL A CONV
@BOX 14.0
REVERSE OP IF NECESSARY
PL NUM FN(OP OTHER OPERAND):07.22:
@BOX 15.0
UPDATE A,B,T AS IN USE IF NECESSARY
MAKE NODE INTO A TERMINAL
NODE.
SET RESULT
@BOX 16.0
END
@BOX 21.0
CHOOSE THE SMALLEST
PRECISION TO LOAD FIRST
@BOX 1.1
PROC CODE.OPERATOR(AP,LAP,RAP,LHT,RHT);
$IN ET,W0,OP,TL.OP,LD.AP,OP.AP,T,OP.T;
AS[AP] => W0 & %1F => OP;
W0 ->> 11 & %1F => ET;
DATAVEC REV.TL.OPS($LO8)
%7F  15  15  15  15  15  15  10
%7F %7F 11 4 5 13 %7F %7F
%7F 8
END;
DATAVEC REV.T($LO8)
0   ::0 NOT USED
1   ::1 = -> =
2   ::2 /= -> /=
5   ::3 >= -> =<
6   ::4 > -> <
3   ::5 =< -> >=
4   ::6 < -> >
END
@BOX 2.1
IF AS[LD.AP] & %FF /= %80
@BOX 3.1
IF LD.AP = L.AP THEN
   CHECK.CONST(LD.AP, LHT, RHT);
ELSE
   CHECK.CONST(LD.AP, RHT, LHT);
FI
@BOX 5.1
CHECK.CONST(OP.AP, OP.T, CUR.A.TYPE);
@BOX 8.1
IF AS[LAP] & %FF = %8C OR
   AS[RAP] & %FF = %8C
@BOX 9.1
IF LHT /= RHT
@BOX 10.1
IF AS[RAP] & %FF => T = %86 OR T = %89 THEN
   RAP => LD.AP;
ELSE
   LAP => LD.AP;
FI
@BOX 11.1
PLANT.NUM.FN(INFO & %100 ! 2, LD.AP);
@BOX 4.1
IF AS[LAP] & %FF =%8C THEN
   RAP => OP.AP;
ELSE
   LAP => OP.AP;
FI
AS[OP.AP] ->> 11 => OP.T;
IF AS[OP.AP] & %FF /= %80
@BOX 12.1
TL.OPS[OP] => TL.OP;
IF INFO & %100 /= 0 OR
   [OP.T & %18 => T = CUR.A.TYPE & %18 AND
         OP.T & 7 =< CUR.A.TYPE & 7] OR
   [T /= CUR.A.TYPE & %18 AND T /= 0]
@BOX 13.1
IF TL.OP = 15 THEN
   OP.T => T;
ELSE
   ET => T;
FI
SET.A.TYPE(T ! %100);
@BOX 14.1
IF OP.AP = L.AP THEN
   REV.TL.OPS[OP] => TL.OP
FI
PLANT.NUM.FN(INFO & %100 ! TL.OP, OP.AP);
@BOX 15.1
0 => CODE.OPERATOR;
AS[AP] & %FF00 ! %8C => AS[AP];
IF TL.OP = 15 THEN
   -1 => A.AP;
   AP => T.AP;
   2 +> AS[AP];
   AS[OP.AP] & %FF => T;
   IF [OP.AP = RAP AND T /= %86 /= 89] OR
      [OP.AP = LAP AND [T = %86 OR T = %89]] THEN
      OP => TFN => CODE.OPERATOR;
   ELSE
      REV.T[OP] => TFN => CODE.OPERATOR;
   FI
ELSE
   IF INFO & %100 = 0 THEN
      AP => A.AP;
   ELSE
      AP => B.AP;
   FI
FI
@BOX 21.1
IF LHT & %18 = RHT & %18 THEN
   IF LHT & 7 >= RHT & 7 THEN
      RAP => LD.AP;
   ELSE
      LAP => LD.AP;
   FI
ELSE
   IF LHT & %18 = 0 THEN
      RAP => LD.AP;
   ELSE
      LAP => LD.AP;
   FI
FI
@BOX 16.1
END;
@END
///10
@TITLE BSC07.29(1,11)
@COL 1S-2R-3R-4F
@FLOW 1-2-3-4
@BOX 1.0
CNT.STR.OPNDS(AP)
@BOX 2.0
SET COUNT TO ZERO
@BOX 3.0
COUNT NO. OF STRING
OPERANDS IN EXPRESSION
@BOX 4.0
END
@BOX 1.1
PROC CNT.STR.OPNDS(AP);
$IN N;
PSPEC CNT($IN)/$IN;
PROC CNT(AP);
IF AS[AP] & %80 /= 0 THEN
   1 +> N;
ELSE
   CNT(AS[AP+2]);
   CNT(AS[AP+3]);
FI
END
@BOX 2.1
0 => N;
@BOX 3.1
CNT(AP);
N => CNT.STR.OPNDS;
@BOX 4.1
END
@END
//16 21.JUL.83
@TITLE BSC07.30(1,11)
@COL 1S-2T-3R-4F
@COL 5R
@ROW 3-5
@FLOW 1-2N-3-4
@FLOW 2Y-5-4
@BOX 1.0
CODE.STR.OPNDS(OPND.VECTOR,INDEX,EXPR.INDEX)INDEX
@BOX 2.0
OPERAND NOT A TERMINAL NODE ?
@BOX 3.0
ADD OPERAND SPECIFICATION TO VECTOR
@BOX 4.0
END
@BOX 5.0
CODE STR OPERANDS IN LH NODE[07.30]
CODE STR OPERANDS IN RH NODE[07.30]
@BOX 6.0
@BOX 1.1
PROC CODE.STR.OPNDS(N,IND,AP);
@BOX 2.1
IF AS[AP] & %80 = 0
@BOX 3.1
PLANT.STR(N,IND,AP, 0);
1 + IND => CODE.STR.OPNDS;
@BOX 4.1
END
@BOX 5.1
CODE.STR.OPNDS(N,IND,AS[AP+2]) => IND;
CODE.STR.OPNDS(N,IND,AS[AP+3]) => CODE.STR.OPNDS;
@END
///12
@TITLE BSC07.31(1,11)
@COL 1S-2R-3F
@FLOW 1-2-3
@BOX 1.0
PLANT BASIC FN CALL
PL.BFN.CALL(AP)
@BOX 2.0
SET UP PARAMETER EXPRESSIONS
SELECT AND PLANT CODE SEQUENCE
FOR BASIC FUNCTION [BSC07.7]
@BOX 3.0
END
@BOX 1.1
PROC PL.BFN.CALL(AP);
$IN S,F,T;
@BOX 2.1
IF AS[AP] & %100 /=0 THEN
   AS[AS[AP+3] => T+1] => EXPR.AP0;
   AS[T+2] => EXPR.AP.1;
   AS[T+3] => EXPR.AP.2;
FI
BFN.CODE.I[AS[AP+2]  => F] => S;
BFN.CODE.I[F+1] -1 => F;
PL.CD.SEQ(PART(^BFN.CODE,S,F));
@BOX 3.1
END;
@END

