*COMDECK  CCLEVX
          TITLE  CCLEVX - EVALUATE EXPRESSIONS
*         AN EXPRESSION MAY CONTAIN CONSTANTS, FUNCTIONS, SYMBOLIC
*         NAMES, AND STRING, ARITHMETIC, RELATIONAL, AND BOOLEAN
*         OPERATORS.  PARENTHESIS NESTING IS ALLOWED TO ANY DEPTH.
* 
* 
*         NUMERIC CONSTANTS ARE IN DECIMAL BASE AND MAY HAVE A POST 
*         RADIX OF *B* OR *D*.
* 
* 
*         STRING OPERATIONS ARE PERFORMED ON STRING OPERANDS.  STRING 
*         OPERANDS RESULT FROM THE *STR*, *STRB*, OR *STRD* FUNCTIONS,
*         STRING OPERATIONS, OR BOOLEAN OPERATIONS ON STRING OPERANDS.
*         THE ONLY STRING OPERATOR IS - 
* 
*         //       .CAT.       CONCATENATION OF TWO STRINGS 
* 
* 
*         ARITHMETIC OPERATIONS ARE PERFORMED IN 1-S COMPLEMENT WITH
*         48 BIT EVALUATIONS.  IF A STRING OPERAND IS INVOLVED IN AN
*         ARITHMETIC OPERATION, THE LEFTMOST WORD OF THE STRING IS
*         EXTRACTED AND USED AS A NUMERIC VALUE.
*         THE ARITHMETIC OPERATORS ARE -
* 
*         +                  ADDITION 
*         -                  SUBTRACTION
*         *                  MULTIPLICATION 
*         /                  DIVISION 
*         **     '           EXPONENTIATION 
*         LEADING -          NEGATION 
*         LEADING +          IGNORED
* 
* 
*         RELATIONAL OPERATIONS PRODUCE THE VALUE 1 IF THE RELATION 
*         IS TRUE, A VALUE OF 0 IF THE RELATION IS FALSE.  IF STRING
*         OPERANDS ARE INVOLVED, THE STRINGS ARE COMPARED LEFT TO RIGHT 
*         IN DISPLAY CODE COLLATING SEQUENCE, WITH THE SHORTER EXTENDED 
*         LOGICALLY TO THE LENGTH OF THE LONGER WITH BINARY ZEROES. 
*         THE RELATIONAL OPERATORS ARE -
* 
*         =      .EQ.        EQUALITY 
*         "      .NE.        INEQUALITY 
*         <      .LT.        LESS THAN
*         >      .GT.        GREATER THAN 
*         @      .LE.        LESS THAN OR EQUAL 
*         \      .GE.        GREATER THAN OR EQUAL
* 
* 
*         BOOLEAN OPERATIONS ARE PERFORMED ON A BIT-BY-BIT BASIS USING
*         CORRESPONDING BITS FROM EACH OPERAND.  IF STRING OPERANDS ARE 
*         INVOLVED, THE SHORTER IS EXTENDED LOGICALLY TO THE LENGTH OF
*         THE LONGER WITH BINARY ZEROES.
*         THE BOOLEAN OPERATORS ARE - 
* 
*         #      .EQV.       EQUIVALENCE
*         !      .OR.        INCLUSIVE OR 
*         &      .AND.       AND
*         ?      .XOR.       EXCULSIVE OR 
*         ^      .NOT.       COMPLEMENT 
* 
*         ORDER OF EVALUATION.
* 
*         EXPONENTIATION
*         MULTIPLICATION, DIVISION
*         ADDITION, SUBTRACTION, NEGATION, CONCATENATION
*         RELATIONS 
*         COMPLEMENT
*         AND 
*         INCLUSIVE OR
*         EXCLUSIVE OR, EQUIVALENCE 
* 
* 
*         SYMBOLIC NAMES. 
*         SYMBOLIC NAMES MAY BE USED TO REFERENCE VALUES PERTAINING 
*         TO THE JOB PROCESS. 
*         THE NAMES AND DEFINITIONS ARE THOSE OF THE SNV
*         TABLE IN THE COMMON DECK COMALL.  WHEN THE EVALUATION 
*         PROCESS IS WITHIN A FILE FUNCTION THE VALID SYMBOLIC
*         NAMES ARE DIFFERENT.  THE NAMES FOR A FILE FUNCTION 
*         ARE THOSE OF THE TABLE SNVFIL WITHIN CCLEVX 
  
 EVX      SPACE  4
  
**        CCLEVX  -  EVALUATE EXPRESSION
* 
*         ENTRY  A2  = BUFFER HEADER ADDRESS
*                X2  = BUFFER HEADER
*                - ANSSEP= SEPARATOR PRECEDING EXPRESSION 
* 
*         EXIT   - THE STRING BUFFER HAS BEEN ADVANCED THROUGH THE
*                  EXPRESSION.  THE SEPARATOR FOLLOWING THE EXPRESSION
*                  IS IN ANSSEP.
*                - THE VALUE OF THE EXPRESSION IS IN EXPVAL 
* 
*                X5  = 0 IF O.K., 1 IF ERROR IN EXPRESSION
* 
  
  
 EVXSL    EQU    V.EVXSL     EXPRESSION STACK LENGTH
  
 CCLEVX   SUBR   =
  
          SA1    ANSSEP 
          SX4    X1-1R. 
          SX1    X1-1R) 
          SX3    MSG103      STATEMENT INCOMPLETE (VERB-TERM) 
          ZR     X4,EVXERR   ERROR - TERMINATOR AFTER VERB
          ZR     X1,EVXERR   ERROR - TERMINATOR AFTER VERB
  
          SX7    1R(
          SA7    ANSSEP      FORCE LEADING OPERATOR TO BE  (
          MX6    0
          MX7    4
          SA6    EVXOSNE     ZERO NUMBER OF ENTRIES IN OPERATOR STACK 
          SA7    EVXPO       SET PREVIOUS FLAG TO ALLOW ( 
          MX7    0
          SA6    EVXPAR      ZERO NESTED PARENTHESIS COUNT
          SA7    EVXVSNE     ZERO NUMBER OF ENTRIES IN VALUE STACK
          SA6    EVXVS       ZERO FIRST ENTRY OF VALUE STACK
          SA7    EVXFIL      CLEAR FILE FUNCTION FLAG 
          SA6    EXPVAL      ZERO EXPRESSION VALUE
          SA7    EXPCHR      ZERO EXPRESSION VALUE SIZE 
          SA7    EVXINF      ZERO INFORMATIVE MESSAGE WORD
  
 EVX01    BSS 
          SA1    ANSSEP 
          SX3    MSG101 
          SX6    X1-1R. 
          NG     X1,EVXERR   IF NO SEPARATOR
  
          NZ     X6,EVX05    IF OPERATOR NOT A PERIOD 
  
*         SCAN AHEAD TO DETERMINE IF THIS IS A PERIOD BRACKETED 
*         OPERATOR.  IF NOT THEN THIS PERIOD ENDS THE STATEMENT.
*         THE SCAN IS DONE SO THAT ALL NONALPHA CHARACTERS ARE
*         SEPARATORS SO THAT NO ERROR CAN OCCUR ON THE CALL TO
*         STRANS.  FOR EXAMPLE THIS PERIOD MAY BE THE STATEMENT 
*         TERMINATOR AND IT MAY BE FOLLOWED BY ONE DOLLAR.
*         SINCE THE DOLLAR IS A COMMENT IT IS LEGAL AND 
*         NEED NOT BE BALANCED.  THE RESULT 
*         OF DOING THIS IS THAT PERIOD BRACKETED OPERATORS
*         MAY NOT CONTAIN BLANKS OR BE A LITERAL. 
  
          SX7    1
          SA2    SCATBF1
          SA7    ANSMDE      ALL NONALPHA ARE SEPARATORS
          RJ     =XSTRANS 
  
          SA2    ANSSEP 
          MX6    0
          SA6    ANSMDE      RESET MODE TO IGNORE BLANKS, ETC 
          SX7    X2-1R. 
          SA4    ANSSTR 
          SA2    EVXLBO 
          ZR     X7,EVX03    IF POSSIBLY LOGICAL OPERATOR  .OP. 
  
 EVX02    BSS 
  
*         RESET SCATTER BUFFER HEADER AND ANSSEP SO THAT
*         IT APPEARS LAST CALL TO STRANS WAS NOT MADE 
  
          SA2    ANSHBA      HEADER BEFORE LAST ASSEMBLY
          SX7    1R.         ANSSEP DID CONTAIN A PERIOD
          BX6    X2 
          BX1    X7          RESTORE X1 WITH SEPARATOR
          SA6    SCATBF1
          SA7    ANSSEP 
          JP     EVX05       GO PROCESS PERIOD AS OPERATOR
  
*         SEARCH THE TABLE OF SYMBOLS WHICH MAY BE USED AS
*         LOGICAL OR BOOLEAN OPERATORS WHEN BRACKETED BY PERIODS. 
*         IF FOUND SUBSTITUTE THE SINGLE CHARACTER FOR THAT OPERATOR. 
  
 EVX03    BSS 
          BX6    X2 
          MX0    18 
          ZR     X2,EVX02    END OF TABLE, NOT FOUND
  
          BX7    X0*X6
          BX7    X7-X4
          SA2    A2+B1
          NZ     X7,EVX03    IF NOT A MATCH 
  
*         MATCH, SET OPERATOR IN ANSSEP 
  
          MX0    -18
          BX7    -X0*X6      EXTRACT SINGLE CHARACTER 
          AX6    18 
          BX1    X7 
          SA2    X6          FETCH ENTRY FROM EVXOT 
          SA7    ANSSEP 
          JP     EVX05.1
  
  
 EVX05    BSS 
  
*                X1  = OPERATOR 
  
          SB2    X1-1R9 
          SA2    EVXMSK      BIT MASK FOR VALID OPERATOR CHARACTERS 
          AX7    X2,B2       CHECK SEPARATOR
          LX7    59 
          PL     X7,EVXERR2  IF NOT LEGAL SEPARATOR 
          CX6    X7          SET SEPARATOR INDEX
          SA2    EVXOT-1+X6  GET THIS OPERATORS ENTRY 
          BX0    X2 
          LX0    3
          PL     X0,EVX05.0  IF ALLOWED SINGLE CHARACTER OPERATOR 
  
          SX3    IP.KCLO-1
          NG     X3,EVXERR2  ABORT WITH DIAGNOSTIC MESSAGE
  
          NZ     X3,EVX05.0  IF ACCEPTING SINGLE CHARACTER OPERATOR 
  
*         ALLOW SINGLE CHARACTER OPERATOR BUT ADD INFORMATIVE MESSAGE 
  
          MX7    1
          SA7    EVXINF      ISSUE INFORMATIVE MESSAGE
 EVX05.0  BSS    0
          LX0    24-3 
          SX7    X0          ISOLATE OPERATOR PAIR TRANSLATION
          ZR     X7,EVX05.1  IF NO OPERATOR PAIR POSSIBILITY
  
          SA4    SCATBF1
          SB7    X4          CURRENT
          AX4    S.SBTOT-N.SBTOT+1
          SB6    X4          TOTAL
          GE     B7,B6,EVX05.1  IF NO MORE CHAR. IN STRING BUFFER 
  
          SA4    SCATBF1+1+B7 
          BX4    X4-X1
          NZ     X4,EVX05.1  IF NOT A PAIR
  
          SA7    EVXT2       SAVE THE TRANSLATION 
          SA2    SCATBF1
          RJ     =XSTRANS    ADVANCE THE STRING BUFFER
  
          SA1    EVXT2       TRANSLATED OPERATOR
          SA2    EVXMSK 
          BX7    X1 
          SB2    X1-1R9 
          SA7    ANSSEP 
          AX2    B2 
          CX6    X2 
          SA2    EVXOT-1+X6  GET THE NEW OPERATOR'S ENTRY 
 EVX05.1  BSS 
          SA4    EVXPO       PREVIOUS OPERATOR
          LX6    X4,B1       POSITION P CONTROL TO BIT OF NEW CONTROL 
          BX7    -X6-X2 
          LX4    X7,B1       SIGN BIT= DIFF. OF P COMPLEMENTED AND NEW
          PL     X4,EVX06    IF OPERATOR/OPERATOR SEQUENCE OK 
  
          SX7    X1-1R+ 
          SX5    X1-1R- 
          ZR     X7,EVX11     IF + ,IGNORE LEADING +
          SX1    100B        SET VALUE FOR NEGATION 
          ZR     X5,EVX05    IF LEADING - 
  
*         SEQUENCE ERROR
  
          SX3    MSG155      $OPERATOR/OPERAND SEQUENCE ERROR$
          JP     EVXERR 
  
 EVX06    BSS 
          BX6    X2          SET NEW CONTROL FLAG 
          SX0    X1-1R( 
          SA6    EVXPO       STORE THIS OPERATORS ENTRY 
          NZ     X0,EVX07    IF NOT  (
  
          SA4    EVXPAR 
          SX7    X4+B1       INCREMENT LEFT  (  COUNT 
          SA7    A4          EVXPAR 
  
*         COMPARE PRECEDENCE VALUES.
  
*                X2  = EVXOT ENTRY FOR LATEST OPERATOR
  
 EVX07    BSS 
          SA3    EVXOSNE     ENTRIES IN OPERATOR STACK
          ZR     X3,EVX08    IF STACK EMPTY 
  
          SA4    EVXOS-1+X3   CHECK PREVIOUS PRIORITY 
          SB2    X2 
          SB3    X4 
          NG     X2,EVX08    IF EQUAL NOT UNSTACK 
          GE     B3,B2,EVX09 IF NEW OPERATOR LOWER OR EQUAL 
  
*         ENTER OPERATOR IN STACK.
  
 EVX08    BSS 
          SX0    X3-EVXSL 
          BX6    X2          MOVE OPERATOR TO STACK 
          SX7    X3+B1       ADVANCE STACK
          PL     X0,EVXERR4  IF STACK OVERFLOW
  
          SA6    EVXOS+X3 
          SA7    EVXOSNE     ENTRIES IN OPERATOR STACK
          JP     EVX11       GO PROCESS OPERAND 
  
*         UNSTACK AND PROCESS OPERATOR. 
  
 EVX09    BSS 
          SX6    X3-1        UNSTACK OPERATOR 
          BX7    X2          SAVE NEW ENTRY 
          SA6    A3          EVXOS-1
          SA2    EVXVSNE     NUMBER OF ENTRIES IN VALUE STACK 
          SA7    EVXT1
          AX4    18          SET OPERATION PROCESSOR
          SB2    X4 
          BX7    X2 
          SX1    B0 
          SA3    EVXVS-1+X7  V(N) 
          PL     X3,EVX09A   IF V(N) IS POSITIVE
  
          SX7    X3+1        ADJUST VALUE STACK POINTER 
          LX3    -18         SIZE OF V(N) IN CHARACTERS 
          SX1    X3 
          SA3    EVXVS-1+X7  FIRST WORD OF V(N) 
 EVX09A   BSS    0
          SA4    EVXVS-2+X7  V(N-1) 
          SX5    B0+
          PL     X4,EVX09B   IF V(N-1) IS POSITIVE
  
          SX7    X4+2        POINTER TO FIRST WORD OF V(N-1)
          LX4    -18         SIZE OF V(N-1) IN CHARACTERS 
          SX5    X4 
          SA4    EVXVS-2+X7  FIRST WORD OF V(N-1) 
 EVX09B   BSS    0
          SX7    X7-2        UPDATE POINTER FOR VALUES UNSTACKED
          SA7    A2+
          JP     B2          EXECUTE OPERATOR PROCESS, RETURN 
                             IS TO EVX10 WITH MODIFIED VALUE
                             ELSE TO EVX11. 
  
  
*                X6  = NEW VALUE FOR VALUE STACK
  
 EVX10    BSS 
          RJ     EVXNVS      PLACE VALUE RETURNED BACK ON THE STACK 
  
          SA2    EVXT1       RESTORE ENTRY
          JP     EVX07
  
*         NOW PROCESS THE OPERAND IN ANSSTR 
*         OPERANDS MAY BE NULL,LITERALS,NUMERIC,SYMBOLIC NAME 
*         OR THE NAME OF A FUNCTION 
  
 EVX11    BSS 
          RJ     CCLGNP1
          NZ     X5,EVXERR1  ERROR INDICATED BY GNP1
  
          SA2    ANSCHR 
          SA1    ANSPSP 
          SA4    ANSLIT 
          ZR     X2,EVX01    IF NULL, PROCESS NEXT OPERATOR 
  
*         IF THE PREVIOUS SEPARATOR WAS A RIGHT PARENTHESIS THEN
*         THE PRESENCE OF AN OPERAND(ANY NON-NULL STRING) IS ILLEGAL
  
          SX1    X1-1R) 
          SX3    MSG155      $SEQUENCE ERROR$ 
          ZR     X1,EVXERR   OPERAND MUST NOT FOLLOW RIGHT PAR. 
  
          SA5    EVXFIL 
          SX3    MSG156      *STRING TOO LONG*
          ZR     X4,EVX14    IF NOT A LITERAL 
  
          NZ     X5,EVXERR3  IF WITHIN FILE FUNCTION
  
          SA5    EVXJST 
          SA1    ANSEVL 
          SA2    ANSEVLC
          BX6    X1          VALUE TO X6 IN CASE NOT WITHIN STR 
          ZR     X5,EVX19    IF NOT WITHIN STR FUNCTION 
  
*         ADD STRING TO THE VALUE STACK.
* 
*                A1 = ADDRESS OF STRING.
*                X1 = FIRST WORD OF STRING. 
*                X2 = NUMBER OF CHARACTERS IN STRING. 
  
 EVX12    BSS    0
          RJ     EVXSVS      ADD STRING TO THE VALUE STACK
  
          JP     EVX30       COMPLETE OPERAND PROCESSING
  
  
  
 EVX14    BSS 
          SA4    ANSNUM 
          SA2    ANSCHR 
          SA1    ANSSTR 
          SB2    X2-11
          SX0    A1+
          PL     B2,EVXERR9  IF STRING IS TOO LONG
  
          ZR     X4,EVX15    IF NOT NUMERIC 
  
          NZ     X5,EVXERR3  IF WITHIN FILE FUNCTION
  
          RJ     =XSTREVN    EVALUATE NUMERIC, X1= STRING 
          NZ     X5,EVXERR1  ERROR IN NUMERIC, EXIT 
  
*                X6  = VALUE OF NUMERIC 
  
          JP     EVX20
  
 EVX15    BSS 
          RJ     =XCCLSNV    FIND VALUE OF SYMBOLIC NAME
  
          NZ     X5,EVX20    IF NAME WAS KNOWN
  
*         TRY A FUNCTION NAME 
  
          SA4    EVXFN
          SA2    ANSSTR 
          MX0    42 
 EVX16    BSS 
          BX6    X0*X4
          ZR     X4,EVX17    IF END OF FUNCTION TABLE 
* 
          SB7    X4          ADDRESS OF FUNCTION
          BX6    X2-X6
          SA4    A4+B1
          NZ     X6,EVX16    NO MATCH, TRY NEXT FUNCTION
  
          SA1    EVXFIL 
          SX3    MSG153 
          SX0    MSG170      COMPONENT
          LX0    18 
          BX3    X0+X3
          NZ     X1,EVXERR   IF FUNCTION CALL FROM FILE 
  
*         FUNCTIONS WILL RETURN TO EVX01 IF NO VALUE TO ADD TO STACK
*         OR TO EVX20 IF A VALUE IS TO BE ADDED TO STACK
*         OR TO EVX12 IF A STRING IS TO BE ADDED TO STACK.
  
          JP     B7          EXECUTE FUNCTION 
  
 EVX17    BSS 
          SA1    EVXFIL 
          SA3    ANSCHR      COUNT
          SA4    ANSSEP      SEPARATOR
          SX0    X3-2 
          ZR     X1,EVX18    NOT WITHIN FILE FUNCTION 
  
          ZR     X0,FIDT     WITHIN FILE AND 2 CH - GOTO DT FUNCTION
  
*         UNKNOWN NAME IN EXPRESSION
  
 EVX18    BSS 
          SX3    MSGBUF2
          BX7    X2 
          LX3    18 
          SA7    MSGBUF2     STORE UNKNOWN NAME MESSAGE COMPONENT 
          SX0    MSG157 
          BX3    X0+X3       FORM INPUT FOR STRMSG
          JP     EVXERR 
  
  
*         RIGHT JUSTIFY STRING BEFORE ADDING IT TO THE STACK. 
  
 EVX19    ZR     X2,EVX20    IF NULL STRING 
  
          SB2    X2-11
          SX0    A1          POINT TO ANSEVL
          PL     B2,EVXERR9  IF STRING IS TOO LONG
  
          LX2    1           2*CHARACTERS 
          SB2    X2 
          LX2    1           4*CHARACTERS 
          SB2    X2+B2       6*CHARACTERS 
          LX6    B2 
  
*         ADD OPERAND TO VALUE STACK
* 
*                X6  = VALUE
  
  
 EVX20    BSS 
          RJ     EVXNVS      ADD NEW VALUE TO THE STACK 
  
 EVX30    BSS    0
          MX6    0
          SA6    EVXPO       CLEAR PREVIOUS OPERATOR FLAGS
          JP     EVX01
  
  
  
*         THE PARENTHESIS PROCESSOR WILL COME HERE IF THE EXPRESSION
*         IS COMPLETE.
  
 EVXEXIT  BSS 
          SA2    EVXVSNE     NUMBER OF ENTRIES IN VALUE STACK 
          SA4    EVXVS-1+X2 
          SX7    B0 
          PL     X4,EVXEX10  IF POSITIVE NUMERIC VALUE
  
          MX7    -18
          SX2    X4+B1       POINT TO FIRST WORD OF VALUE 
          LX4    -18
          BX7    -X7*X4 
          SA4    EVXVS-1+X2  GET FIRST WORD OF VALUE
 EVXEX10  BSS    0
          SA7    EXPCHR      SAVE VALUE SIZE INDICATOR
          SX3    MSG151      $FORMAT ERR$ 
          SX2    X2-2 
          PL     X2,EVXERR   IF MORE THAN ONE ENTRY 
          BX7    X4 
          SA7    EXPVAL      STORE VALUE OF EXPRESSION
          SA3    EVXINF 
          ZR     X3,EVXEX50  DO NOT ISSUE INFORMATIVE MESSAGE 
  
          SX3    MSG162      PERIOD BRACKETED OPERATORS PREFERRED 
          RJ     =XSTRMSG 
  
 EVXEX50  BSS 
          MX5    0           EXPRESSION IS OK 
          JP     CCLEVX      EXIT 
  
  
*         EVXERR  -  ERROR PROCESSING FOR EXPRESSIONS.
* 
*         DETERMINE WHETHER CCLEVX IS PROCESSING A .IF CONDITIONAL
*         EXPRESSION.  IF IT IS, LET BST PROCESS THE MESSAGE. OTHERWISE 
*         A MESSAGE IS ISSUED AND THEN A RETURN CODE IS SET 
*         TO INDICATE A BAD EXPRESSION AND EVX EXITS
* 
*         X3  = MESSAGE CODE FOR STRMSG 
* 
  
 EVXERR   BSS 
          SA1    PBCOND      CHECK PROCESSING OF A .IF CONDITION
          NZ     X1,EVXERR1  .IF - SKIP MESSAGE 
  
          RJ     STRMGA      ASSEMBLE AND ISSUE ABORT MESSAGE 
  
 EVXERR1  BSS 
          SX5    B1          ERROR CODE 
          MX7    0           ZERO EXPRESSION VALUE
          SA7    EXPVAL      ZERO THE EXPRESSION VALUE
          JP     CCLEVX      EXIT EXPRESSION EVALUATION 
  
  
 EVXERR2  BSS 
          BX7    X1          ILLEGAL OPERATOR 
          LX7    54          LEFT JUSTIFY 
          SA7    MSGBUF2     STORE ILLEGAL OPERATOR MESSAGE COMPONENT 
          SX3    MSG150 
          SX0    A7          MSGBUF 
          LX0    18 
          BX3    X0+X3
          JP     EVXERR      ISSUE ERR MSG. AND EXIT
  
 EVXERR3  BSS 
          SX3    MSG160      $NUMERIC/LITERAL INVALID IN FILE FUNCTION$ 
          SX0    MSG170      COMPONENT
          LX0    18 
          BX3    X0+X3       COMBINE MESSAGE COMPONENTS 
          JP     EVXERR      ISSUE MESSAGE AND ABORT
  
 EVXERR4  BSS 
          SX3    MSG161      $STACK OVERFLOW$ 
          JP     EVXERR 
  
 EVXERR5  SX3    MSG152      *POORLY FORMED FUNCTION* 
          JP     EVXERR9     COMPLETE MESSAGE, ISSUE AND ABORT
  
 EVXERR6  SX3    MSG158      *FUNCTION MUST BE FOLLOWED BY OPERATOR*
          JP     EVXERR9     COMPLETE MESSAGE, ISSUE AND ABORT
  
 EVXERR7  SX0    STRD        CURRENT ACTIVE FUNCTION (STR, STRB, STRD)
          SX1    =8L WITHIN 
          LX0    18 
          BX0    X0+X1
          SX3    MSG153      *INCORRECT FUNCTION CALL*
  
 EVXERR9  LX0    18          MERGE PARTS 2/3 WITH PART 1 OF MESSAGE 
          BX3    X0+X3
          JP     EVXERR      ISSUE MESSAGE AND ABORT
  
  
 EVXNVS   EJECT 
**        EVXNVS - PLACE A NUMERIC VALUE ON THE VALUE STACK.
* 
*         PLACES A NUMERIC VALUE AS THE LATEST ENTRY ON THE STACK.
* 
*         POSITIVE VALUES ARE STORED AS A SINGLE WORD.
*         NEGATIVE VALUES ARE STORED AS TWO WORDS. THE FIRST WORD 
*         CONTAINS THE VALUE.  THE SECOND WORD HAS BIT 59 SET, BITS 
*         35-18 CONTAIN ZERO, AND BITS 17-0 CONTAIN THE POSITION IN 
*         THE STACK OF THE FIRST WORD.
* 
*         ENTRY  (X6) = VALUE TO BE PLACED ON THE STACK.
*                AT EVXNVS1 IF ENTERED FROM EVXSVS. 
* 
*         EXIT   THROUGH B2 AFTER VALUE PLACED ON STACK.
* 
*         USES   X - 0, 3, 4, 6, 7. 
*                A - 3, 6, 7. 
*                B - 2. 
  
 EVXNVS   SUBR               ENTRY/EXIT 
          SB2    EVXNVS      SET UP EXIT
          SA3    EVXVSNE     NUMBER OF WORDS IN VALUE STACK 
  
*         ENTRY HERE FROM EVXSVS WITH NULL OR NON-STRING VALUE. 
  
 EVXNVS1  BSS    0
          SX0    X3-EVXSL 
          PL     X0,EVXERR4  IF STACK OVERFLOW
  
          PL     X6,EVXNVS3  IF VALUE IS POSITIVE 
  
          SA6    EVXVS+X3    STORE NEGATIVE VALUE IN STACK
          BX4    X3 
          SX3    X3+1 
          MX6    1           FLAG EXTENDED VALUE ENTRY
 EVXNVS2  BSS    0
          BX6    X4+X6
          SX0    X0+B1
          PL     X0,EVXERR4  IF STACK OVERFLOW
  
 EVXNVS3  BSS    0
          SX7    X3+B1
          SA6    EVXVS+X3    STORE LAST OR ONLY WORD OF STACK ENTRY 
          SA7    A3          STORE UPDATED STACK POINTER
          JP     B2          RETURN 
 EVXSVS   SPACE  4,10 
**        EVXSVS - PLACE A STRING ON THE VALUE STACK. 
* 
*         PLACES A STRING AS THE LATEST VALUE ON THE VALUE STACK. 
* 
*         STRINGS ARE STORED AS MULTIPLE WORD ENTRIES.  THE STRING
*         ITSELF IS PLACED IN THE STACK OCCUPYING AS MANY FULL WORDS AS 
*         REQUIRED TO CONTAIN IT, FOLLOWED BY A POINTER WORD WHICH HAS
*         BIT 59 SET, BITS 35-18 CONTAIN THE NUMBER OF CHARACTERS IN
*         THE STRING, AND BITS 17-0 CONTAIN THE POSITION IN THE STACK 
*         OF THE FIRST WORD OF THE STRING.
* 
*         ENTRY  (A1) = ADDRESS OF FIRST WORD OF THE STRING.
*                (X1) = FIRST WORD OF THE STRING. 
*                (X2) = NUMBER OF CHARACTERS IN THE STRING. 
* 
*         EXIT   THROUGH B2 VIA EVXNVS1 IF VALUE OR NULL STRING.
*                THROUGH B2 VIA EVXNVS2 AFTER STRING PLACED ON STACK. 
* 
*         USES   X - 0, 1, 2, 3, 4, 6, 7. 
*                A - 1, 3, 7. 
*                B - 2. 
  
 EVXSVS   SUBR               ENTRY/EXIT 
          SB2    EVXSVS      SET UP EXIT
          SA3    EVXVSNE     NUMBER OF WORDS IN VALUE STACK 
          BX6    X1 
          ZR     X2,EVXNVS1  IF STRING IS NULL OR NOT A STRING
  
          BX4    X2 
          LX4    18 
          BX4    X3+X4       STRING LENGTH AND POINTER TO FIRST WORD
          MX6    1
 EVXSVS1  BSS    0
          SX0    X3-EVXSL 
          PL     X0,EVXERR4  IF STACK OVERFLOW
  
          BX7    X1 
          SA7    EVXVS+X3 
          SX3    X3+B1
          SX2    X2-11
          NG     X2,EVXNVS2  IF FINISHED WITH STRING
  
          SA1    A1+B1
          SX2    X2+B1
          JP     EVXSVS1     PROCESS NEXT WORD OF STRING
  
          TITLE  CCLEVX - EXPRESSION OPERATOR TABLE 
*         EVXOT  -  OPERATOR TABLE
* 
*         ONE WORD PER ENTRY, DESCRIBES AN OPERATOR 
*         INDEXED BY COUNT ON CHARACTER MASK. 
* 
*         THE CONTROL FLAGS INDICATE WHICH OPERATOR MAY FOLLOW
*         OTHER OPERATORS IN THE EXPRESSION.  FOR EXAMPLE A//B
*         IS INVALID.  THE NEW FLAG OF THE NEW OPERATOR IS COMPARED 
*         TO THE PREVIOUS FLAG COMPLIMENTED AND THEY MUST BE DIFFERENT. 
* 
* 
*         1/E,1/N,1/P,1/S,20/UNUSED,18/ADDR,18/PR 
*         E      1= ALWAYS STACK
*         N      NEW CONTROL FLAG 
*         P      PREVIOUS CONTROL FLAG
*         S      1= THIS SINGLE CHAR. OPER. NOT LEGAL(PERIOD BRACKETS)
*         ADDR   ADDRESS OF PROCESSOR 
*         PR     OPERATOR PRECEDENCE VALUE
  
  
 EVXOT    BSS 
  
          VFD    1/1,1/0,1/1,21/,18/NEG,18/8 NG 
 EVXNOT   VFD    1/1,1/0,1/1,1/1,20/,18/NOT,18/5 ^
 EVXGEQ   VFD    1/0,1/1,1/1,1/1,20/,18/GEQ,18/6 \
 EVXLEQ   VFD    1/0,1/1,1/1,1/1,20/,18/LEQ,18/6 @
 EVXGT    VFD    1/0,1/1,1/1,1/0,20/,18/GTH,18/6 >
 EVXLT    VFD    1/0,1/1,1/1,1/0,20/,18/LTH,18/6 <
 EVXXOR   VFD    1/0,1/1,1/1,1/1,20/,18/XOR,18/2 ?
 EVXEXP   VFD    1/0,1/1,1/1,1/1,20/,18/EXP,18/9 '
 EVXAND   VFD    1/0,1/1,1/1,1/1,20/,18/AND,18/4 &
 EVXOR    VFD    1/0,1/1,1/1,1/1,20/,18/IOR,18/3 !
 EVXCAT   VFD    1/0,1/1,1/1,21/,18/CAT,18/7 _
 EVXNE    VFD    1/0,1/1,1/1,1/1,20/,18/NEQ,18/6 "
 EVXEQV   VFD    1/0,1/1,1/1,1/1,20/,18/EQV,18/2 #
          VFD    1/0,1/1,1/0,21/,18/000,18/0 .
          VFD    1/0,1/1,1/0,21/,18/000,18/0 ,
 EVXEQ    VFD    1/0,1/1,1/1,1/0,20/,18/EQU,18/6 =
          VFD    1/0,1/1,1/0,21/,18/000,18/0 )
 EVXLPR   VFD    1/1,1/0,1/1,21/,18/PAR,18/1 (
          VFD    1/0,1/1,1/1,3/,18/65B,18/DIV,18/8 /
          VFD    1/0,1/1,1/1,3/,18/70B,18/MUL,18/8 *
          VFD    1/0,1/1,1/1,21/,18/SUB,18/7 -
          VFD    1/0,1/1,1/1,21/,18/ADD,18/7 +
  
  
  
**        EVXLBO  -  LOGICAL/BOOLEAN OPERATORS TABLE
* 
*         CORRELATES THE PERIOD BRACKETED OPERATORS TO
*         THE SINGLE CHARACTER.  I.E. .EQ.  = 
  
 EVXLBO   BSS 
  
          VFD    18/0LNOT,6/,18/EVXNOT,18/1R^ 
          VFD    18/0LGE,6/,18/EVXGEQ,18/1R\
          VFD    18/0LLE,6/,18/EVXLEQ,18/1R@
          VFD    18/0LGT,6/,18/EVXGT,18/1R> 
          VFD    18/0LLT,6/,18/EVXLT,18/1R< 
          VFD    18/0LXOR,6/,18/EVXXOR,18/1R? 
          VFD    18/0LAND,6/,18/EVXAND,18/1R& 
          VFD    18/0LOR,6/,18/EVXOR,18/1R! 
          VFD    18/0LCAT,6/,18/EVXCAT,18/65B 
          VFD    18/0LNE,6/,18/EVXNE,18/1R" 
          VFD    18/0LEQV,6/,18/EVXEQV,18/1R# 
          VFD    18/0LEQ,6/,18/EVXEQ,18/1R= 
          CON    0
  
  
 EVXFN    BSS                FUNCTION NAMES 
          VFD    42/0LFILE,18/FILE
          VFD    42/0LLEN,18/LEN
          VFD    42/0LNUM,18/NUM
          VFD    42/0LLVL,18/LVL
          VFD    42/0LSS,18/SS
          VFD    42/0LSTR,18/STR
          VFD    42/0LSTRB,18/STR 
          VFD    42/0LSTRD,18/STR 
          CON    0
  
  
 EVXFIL   BSSZ   1           BOOLEAN,1= FILE FUNCTION IN PROCESS
 EVXINF   BSSZ   1           =1 ISSUE INFORMATIVE MESSAGE MSG162
 EVXMSK   CON    2777616576B OPERATOR MASK $+-*/()=,.#"_!&'?<> ^NG$ 
 EVXPAR   BSS    1           NESTED PARENTHESIS COUNT 
 EVXPO    BSS    1           PREVIOUS OPERATOR FLAG 
 EVXJST   BSSZ   1           LEFT JUSTIFY STRINGS FLAG
 EVXSTR   BSSZ   1           STR, STRB, STRD FUNCTION FLAG
 EVXT1    BSS    1           TEMP STORAGE 
 EVXT2    BSS    1           TEMP STORAGE 
  
*         ADDITIONAL EVX SYMBOLS ARE IN COMALL
          TITLE  CCLEVX - EXPRESSION OPERATORS
**        ADD - PROCESS ADDITION. 
  
  
 ADD      IX6    X4+X3
          JP     EVX10
  
  
**        AND - PROCESS AND.
  
  
 AND      SB2    AND1        PRESET FOR EVXPLR
          SA0    A4 
          BX0    X1+X5
 AND1     BX6    X4*X3
          EQ     EVXPLR      PROCESS LOGICAL RESULT 
  
  
*         CAT - PROCESS CONCATENATION OF TWO STRINGS. 
  
  
 CAT      SA2    SCATX       SET SCATTER BUFFER HEADER FOR SCATX
          SX2    B0 
          SB2    X5          SAVE V(N) AND SET UP FOR V(N-1) STRING 
          SA5    A3 
          SX5    X1 
          SA1    A4 
          ZR     B2,CAT2     IF V(N-1) IS NOT A STRING
  
          RJ     =XSTRUPS    UNPACK STRING V(N-1) 
  
 CAT1     SA1    A5          GET V(N) 
          SB2    X5 
          NZ     B2,CAT4     IF V(N) IS A STRING
  
          NG     X1,CAT3     IF V(N) IS NOT NULL
  
          ZR     X1,CAT5     IF V(N) IS NULL
  
 CAT2     NG     X1,CAT3     IF V(N-1) IS NOT NULL
  
          ZR     X1,CAT1     IF V(N-1) IS NULL
  
 CAT3     SX3    MSG165      *CONCATENATION MUST HAVE STRING OPERANDS*
          JP     EVXERR      ISSUE ERROR MESSAGE AND ABORT
  
 CAT4     RJ     =XSTRUPS    UNPACK STRING V(N) 
  
 CAT5     SA4    EVXVSNE     GET CURRENT VALUE STACK POINTER
          SX6    B0+
          ZR     X2,CAT6     IF SCATTER BUFFER EMPTY BOTH STRINGS NULL
  
          SA1    EVXVS+X4    POINT TO FIRST AVAILABLE LOCATION
  
          MX5    1           EXTENDED VALUE FLAG
          BX5    X4+X5       EXTENDED VALUE FLAG + FIRST WORD POINTER 
          RJ     =XSTRPKS    PACK CONCATENATED STRINGS TO VALUE STACK 
  
          SX6    B2          NUMBER OF CHARACTERS 
          LX6    18 
          BX6    X5+X6       EXT VAL FLG + NBR CHR + 1ST WD PTR 
          SX4    X4+B3       ADJUST STACK POINTER BY NUMBER OF WORDS
 CAT6     SA6    EVXVS+X4    STORE THE WORD IN THE VALUE STACK
          SX6    X4+B1       UPDATE VALUE STACK POINTER 
          SA6    A4 
          SA2    EVXT1       RESTORE OPERATOR 
          JP     EVX07       EXIT WITH STRING RESULT
  
  
**        DIV - PROCESS DIVISION. 
  
  
 DIV      IX6    X4/X3
          JP     EVX10
  
  
**        EQU - PROCESS EQ RELATION.
  
  
 EQU      RJ     EVXPRC      PERFORM RELATIONAL COMPARISON
          SX6    B1 
          ZR     X7,EQU1
          SX6    B0 
 EQU1     SA1    EVXT1       CHECK UNSTACK OPERATOR 
          SX7    X1-6 
          NZ     X7,EVX10    IF NOT RELATION
  
*         IF TWO RELATIONAL OPERATORS ARE SEPARATED ONLY BY AN
*         OPERAND THEN THE OPERATOR .AND. MUST BE INSERTED.  FOR
*         EXAMPLE -  X.LT.Y.LT.Z  IS IN FACT
*         X.LT.Y.AND.Y.LT.Z 
  
          SA3    EVXOSNE     NUMBER OF ENTRIES IN OPERATOR STACK
          SA1    EVXAND 
          BX7    X1 
          SA7    EVXOS+X3    ENTER  &  IN OPERATOR STACK
          SX7    X3+B1       ADVANCE STACK
          SA7    A3          EVXOS-1
          SA3    EVXVSNE     NUMBER OF ENTRIES IN VALUE STACK 
          SA6    EVXVS+X3    STACK RESULT OF COMPARISON 
          SX7    X3+B1
          SA7    A3          EVXVS-1
          SA1    A0+         RESTORE V(N) TO VALUE STACK
          RJ     EVXSVS 
  
          SA2    EVXT1       RESTORE OPERATOR 
          JP     EVX07
  
  
**        EQV - PROCESS EQUIVALENCE.
  
  
 EQV      SB2    EQV1        PRESET FOR EVXPLR
          SA0    A4 
          BX0    X1+X5
 EQV1     BX6    -X4-X3 
          EQ     EVXPLR      PROCESS LOGICAL RESULT 
  
  
**        EXP - PROCESS EXPONENTIAL.
  
  
 EXP      PX4    X4          PACK BASE
          SX7    1
          PX6    X7 
          NG     X3,EXP3     IF NEGATIVE EXPONENT 
          BX2    X7*X3
 EXP1     BSS 
          OR     X4,EXP3     IF EXPONENT OUT OF RANGE 
          ZR     X2,EXP2     IF POWER NOT A FACTOR
          DX6    X6*X4
          OR     X6,EXP3     IF OUT OF RANGE
 EXP2     AX3    1
          DX4    X4*X4       SQUARE BASE
          BX2    X7*X3       EXTRACT POWER OF 2 
          NZ     X3,EXP1     LOOP TO END OF EXPONENT
          UX6    X6 
          JP     EVX10
  
 EXP3     BSS 
          SX3    MSG154 
          JP     EVXERR 
  
  
**        GEQ - PROCESS GE RELATION.
  
  
 GEQ      SX6    B0          PRESET *FALSE* INDICATOR 
          RJ     EVXPRC      PERFORM RELATIONAL COMPARISON
  
 GEQ1     NG     X7,EQU1     IF (X4) .LT. (X3)
  
          SX6    B1+
          JP     EQU1 
  
  
**        GTH - PROCESS GT RELATION.
  
  
 GTH      SX6    B0          PRESET *FALSE* INDICATOR 
          RJ     EVXPRC      PERFORM RELATIONAL COMPARISON
  
          NZ     X7,GEQ1     IF VALUES NOT EQUAL
  
          JP     EQU1 
  
  
**        IOR - PROCESS INCLUSIVE OR. 
  
  
 IOR      SB2    IOR1        PRESET FOR EVXPLR
          SA0    A4 
          BX0    X1+X5
 IOR1     BX6    X4+X3
          EQ     EVXPLR      PROCESS LOGICAL RESULT 
  
  
**        LEQ - PROCESS LE RELATION.
  
  
 LEQ      SX6    B1          PRESET *TRUE* INDICATOR
          RJ     EVXPRC      PERFORM RELATIONAL COMPARISON
  
          NZ     X7,LTH1     IF VALUES NOT EQUAL
  
          JP     EQU1 
  
  
**        LTH - PROCESS LT RELATION.
  
  
 LTH      SX6    B1          PRESET *TRUE* INDICATOR
          RJ     EVXPRC      PERFORM RELATIONAL COMPARISON
  
 LTH1     NG     X7,EQU1     IF LESS
  
          SX6    B0+
          JP     EQU1 
  
  
**        MUL - PROCESS MULTIPLICATION. 
  
  
 MUL      IX6    X4*X3
          JP     EVX10
  
  
**        NEG - PROCESS NEGATION. 
  
  
 NEG      BX6    -X3         COMPLEMENT V(N)
          JP     NOT1 
  
  
**        NEQ - PROCESS NE RELATION.
  
  
 NEQ      RJ     EVXPRC      PERFORM RELATIONAL COMPARISON
          SX6    B1 
          NZ     X7,EQU1
          SX6    B0 
          JP     EQU1 
  
  
**        NOT - PROCESS NOT.
  
  
 NOT      SX6    B0+
          NZ     X1,NOT1     IF NON-NULL STRING - *TRUE*
          NZ     X3,NOT1     IF *TRUE*
          SX6    B1+
  
*         SINCE .NOT. ONLY OPERATES ON ONE VALUE THE VALUE STACK
*         MUST BE RESET TO INDICATE THE CORRECT NUMBER OF ENTRIES 
  
 NOT1     BSS 
          SB4    EVXVS       ADDRESS OF VALUE STACK 
          SX7    A3-B4       RESTORE V(N-1) TO STACK
          SA7    A2 
          JP     EVX10       STACK RESULT 
  
  
**        PAR - PROCESS *(* 
  
*         NOTE THAT THE ONLY OPERATORS WHICH FORCES EXECUTION OF
*         PAR IS THE RIGHT  )  OR COMMA OR THE PERIOD.  PAR UPDATES 
*         THE OPERATOR STACK TO REMOVE THE LEFT  (  AND THEN THE
*         COUNT OF NESTED PARENTHESES IS EXAMINED TO DETERMINE IF 
*         THE EXPRESSION IS COMPLETE.  IF OTHER NESTED PARENTHESES
*         EXIST THE RETURN TO EVX10 CAUSES THE  )  TO GET LOST, THUS
*         THE LEFT AND RIGHT PARENTHESES HAVE BEEN PAIRED.
  
 PAR      BSS 
          SA5    EVXPAR 
          SA4    EVXFIL 
          SX7    X5-1        DECREMENT PARENTHESIS NESTING LEVEL
          BX6    X2 
          SA7    A5 
          SA6    EVXVSNE     RESET NUMBER OF ENTRIES OF VALUE STACK 
          ZR     X7,EVXEXIT  IF NEST ZERO, END OF EXPRESSION
  
          BX6    X4-X7
          NZ     X6,PAR1     IF NOT AT END OF *FILE* FUNCTION 
          SA6    A4 
 PAR1     BSS 
          SA1    EVXSTR 
          BX6    X1-X7
          ZR     X6,STR2     IF END OF STR FUNCTION 
  
 PAR2     BSS    0
          SA1    ANSSEP 
          SX0    X1-1R) 
          ZR     X0,EVX11    CONTINUE IF RIGHT  ) 
  
*         IF THE OPERATOR THAT CAUSED EXECUTION WAS NOT A  )
*         THEN IT MUST BE A COMMA OR PERIOD.  THE EXPRESSION
*         MUST BE POORLY FORMED BECAUSE THE NESTING LEVEL OF
*         PARENTHESIS IS NOT ZERO.
  
          SX3    MSG151 
          JP     EVXERR 
  
  
**        SUB - PROCESS SUBTRACTION.
  
  
 SUB      IX6    X4-X3
          JP     EVX10
  
  
**        XOR - PROCESS EXCLUSIVE OR. 
  
  
 XOR      SB2    XOR1        PRESET FOR EVXPLR
          SA0    A4 
          BX0    X1+X5
 XOR1     BX6    X4-X3
          EQ     EVXPLR      PROCESS LOGICAL RESULT 
  
 EVXPRC   SPACE  4,20 
**       EVXPRC - PERFORM RELATIONAL COMPARISON.
* 
*         IF NEITHER VALUE TO BE COMPARED IS A STRING, A ONE-WORD 
*                ARITHMETIC COMPARISON IS DONE, (X4)-(X3).
*         IF BOTH VALUES TO BE COMPARED ARE STRINGS, A DISPLAY CODE 
*                SEQUENCE COMPARISON IS DONE ON THE STRINGS.
*         IF ONLY ONE OF THE VALUES TO BE COMPARED IS A STRING, THE 
*                OTHER IS CONSIDERED A STRING FOR THE COMPARISON. 
* 
*         ENTRY  X1 = SIZE OF V(N), ZERO IF V(N) IS NOT A STRING. 
*                X3 = V(N). 
*                X4 = V(N-1). 
*                X5 = SIZE OF V(N-1), ZERO IF V(N-1) IS NOT A STRING. 
*                A3 = ADDRESS OF V(N).
*                A4 = ADDRESS OF V(N-1).
* 
*         EXIT   X7 .EQ. X4-X3 IF NEITHER X3 NOR X4 CONTAINS A STRING,
*                   .LT. 0 IF THE X4 STRING .LT. THE X3 STRING, 
*                   .EQ. 0 IF BOTH STRINGS ARE EQUAL, 
*                   .GT. 0 IF THE X4 STRING .GT. THE X3 STRING. 
*                X2 = SIZE OF V(N). 
*                A0 = ADDRESS OF V(N).
* 
*         USES   X - 0, 1, 2, 3, 4, 5, 7. 
*                A - 0, 3, 4. 
  
 EVXPRC   SUBR               ENTRY/EXIT 
          SA0    A3+         SAVE SECOND OPERAND IN CASE SERIES 
          BX2    X1          SAVE SIZE OF SECOND OPERAND
          IX7    X4-X3
          BX0    X1+X5
          ZR     X0,EVXPRCX  IF NEITHER OPERAND IS A STRING 
  
 EVXPRC1  BX7    X4-X3
          NZ     X7,EVXPRC4  IF DIFFERING WORD FOUND
  
          SX1    X1-11
          SX5    X5-11
          PL     X1,EVXPRC3  IF X3 STRING NOT EXHAUSTED 
  
          NG     X5,EVXPRCX  IF BOTH EXHAUSTED THEY ARE EQUAL 
  
 EVXPRC2  IX7    X5-X1       SET EXIT CONDITIONS
          JP     EVXPRCX     RETURN 
  
 EVXPRC3  NG     X5,EVXPRC2  IF X4 STRING EXHAUSTED 
  
          SA3    A3+B1
          SA4    A4+B1
          SX1    X1+B1
          SX5    X5+B1
          EQ     EVXPRC1     COMPARE NEXT WORD
  
 EVXPRC4  MX0    30 
          LX3    30 
          LX4    30 
          BX1    -X0*X3 
          BX5    -X0*X4 
          IX7    X5-X1
          ZR     X7,EVXPRC4  IF DIFFERENCE IS IN THE OTHER HALF WORD
  
          JP     EVXPRCX
 EVXPLR   SPACE  4,45 
**       EVXPLR - PROCESS LOGICAL RESULT. 
* 
*         STORES THE RESULT OF THE LOGICAL OPERATION JUST PERFORMED,
*         CAUSES THE SAME OPERATION TO BE REPERFORMED FOR SUBSEQUENT
*         WORDS OF THE OPERANDS, AND UPDATES THE VALUE STACK WITH THE 
*         RESULT. 
* 
*         ENTRY  X0 = 0 IF NEITHER OPERAND IS A STRING, 
*                     NON-ZERO IF ONE OR BOTH ARE STRINGS.
*                X1 = REMAINING CHARACTERS IN V(N). 
*                X3 = WORD OF V(N) JUST PROCESSED.
*                X4 = WORD OF V(N-1) JUST PROCESSED.
*                X5 = REMAINING CHARACTERS IN V(N-1). 
*                X6 = RESULT OF OPERATION ON X4 AND X3. 
*                A0 = ADDRESS FOLLOWING LAST NON-NULL WORD OF RESULT. 
*                A3 = ADDRESS OF WORD OF V(N) JUST PROCESSED. 
*                A4 = ADDRESS OF WORD OF V(N-1) JUST PROCESSED. 
*                B2 = PROCESSING ADDRESS. 
* 
*         EXIT   IF OPERATION IS NOT COMPLETE, EXIT THROUGH B2, WITH
*                X0 = UNCHANGED.
*                X1 = REMAINING CHARACTERS IN V(N). 
*                X3 = WORD OF V(N) TO BE PROCESSED. 
*                X4 = WORD OF V(N-1) TO BE PROCESSED. 
*                X5 = REMAINING CHARACTERS IN V(N-1). 
*                A0 = ADDRESS FOLLOWING LAST NON-NULL WORD OF RESULT. 
*                A3 = ADDRESS OF NEXT WORD OF V(N) TO BE PROCESSED. 
*                A4 = ADDRESS OF NEXT WORD OF V(N-1) TO BE PROCESSED. 
*                B2 = UNCHANGED.
* 
*                IF OPERATION IS COMPLETE, EXIT IS TO EVX07 WITH
*                THE RESULT PLACED ON THE VALUE STACK AND THE 
*                STACK POINTER *EVXVSNE* UPDATED. 
* 
*         USES   X - ALL. 
*                A - 0, 2, 3, 4, 6, 7.
*                B - 3. 
  
 EVXPLR   SA6    A4          STORE WORD OF RESULT 
          SA4    A4+B1       GET POSSIBLE NEXT WORD OF V(N-1) 
          SX3    B0+         PRESET V(N) TO ZERO
          NG     X6,EVXPLR1  IF NEGATIVE, RESULT IS NOT NULL
  
          ZR     X6,EVXPLR2  IF POSITIVE ZERO, RESULT IS NULL 
  
 EVXPLR1  SA0    A4+         SET RESULT LENGTH
 EVXPLR2  SX5    X5-11
          SX1    X1-11
          NG     X5,EVXPLR5  IF V(N-1) IS EXHAUSTED 
  
          SX5    X5+1 
 EVXPLR3  NG     X1,EVXPLR4  IF V(N) IS EXHAUSTED 
  
          SA3    A3+B1       GET NEXT WORD OF V(N)
          SX1    X1+B1
 EVXPLR4  JP     B2          PROCESS CURRENT WORDS
  
 EVXPLR5  SX4    B0+         SET V(N-1) TO ZERO 
          PL     X1,EVXPLR3  IF V(N) IS NOT EXHAUSTED 
  
          SA2    EVXVSNE     GET CURRENT POSITION IN VALUE STACK
          SB3    EVXVS+X2 
          SX7    A0-B3       NUMBER OF WORDS IN RESULT
          ZR     X7,EVXPLR8  IF RESULT IS NULL
  
          NZ     X0,EVXPLR6  IF AT LEAST ONE VALUE WAS A STRING 
  
          PL     X6,EVXPLR8  IF NUMERIC RESULT WAS POSITIVE 
  
          SX6    B0 
          EQ     EVXPLR7     COMPLETE PROCESSING OF POINTER WORD
  
 EVXPLR6  SX6    X7          WORDS
          LX6    2           WORDS*4
          IX6    X6+X7       WORDS*5
          LX6    1+18        NUMBER OF CHARACTERS IN BITS 35-18 
 EVXPLR7  BX6    X6+X2       MERGE CHARACTER COUNT AND OFFSET 
          IX2    X2+X7       INCREMENT VALUE STACK POINTER
          MX7    1           SET THE EXTENDED OPERAND FLAG
          BX6    X6+X7
          SA6    A0+
 EVXPLR8  SX7    X2+B1       UPDATE VALUE STACK POINTER 
          SA7    A2 
          SA2    EVXT1       RESTORE ENTRY OPERATOR 
          JP     EVX07       EXIT 
          TITLE  CCLEVX - FUNCTION PROCESSORS - FILE FUNCTION 
***       FILE(LFN,<EXPRESSION>)
*         FILE STATUS FUNCTION. 
* 
* 
*         THE FILE STATUS FUNCTION MAY BE USED TO DETERMINE THE 
*         STATUS OF ANY FILE ASSIGNED TO THE JOB. 
* 
*         LFN = FILE NAME.
* 
*         THE EXPRESSION IS AN EXPRESSION DEFINED AS ABOVE, WITH
*         A DIFFERENT LIST OF SYMBOLIC NAMES. 
* 
  
 FILE     BSS 
  
          SA5    ANSSEP 
          SX0    X5-1R( 
          NZ     X0,FILE6    ERROR IF NOT ( 
  
          RJ     CCLGNP1
          NZ     X5,EVXERR1  ERROR INDICATED BY GNP1
  
          SA5    ANSSEP 
          SX0    X5-1R, 
          NZ     X0,FILE6    IF SEPARATOR AFTER FILE NAME NOT , 
  
          SA5    ANSCHR 
          SA4    ANSNUM 
          SA3    ANSLIT 
          SX0    X5-8 
          ZR     X5,FILE6    ERROR IF NULL
          PL     X0,FILE6    ERROR IF MORE THAN 7 CHARS.
          IFNE   HOST,NOS,1 
          NZ     X4,FILE6    ERROR IF NUMERIC FILE NAME 
          NZ     X3,FILE6    ERROR IF LITERAL FILE NAME 
  
          SA5    ANSSTR      FILE NAME
  
          RJ     =XIOFIL     OBTAIN FILE INFORMATION
  
*         ZERO VALUE FIELD OF ALL SNVFIL ENTRIES
  
          MX7    0
          SA7    SNVDT       CLEAR OLD DEVICE TYPE WORD 
          SB3    B0          OFFSET COUNTER 
          MX2    -N.SNVVAL
          ERRNZ  N.SNVVAL-S.SNVVAL-1
  
 FILE1    BSS 
          SA1    SNVFIL+B3
          SB3    B3+1 
          BX7    X1*X2       ZERO VALUE FIELD 
          BX3    -X2*X1      SAVE POSSIBLE OFFSET 
          LX1    59-S.SNVOFF
          PL     X1,FILE1A   CLEAR VALUE
  
          MX7    0
          SA7    SNVWRD+X3   CLEAR VALUE IN COMALL TABLE SNVWRD 
          JP     FILE1       NEXT ENTRY 
  
 FILE1A   BSS    0
          SA7    A1          RESTORE WORD 
          NZ     X7,FILE1    CONTINUE UNTIL END OF TABLE
* 
          SA1    FILADR+W.FMSTS  STATUS WORD RETURNED BY FILINFO
          BX3    X1 
          MX2    -1 
          NZ     X3,FILE1B   IF FILE WITH SPECIFIED LFN EXISTS
  
          SA5    SNVZL       FILE DOES NOT EXIST - SET ZERO LENGTH TRUE 
          BX7    -X2+X5 
          SA7    A5 
          JP     FILE5       DONE WITH THIS FILE - CLEAN UP AND EXIT
  
 FILE1B   BSS    0
          SA5    SNVAS
          BX7    -X2+X5      SET TRUE FOR SNVAS 
          SA7    A5          RESTORE SNVAS
          LX3    N.FMDT 
          MX5    -12
          BX7    -X5*X3      NEW DEVICE TYPE
          SA7    SNVDT       RESTORE WORD 
  
*         PROCESS TABLE OF 1 BIT FILE FIELDS
*         SET CORRESPONDING 0 BIT IN SNVFIL WHEN FIELD IN X1 IS NONZERO 
*         THE FIELDS ARE POSITIONED BY S.FMXXX IN FLDTAB
  
  
          SB4    LFLDTAB-1   TABLE OFFSET 
 FILE2    BSS 
          SA3    FLDTAB+B4   ENTRY FROM TABLE 
          SB5    X3          ISOLATE S.FMXXX
          SB6    59 
          SB5    B6-B5             59-S.FMXXX 
          LX2    B5,X1
          SB4    B4-1 
          PL     X2,FILE3    BIT NOT SET - CK FOR END 
* 
          AX3    30          POSITION TO ADDRESS OF SNVXXX WORD 
          MX2    -21
          BX3    -X2*X3 
          SA3    X3          ENTRY IN SNVXXX
          MX2    -1 
          BX7    -X2+X3 
          SA7    A3          RESTORE SNVXXX WITH BIT 0 SET
 FILE3    BSS 
          PL     B4,FILE2    CONTINUE UNTIL TABLE END 
  
 OSNOS    IFEQ   HOST,NOS 
*         DETERMINE READ/MODIFY (SNVRM) RM=RU+RA
*         DETERMINE MODIFY (SNVMD) MD=UP+AP 
  
          EX5    X1,FMRU
          ZR     X5,FILE3A   NO READ/MODIFY PERMISSION
  
          EX5    X1,FMRA
          ZR     X5,FILE3A   NO READ MODIFY PERMISSION
  
          SA3    SNVRM
          BX7    X3+X5
          SA7    A3          STORE READ/MODIFY PERMISSION 
  
 FILE3A   BSS    0
          EX5    X1,FMUP
          ZR     X5,FILE3B   NO MODIFY PERMISSION 
  
          EX5    X1,FMAP
          ZR     X5,FILE3B   NO MODIFY PERMISSION 
  
          SA3    SNVMD
          BX7    X5+X3
          SA7    A3          STORE MODIFY PERMISSION
  
 OSNOS    ENDIF 
  
*         ISOLATE FILE TYPE FROM X1 
*                0=LOCAL,1=INPUT,2=QUEUED/PRINT,3=PUNCH,4=PERMFILE
*                5=LOCKED COMMON, 6=PRIMARY, 7=LIBRARY, 77=OTHER
  
 FILE3B   BSS    0
          MX5    -N.FMTYP 
          SB5    TYPMAX 
          BX5    -X5*X1      ISOLATED FILE TYPE 
          SB4    X5 
          GT     B4,B5,FILE4 NOT A KNOWN FILE TYPE
  
          SX5    1
          SA3    SNVTYP+B4
          IX3    X3+X5       SET BIT 0 IN ORIGINAL WORD 
          BX7    X3 
          SA7    A3          RESTORE WORD INDICATING FILE TYPE
          SB7    SNVPF-SNVTYP 
          NE     B4,B7,FILE3.5     TYPE IS NOT *PF* 
  
          SA3    SNVPM
          BX7    X3+X5
          SA7    A3          SET *PM*=*PF*
 FILE3.5  BSS 
          SB7    SNVLK-SNVTYP 
          NE     B4,B7,FILE4 TYPE SETTING IS NOT SNVLK
  
          SA3    SNVCM
          BX7    X3+X5       SET BIT 0 IN SNVCM 
          SA7    A3          RESTORE SNVCM
  
*         PLACE EQUIPMENT NUMBER (EST ORDINAL) INTO SYMBOL TABLE
  
 FILE4    BSS 
          SA1    FILADR+W.FMEST   STATUS WORD RETURNED BY FILINFO 
          EX7    X1,FMEST 
          MX5    N.FMEST
          LX5    N.FMEST     POSITION TO CLEAR OLD SNVEQ
          SA1    SNVEQ
          BX1    -X5*X1 
          BX7    X1+X7
          SA7    A1          RESTORE SNVEQ
  
 OSNOS    IFEQ   HOST,NOS 
  
*         GET FILE ID USING STATUS MACRO
  
          SA3    FILADR+W.FMLFN 
          MX7    N.FMLFN
          BX7    X7*X3       ISOLATE LFN TO STORE IN FET
          SX0    B1 
          BX7    X0+X7       SET COMPLETE BIT FOR STATUS MACRO
          SA7    FILESTS     STORE FOR STATUS MACRO 
  
  
          SX2    FILESTS
          STATUS X2,P 
  
*         WORD 6 OF FET CONTAINS FILE ID IN UPPER 6 BITS
  
          SA2    FILESTS+6
          MX0    6
          BX6    X0*X2       ISOLATE ID 
          LX6    6
          SA2    SNVID
          BX6    X2+X6
          SA6    SNVID       STORE FILE ID
 OSNOS    ENDIF 
  
*         PLACE SIZE OF FILE (LENGTH IN SECTORS) IN THE SYMBOL TABLE
  
          SA3    FILADR+W.FMFS
          EX7    X3,FMFS     EXTRACT FILE SIZE
          SX6    B0+         PRESET FILE NOT ZERO LENGTH
          SA7    SNVFS       SAVE SIZE
          NZ     X7,FILE4.5  FILE IS NOT ZERO LENGTH
  
          SX6    1           INDICATE FILE IS ZERO LENGTH 
  
 FILE4.5  BSS    0
          SA1    SNVZL       STORE TRUE FALSE VALUE OF ZL 
          BX7    X6+X1
          SA7    A1 
  
 OSNOS    IFEQ   HOST,NOS 
  
*         DETERMINE WHETHER THE FILE IS ON THE GLOBAL LIBRARY SET.
  
          SX7    SNVGLL      INITIALIZE GLOBAL LIBRARY ARGUMENT 
          LX7    36 
          SA7    ARGGL
          GETGLS ARGGL
          SB7    LSNVGLL
          SB6    B0 
          SA2    FILADR+W.FMLFN 
          ERRNZ  59-S.FMLFN 
          MX7    N.FMLFN
          BX3    X2*X7       FILE NAME FROM CALL
          ERRNZ  59-S.GLNAME
          MX7    N.GLNAME 
  
 FILE4.6  BSS    0           SEARCH LIST FOR MATCH
          EQ     B6,B7,FILE4.7   END OF LIST
          SA1    SNVGLL+B6
          SB6    B6+1 
          ZR     X1,FILE4.7  END OF LIST
  
          BX6    X1*X7
          BX0    X3-X6
          NZ     X0,FILE4.6  KEEP SEARCHING 
          NG     X0,FILE4.6  KEEP SEARCHING 
  
          SX6    1
          SA1    SNVGL
          BX7    X1+X6       INDICATE FILE IS GLOBAL
          SA7    A1 
  
 FILE4.7  BSS    0
 OSNOS    ENDIF 
  
 FILE5    BSS 
          SA5    EVXPAR 
          BX6    X5 
          SX7    1R(
          SA6    EVXFIL      FLAG WITHIN FILE FUNCTION
          SA7    ANSSEP      NEXT PASS THROUGH EVX OPERATOR = ( 
          JP     EVX01
  
 FILE6    BSS 
          SX3    MSG151      =EXPRESSION FORMAT ERROR 
          SX0    MSG170      = IN FILE FUNCTION 
          LX0    18 
          BX3    X0+X3
          JP     EVXERR      GOTO ERROR PROCESSOR 
  
  
***       FIDT - PROCESS DT FUNCTION WITHIN FILE FUNCTION 
* 
*         INPUT - X2 = ANSSTR 
*                 X3 = ANSCHR 
*                 X4 = ANSSEP 
* 
*         CASE 1.  DT .AND. SEP .NE. ( --> DT 
*         CASE 2.  DT .AND. SEP .EQ. ( --> DT(XX) 
*         CASE 3.  .NOT. DT .AND. 2 CH --> XX 
* 
* 
 FIDT     BSS 
          SX0    2RDT 
          LX0    48          LEFT JUSTIFY 
          BX0    X0-X2
          NZ     X0,FIDT2    NOT DT 
  
          SX0    X4-1R( 
          ZR     X0,FIDT1    CASE 2. DT AND ( 
  
*         CASE 1.  DT AND SEPARATOR .NE. (
  
          SA3    SNVDT
          BX6    X3 
          JP     FIDT3       EXIT DT FUNCTION 
  
*         CASE 2.  DT AND SEPARATOR = ( 
  
 FIDT1    BSS 
  
          RJ     CCLGNP1     ADVANCE STRING 
          NZ     X5,EVXERR1  ERROR INDICATED BY GNP1
  
          SA4    ANSSEP 
          SX0    X4-1R) 
          NZ     X0,FIDT4   ERROR IF ANSSEP .NE. )
  
          SA2    ANSSTR 
          BX7    X2 
          SA7    FILTMP 
  
*         ADVANCE STRING AGAIN
  
          RJ     CCLGNP1
          NZ     X5,EVXERR1  ERROR INDICATED BY GNP1
  
          SA3    ANSCHR 
          NZ     X3,FIDT5    ERROR IF ANSCHR IS NOT NULL
  
          SA2    FILTMP 
  
*         CASE 3.  X2 = STRING LEFT JUSTIFIED 
  
 FIDT2    BSS 
          SA3    SNVDT
          LX3    48 
          SX6    1           TRUE INDICATION
          IX3    X2-X3
          ZR     X3,FIDT3    EXIT DT FUNCTION 
  
          MX6    0           FALSE INDICATION 
 FIDT3    BSS 
          JP     EVX20       EXIT - ADD VALUE TO STACK
  
  
 FIDT4    BSS 
          SX0    MSG173      *DT* 
          JP     EVXERR5     *POORLY FORMED FUNCTION* 
  
 FIDT5    BSS 
          SX0    MSG173      *DT* 
          JP     EVXERR6     *FUNCTION MUST BE FOLLOWED BY OPERATOR*
  
 FLDTAB   BSS 
          VFD    30/SNVEOI,30/S.FMEOI 
          VFD    30/SNVEOF,30/S.FMEOF 
          VFD    30/SNVBOI,30/S.FMBOI 
          VFD    30/SNVLB,30/S.FMLAB
          VFD    30/SNVTP,30/S.FMNT 
          VFD    30/SNVTP,30/S.FMMT 
          VFD    30/SNVOP,30/S.FMOPN
          VFD    30/SNVTT,30/S.FMTRM
          VFD    30/SNVMS,30/S.FMMS 
          VFD    30/SNVEX,30/S.FMEXO
          VFD    30/SNVRA,30/S.FMRA 
 OSNOS    IFEQ   HOST,NOS 
          VFD    30/SNVRU,30/S.FMRU 
          VFD    30/SNVUP,30/S.FMUP 
          VFD    30/SNVAP,30/S.FMAP 
 OSNOS    ELSE
          VFD    30/SNVRM,30/S.FMRM 
          VFD    30/SNVMD,30/S.FMMD 
          VFD    30/SNVEN,30/S.FMEN 
 OSNOS    ENDIF 
          VFD    30/SNVWR,30/S.FMWR 
          VFD    30/SNVRD,30/S.FMRD 
 LFLDTAB  EQU    *-FLDTAB 
  
 FILTMP   BSSZ   1
  
 SNVDT    BSSZ   1           LOCATION FOR DEVICE TYPE CODE
  
*         THE SYMBOLIC NAME TABLE FOR USE WITH THE FILE FUNCTION
*                SEE FM FIELD DEFINITIONS FOR SYMBOL DESCRIPTIONS 
  
 SNVFIL   BSS                SYMBOLS FOR FILE FUNCTION
 SNVEOI   CON    0LEOI
 SNVEOF   CON    0LEOF
 SNVBOI   CON    0LBOI
 SNVLB    CON    0LLB 
 SNVOP    CON    0LOP 
 SNVAS    CON    0LAS 
 SNVTT    CON    0LTT 
 SNVTP    CON    0LTP 
 SNVMS    CON    0LMS 
 SNVEX    CON    0LEX 
*         PERMISSIONS 
 SNVRA    CON    0LRA 
 OSNOS    IFEQ   HOST,NOS 
 SNVRU    CON    0LRU        READ UPDATE
 SNVUP    CON    0LUP        UPDATE 
 SNVAP    CON    0LAP        APPEND 
  
 OSNOS    ELSE
 SNVEN    CON    0LEN 
 OSNOS    ENDIF 
  
 SNVWR    CON    0LWR 
 SNVRD    CON    0LRD 
 SNVRM    CON    0LRM 
 SNVMD    CON    0LMD 
*         FILE TYPES
 SNVTYP   BSS 
          CON    0LLO 
          CON    0LIN 
 OSNOS    IFEQ   HOST,NOS 
          CON    0LQF 
 OSNOS    ELSE
          CON    0LPR 
 OSNOS    ENDIF 
          CON    0LPH 
 SNVPF    CON    0LPF 
 SNVLK    CON    0LLK 
          CON    0LPT        PRIMARY TYPE 
          CON    0LLI        LIBRARY TYPE 
 TYPMAX   EQU    *-SNVTYP-1  MAXIMUM FILE TYPE CODE 
 SNVCM    CON    0LCM        DUPLICATE NAME FOR SNVLK 
 SNVPM    CON    0LPM        DUPLICATE NAME FOR SNVPF 
 SNVEQ    CON    0LEQ 
 SNVID    CON    0LID        FILE ID VALUE
          VFD    42/0LFS,1/1,2/0,15/SNVFS-SNVWRD  FILE SIZE IN SECTORS
 SNVZL    CON    0LZL        ZERO LENGTH
 OSNOS    IFEQ   HOST,NOS 
 SNVGL    CON    0LGL        GLOBAL LIBRARY 
 OSNOS    ENDIF 
          CON    0
 OSNOS    IFEQ   HOST,NOS 
  
*         TABLE TO HOLD THE LIST OF GLOBAL LIBRARIES (GETGLS MACRO).
*         THE CYBER LOADER REFERENCE MANUAL INDICATES THAT 24 
*         LIBRARIES ARE THE MAXIMUM.  SEE DESCRIPTION OF THE LIBRARY
*         COMMAND.
  
 SNVGLL   BSS    0
          BSSZ   24 
 LSNVGLL  EQU    *-SNVGLL    END OF TABLE 
          BSSZ   1
  
 ARGGL    VFD    6/0,18/SNVGLL,36/0   GETGLS ARGUMENT 
  
 FILESTS  FILEC  ,,FET=7
 OSNOS    ENDIF 
          TITLE  CCLEVX - FUNCTION PROCESSORS - LEN FUNCTION. 
**        LEN - DETERMINE LENGTH OF STRING. 
* 
*         ENTRY  STATEMENT IN SCATBF1 ADVANCED THROUGH LEN(.
* 
*         EXIT   (X6) = LENGTH OF STRING ENCLOSED IN PARENTHESES. 
  
  
 LEN      BSS    0
          SA1    ANSSEP 
          SX0    =0LLEN      *LEN*
          SX1    X1-1R( 
          NZ     X1,EVXERR5  IF BAD SEPARATOR *POORLY FORMED FUNCTION*
  
          RJ     CCLGNP1     FETCH FIRST STRING 
  
          NZ     X5,EVXERR1  IF ERROR FROM GNP1 
  
          SA2    ANSLIT      LITERAL FLAG 
          SA1    ANSCHR      LENGTH OF STRING 
          ZR     X2,LEN1     IF NOT A LITERAL 
  
          SA1    ANSEVLC     LENGTH OF LITERAL
 LEN1     BX6    X1 
          SA3    ANSSEP 
          SX0    =0LLEN      *LEN*
          SX1    X3-1R) 
          NZ     X1,EVXERR5  IF BAD SEPARATOR *POORLY FORMED FUNCTION*
  
          SA6    EVXT2       SAVE LENGTH
          RJ     CCLGNP1     ADVANCE PAST LEN FUNCTION
  
          NZ     X5,EVXERR1  IF ERROR FROM GNP1 
  
          SA1    EVXT2       FETCH LENGTH 
          SA5    ANSCHR 
          BX6    X1 
          ZR     X5,EVX20    IF NORMAL EXIT 
  
          SX0    =0LLEN      *LEN*
          JP     EVXERR6     *FUNCTION MUST BE FOLLOWED BY OPERATOR*
          TITLE  CCLEVX - FUNCTION PROCESSORS - NUM FUNCTION
**        NUM  -  NUMERIC FUNCTION
  
* 
* 
*         THE NUMERIC STATUS FUNCTION MAY BE USED TO DETERMINE
*         IF THE STRING WITHIN THE NUM FUNCTION IS A NUMERIC STRING 
*         THE FUNCTION MUST BE FORMED AS:    NUM(STRING)
* 
* 
*         ENTRY  STATEMENT IN SCATBF1 ADVANCED THROUGH NUM( 
* 
*         EXIT   X6 = 1 IF STRING IN NUM IS NUMERIC, ELSE X6=0
  
  
 NUM      BSS                ENTRY
          SA1    ANSSEP 
          SX0    MSG172      =NUM 
          SX1    X1-1R( 
          NZ     X1,EVXERR5  IF BAD SEPARATOR *POORLY FORMED FUNCTION*
  
          RJ     CCLGNP1
          NZ     X5,EVXERR1  ERROR INDICATED BY GNP1
  
          SA2    ANSNUM 
          SA5    ANSCHR 
          SA1    ANSSTR 
          SB3    1R0
          SB4    1R9
          SB6    10 
          ZR     X2,NUM5     IF NOT NUMERIC 
  
          SB7    X5 
          MX7    -6 
          LX1    6           SHIFT FIRST CHARACTER TO LOWER BITS
  
*         THE CHARACTER STRING BEGINS WITH A NUMERIC CHARACTER. 
*         EXAMINE EACH CHARACTER TO DETERMINE IF THE ENTIRE 
*         STRING IS NUMERIC (POST RADIX OF  B  OR  D ALLOWED).
  
 NUM1     BSS 
          BX0    -X7*X1      EXTRACT CHARACTER
          SB7    B7-B1
          SB6    B6-B1
          SB5    X0 
          LT     B0,B7,NUM2  IF THIS IS NOT LAST CHAR.
  
          SX6    X0-1RB 
          SX5    X0-1RD 
          ZR     X6,NUM4     OK IF LAST CHAR IS   B 
          ZR     X5,NUM4     OK IF LAST CHAR IS   D 
  
 NUM2     BSS 
          LT     B5,B3,NUM5  NON-NUMERIC IF LT 0
          LT     B4,B5,NUM5  NON-NUMERIC IF GT9 
          LT     B0,B6,NUM3  IF MORE CHARACTERS IN WORD 
  
          SA1    A1+B1       GET NEXT WORD
          SB6    10 
 NUM3     BSS 
          LX1    6           SHIFT NEXT CHARACTER TO LOWER BITS 
          LT     B0,B7,NUM1  IF MORE CHARACTERS IN STRING 
  
 NUM4     BSS 
          SX6    B1          CHARACTER STRING IS NUMERIC
          JP     NUM6 
  
 NUM5     BSS 
          SX6    0
 NUM6     BSS 
          SA1    ANSSEP 
          SX0    MSG172      =NUM 
          SA6    EVXT2       STORE NUMERIC FLAG 
          SX1    X1-1R) 
          NZ     X1,EVXERR5  IF BAD SEPARATOR *POORLY FORMED FUNCTION*
  
          RJ     CCLGNP1     ADVANCE TO NEXT OPERATOR AFTER NUM 
          NZ     X5,EVXERR1  ERROR INDICATED BY GNP1
  
          SA1    EVXT2       GET NUMERIC FLAG 
          SA5    ANSCHR 
          BX6    X1 
          ZR     X5,EVX20    EXIT IF NULL 
  
          SX0    MSG172      =NUM 
          JP     EVXERR6     *FUNCTION MUST BE FOLLOWED BY OPERATOR*
 LVL      TITLE  CCLEVX - FUNCTION PROCESSORS - LVL FUNCTION
**        LVL - RELEASE LEVEL FUNCTION. 
* 
*         RETURNS THE RELEASE LEVEL OF THE PRODUCT REQUESTED BY 
*         THE OPERAND.  THE VALUE OF THE OPERAND MUST MATCH THE 
*         INDEX OF SOME ENTRY IN THE TABLE OF RELEASE LEVELS. 
* 
*         ENTRY STATEMENT IN SCATBF1 ADVANCED THROUGH LVL(. 
* 
*         EXIT   (X6) = RELEASE LEVEL NUMBER OF THE PRODUCT SPECIFIED.
*                       0 IF THE SPECIFIED PRODUCT IS AN OPERATING
*                         SYSTEM OTHER THAN THE HOST SYSTEM.
  
  
 LVL      BSS    0           ENTRY
          SA4    ANSSEP 
          BX5    X5-X5       PRESET FOR NO OPERAND CASE 
          BX1    X1-X1
          SX6    X4-1R( 
          SX0    =0LLVL      *LVL*
          NZ     X6,LVL4     IF NO OPERAND ASSUME *SYS* 
  
          RJ     CCLGNP1     GET NEXT OPERAND 
  
          NZ     X1,EVXERR1  IF ERROR FROM GNP1 
  
          SA4    ANSNUM 
          SA1    ANSSTR 
          ZR     X4,LVL2     IF NOT A NUMERIC STRING
  
          RJ     =XSTREVN    EVALUATE NUMERIC 
  
          NZ     X5,LVL3     IF GOOD NUMERIC VALUE
  
 LVL1     BSS    0
          SX3    MSG157      * UNKNOWN NAME * 
          SX0    ANSSTR 
          JP     EVXERR9     ISSUE ERROR MESSAGE
  
 LVL2     BSS    0
          RJ     =XCCLSNV    EVALUATE SYMBOLIC VALUE
  
          ZR     X5,LVL1     IF SYMBOLIC NAME NOT FOUND 
  
 LVL3     BSS    0
          SX1    X6-TLVLL    CHECK AGAINST LENGTH OF PRODUCT TABLE
          PL     X1,LVL1     IF VALUE GREATER THAN NUMBER OF PRODUCTS 
  
          SA3    ANSSEP 
          SX0    =0LLVL      *LVL*
          SX1    X3-1R) 
          NZ     X1,EVXERR5  IF BAD SEPARATOR *POORLY FORMED FUNCTION*
  
          SA6    EVXT2       SAVE INDEX TO PRODUCT TABLE
          RJ     CCLGNP1     ADVANCE TO NEXT OPERATOR 
  
          NZ     X5,EVXERR1  IF ERROR FROM GNP1 
  
          SA1    EVXT2
          SA5    ANSCHR 
 LVL4     BSS    0
          SA1    TLVL+X1     PICK UP RELEASE LEVEL FOR PRODUCT
          BX6    X1 
          ZR     X5,EVX20    IF NOT JUST SEPARATOR FOLLOWING FUNCTION 
  
          SX0    =0LLVL 
          JP     EVXERR6     *FUNCTION MUST BE FOLLOWED BY OPERATOR*
          TITLE  CCLEVX - FUNCTION PROCESSORS - STR FUNCTION. 
**        STR - INITIATE PROCESSING OF THE STR, STRB, OR STRD FUNCTION. 
* 
*         STR, STRB, AND STRD EACH RETURN EXTENDED STRING RESULTS.  AN
*                EXTENDED STRING IS LEFT JUSTIFIED AND MAY BE ANY 
*                LENGTH UP TO THE MAXIMUM LENGTH OF A LINE. 
* 
*         STR    PRIMARILY WORKS ON STRINGS(LITERALS), BUT WILL CONVERT 
*                VALUES TO STRINGS BY LEFT JUSTIFYING THE CONTENTS OF 
*                THE WORD.  ALL STRINGS PROCESSED WITHIN *STR* ARE
*                EXTENDED STRINGS.  CONCATENATION OF STRINGS AND STRING 
*                COMPARISONS MAY BE DONE WITHIN A *STR* FUNCTION. 
* 
*         STRB   CONVERTS A VALUE TO A STRING IN OCTAL NOTATION.
*                STRINGS ARE TREATED THE SAME AS ANY OTHER VALUE. 
*                WITHIN *STRB* STRINGS ARE RIGHT JUSTIFIED VALUES,
*                BUT THE RESULT STRING IS AN EXTENDED STRING. 
* 
*         STRD   CONVERTS A VALUE TO A STRING IN DECIMAL NOTATION.
*                STRINGS ARE TREATED THE SAME AS ANY OTHER VALUE. 
*                WITHIN *STRD* STRINGS ARE RIGHT JUSTIFIED VALUES,
*                BUT THE RESULT STRING IS AN EXTENDED STRING. 
* 
*         ENTRY  STATEMENT IN SCATBF1 ADVANCED THROUGH STR(.
* 
*         EXIT   INITIALLY TO EVX01 TO PROCESS THE ( OPERATOR.
  
 STR      BSS    0           ENTRY
          SA1    ANSSEP 
          SA5    ANSSTR      NAME OF FUNCTION CALLED
          SX0    A5          ADDRESS OF FUNCTION NAME 
          SX1    X1-1R( 
          BX6    X5 
          SA5    EVXSTR 
          NZ     X1,EVXERR5  IF BAD SEPARATOR *POORLY FORMED FUNCTION*
  
          NZ     X5,EVXERR7  IF ALREADY WITHIN STR, STRB OR STRD
  
          SA1    EVXPAR      PARENTHESIS NEST LEVEL 
          SA5    =0LSTR 
          SA6    STRD        SAVE FUNCTION NAME 
          SX7    B0+
          BX5    X5-X6
          SX6    X1 
          SA7    STRA        CLEAR SUBSTRING TERM COUNTER 
          SA6    EVXSTR      SET STR FUNCTION PARENTHESIS NEST LEVEL
          NZ     X5,EVX01    IF STRB OR STRD NO LEFT JUSTIFICATION
          SA6    EVXJST      SET LEFT JUSTIFY STRINGS FLAG
          JP     EVX01       PROCESS ( OPERATOR 
  
*         COMPLETE PROCESSING OF STR, STRB, OR STRD FUNCTION. 
* 
*         ENTRY  X2 = VALUE STACK POINTER.
*                A2 = ADDRESS OF VALUE STACK POINTER. 
* 
*         EXIT   TO EVX11 IF FUNCTION IS COMPLETE.
*                   FINAL RESULT STRING IS ON THE STACK.
*                TO EVX06 IF FUNCTION IS NOT COMPLETE, TO FAKE A LEFT 
*                   PARENTHESIS OPERATOR. 
*                   X1 = (. 
*                   X2 = OPERATOR TABLE ENTRY FOR (.
* 
*         USES   X - ALL. 
*                A - 1, 2, 3, 4, 5, 6, 7. 
*                B - 2, 3.
  
 STR2     SA5    STRA 
          NZ     X5,STR16    IF ORIGINAL STRING ALREADY PROCESSED 
  
          SA1    STRD 
          LX1    6*3
          AX1    6*9
          SX4    X1-1RB      MARK FUNCTION TYPE 
          SA1    EVXVS-1+X2 
          SX7    B0+         CLEAR LEFT JUSTIFY STRINGS FLAG
          SA7    EVXJST 
          BX6    X1 
          PL     X1,STR3     IF A POSITIVE NUMERIC
  
          LX6    -18
          SA1    EVXVS+X1    GET FIRST WORD OF VALUE
          SX0    X6 
          BX6    X1 
          NZ     X0,STR7     IF IT IS ALREADY A STRING
  
          SX2    X2-1        ADJUST STACK POINTER 
 STR3     PL     X4,STR8     IF STRB OR STRD FUNCTION 
  
*         PROCESSING STR FUNCTION.
  
          MX0    6
          LX6    -6 
          NG     X1,STR4     NEGATIVE ZERO IS NOT NULL
  
          ZR     X1,STR7     IF NULL VALUE
  
 STR4     LX6    6
          BX1    X0*X6
          ZR     X1,STR4     IF JUSTIFICATION STILL NEEDED
  
          SA6    EVXVS-1+X2  STORE JUSTIFIED WORD 
          SX4    X2-EVXSL 
          PL     X4,EVXERR4  IF STACK OVERFLOW
  
          SX4    11          COMPUTE CHARACTER COUNT
 STR5     LX0    6
          BX3    X0*X6
          SX4    X4-1 
          ZR     X3,STR5     IF CHARACTER NOT FOUND 
  
          SX0    X2-1 
          MX1    1
          BX1    X0+X1
          LX4    18          STORE THE POINTER WORD 
          BX6    X1+X4
 STR6     SA6    EVXVS+X2 
          SX7    X2+B1       INCREMENT VALUE STACK POINTER
          SA7    A2 
 STR7     SA5    STRA 
          JP     STR18       CHECK FOR END OF FUNCTION
  
*         PROCESSING STRB OR STRD FUNCTION. 
  
 STR8     SX7    X2-1        REMOVE VALUE FROM STACK
          SA7    A2+
          SA2    SCATX       SET UP SCATTER BUFFER HEADER 
          SX2    B0 
          BX5    X1 
          PL     X1,STR9     IF VALUE IS POSITIVE 
  
          BX5    -X1         CONVERT AND PROTECT FROM STRUPS
          SB2    B1 
          SA1    =1L-        PUT SIGN IN SCATX
          RJ     =XSTRUPS 
  
 STR9     BX6    X2 
          SA6    A2 
          ZR     X4,STR14    IF FUNCTION IS STRB
  
*         PROCESSING STRD FUNCTION. 
  
          SA3    =1000000000
          BX1    X5 
          BX4    X3 
          IX0    X5/X3
          ZR     X0,STR10    IF VALUE IS NINE DIGITS OR LESS
  
          IX5    X4*X0
          IX1    X1-X5
          IX5    X1+X4       BIAS AND PROTECT FROM CDD AND STRUPS 
          BX1    X0 
          RJ     =XCDD       CONVERT UPPER PORTION TO DISPLAY 
  
          SX0    B2          CONVERT BIT COUNT TO CHARACTERS
          SX1    6
          IX2    X0/X1
          SB2    X2 
          BX1    X4 
          SA2    SCATX
          RJ     =XSTRUPS    UNPACK CONVERTED CHARACTERS
  
          BX6    X2 
          SA6    A2 
          BX1    X5 
 STR10    RJ     =XCDD       CONVERT LOWER PORTION TO DISPLAY 
  
          ZR     X0,STR11    IF NOT BIASED LOWER PORTION
  
          LX4    6
          SB2    B2-6 
 STR11    SX5    6
          SX6    B2          CONVERT BIT COUNT TO CHARACTERS
          IX2    X6/X5
          SB2    X2 
          BX1    X4 
 STR12    SA2    SCATX
          RJ     =XSTRUPS 
  
          SA3    EVXVSNE
          SA1    EVXVS+X3 
          BX5    X2 
          EX0    X5,SBTOT 
          SX4    10          COMPUTE NUMBER OF WORDS
          SX0    X0+9 
 STR13    IX0    X0-X4
          SX3    X3+B1
          PL     X0,STR13    IF NOT FINISHED
  
          SX0    X3-EVXSL-1 
          PL     X0,EVXERR4  IF STACK OVERFLOW
  
          RJ     =XSTRPKS 
  
          SA2    EVXVSNE
          SX6    B2          NUMBER OF CHARACTERS 
          LX6    18 
          MX4    1
          BX6    X2+X6
          SX2    X2+B3       ADJUST STACK POINTER BY NUMBER OF WORDS
          BX6    X4+X6
          JP     STR6        COMPLETE STACK UPDATE AND EXIT 
  
*         PROCESSING STRB FUNCTION. 
  
 STR14    MX0    30 
          BX1    X0*X5
          ZR     X1,STR15 
  
          BX5    X5-X1
          AX1    30 
          RJ     =XCOD       CONVERT UPPER HALF TO OCTAL DISPLAY
  
          SX0    B2          CONVERT BIT COUNT TO CHARACTERS
          SX1    6
          IX2    X0/X1
          SB2    X2 
          BX1    X4 
          SA2    SCATX
          RJ     =XSTRUPS    UNPACK CONVERTED CHARACTERS
  
          BX6    X2 
          SA6    A2 
          SX0    B0+         FLAG EXTENSION NEEDED
 STR15    BX1    X5 
          RJ     =XCOD       CONVERT LOWER HALF TO OCTAL DISPLAY
  
          NZ     X0,STR11    IF SINGLE WORD RESULT
          SA1    =66666666666666666666B 
          SB3    B2-B1       CONSTRUCT MASK TO CONVERT BLANK FILL 
          MX0    1
          AX0    B3 
          BX1    -X0*X1 
          BX1    X1-X4       CONVERT BLANKS TO DISPLAY ZERO 
          LX1    B2          REJUSTIFY
          SB2    10 
          JP     STR12       COMPLETE STRING OUTPUT 
  
  
*         PROCESSING START OR END POSITION TERM.
  
 STR16    SA4    EVXVS-1+X2 
          PL     X4,STR17    IF TOP STACK VALUE IS POSITIVE NUMERIC 
  
          SX2    X4+1        ADJUST STACK POINTER 
          LX4    -18
          SX4    X4 
          SX0    STRD        FUNCTION NAME
          NZ     X4,EVXERR5  IF NOT NUMERIC *POORLY FORMED FUNCTION*
  
          SA4    EVXVS-1+X2 
 STR17    SX6    X2-1        UPDATE STACK POINTER 
          SA6    A2+
          BX6    X4          SAVE THE CHARACTER POSITION VALUE
          SA6    STRB-1+X5
  
*         CHECK FOR END OF FUNCTION.
  
 STR18    SA4    ANSSEP 
          SX2    X5-2 
          SX3    X4-1R) 
          SX1    X4-1R, 
          ZR     X3,STR19    IF END OF FUNCTION 
  
          SX0    STRD        FUNCTION NAME
          NZ     X1,EVXERR5  IF BAD SEPARATOR *POORLY FORMED FUNCTION*
  
          PL     X2,EVXERR5  IF TOO MANY TERMS
  
          SX6    X5+B1       INCREMENT TERM COUNT 
          SA6    A5 
          SX1    1R(
          SA2    EVXLPR 
          JP     EVX06       PROCESS ( OPERATOR 
  
*         END OF FUNCTION - EXTRACT THE SUBSTRING.
*                X1 = TERM COUNT. 
*                X2 = TERM COUNT - 2. 
  
 STR19    ZR     X5,STR30    IF NO SUBSTRING TERMS LEAVE AS IS
  
          SA3    EVXVSNE     VALUE STACK POINTER
          SA1    EVXVS-1+X3 
          SX6    X1          POINTER TO FIRST WORD OF STRING
          LX1    -18
          SB2    X1          SIZE OF STRING 
          ZR     B2,STR30    IF NULL STRING NO MORE TO DO 
  
          SA1    EVXVS+X6 
          SA6    A3          REMOVE THE STRING FROM THE STACK 
          SX6    B2          SAVE THE STRING LENGTH 
          SA6    STRC 
          ZR     X2,STR20    IF END POSITION WAS SPECIFIED
  
          SA6    STRB+1 
 STR20    SA2    SCATX       SET UP EMPTY SCATX HEADER
          SX2    B0 
          RJ     =XSTRUPS    UNPACK THE STRING TO SCATX BUFFER
  
          SA1    STRB        START POSITION 
          SA4    STRC        LENGTH OF STRING 
          PL     X1,STR21    IF POSITIVE START POSITION 
  
          IX1    X4+X1       CALCULATE START CHARACTER
          SX1    X1+B1
 STR21    ZR     X1,STR22    IF START IS BEFORE BEGINNING OF STRING 
  
          PL     X1,STR23    IF START POSITION IS POSITIVE
  
 STR22    SX1    B1+         POINT TO BEGINNING OF STRING 
          JP     STR24       BYPASS STRING LENGTH CHECK 
  
 STR23    IX0    X4-X1
          NG     X0,STR27    IF START POSITION BEYOND STRING LENGTH 
  
 STR24    SA3    STRB+1      END POSITION 
          PL     X3,STR25    IF POSITIVE END POSITION 
  
          IX3    X4+X3       CALCULATE END CHARACTER
          SX3    X3+B1
 STR25    ZR     X3,STR27    IF END IS BEFORE BEGINNING OF STRING 
  
          NG     X3,STR27    IF END IS BEFORE BEGINNING OF STRING 
  
          IX0    X4-X3
          PL     X0,STR26    IF END POSITION WITHIN STRING LENGTH 
  
          BX3    X4 
 STR26    IX0    X3-X1
          PL     X0,STR28    IF START POSITION NOT AFTER END POSITION 
  
 STR27    BSS    0
          SA2    EVXVSNE     VALUE STACK POINTER
          SX6    B0+         SET UP NULL ENTRY
          JP     STR29       PLACE NULL ENTRY INTO VALUE STACK
  
 STR28    SA2    SCATX-1+X1 
          SX0    X0+B1
          SX6    B0 
          OX2    X6,X0,SBTOT  SET UP THE SCATTER BUFFER HEADER
          SA3    EVXVSNE
          SA1    EVXVS+X3    POINT TO PACKED STRING DESTINATION 
          RJ     =XSTRPKS    PACK THE SUBSTRING INTO THE STACK
  
          SA2    EVXVSNE
          SX6    B2          NUMBER OF CHARACTERS 
          LX6    18 
          MX4    1
          BX6    X2+X6
          BX6    X4+X6
          SX2    X2+B3       ADJUST STACK POINTER BY NUMBER OF WORDS
 STR29    SA6    EVXVS+X2    STORE THE WORD IN THE VALUE STACK
          SX6    X2+B1       UPDATE VALUE STACK POINTER 
          SA6    A2 
 STR30    SX6    B0+         CLEAR THE STR FUNCTION FLAG
          SA6    EVXSTR 
          JP     EVX11       EXIT WITH STRING RESULT
  
 STRA     BSS    1           TERM COUNTER 
 STRB     BSS    2           START AND END POSITION FOR SUBSTRING 
 STRC     BSS    1           LENGTH OF STRING 
 STRD     BSS    1           FUNCTION NAME
 STRE     VFD    24/0,18/STRD,18/MSG152 
