*DECK C$UNST
          IDENT  C$UNST 
          TITLE  C$UNST - PROCESS UNSTRING STATEMENT
  
          MACHINE  ANY,I
          COMMENT  PROCESS UNSTRING STATEMENT 
          SST 
          B1=1
 C.UNSTR  SPACE  4
* 
*         C.UNSTS  - PROCESS UNSTRING 
* 
*         CALLING SEQUENCE
*                RJ  C.UNSTS
* 
*         INPUT 
*                B3 = SOURCE ADDRESS
*                B4 = SOURCE BCP (+ SUBSC CHAR OFFSET IF SUBSCRIPTED) 
*                B5 = PARAMETER LIST ADDRESS
*                B6 = LAST PARAMETER ADDRESS
*                X1 = POINTER VALUE IN BINARY 
*                X2 = TALLYING VALUE IN BINARY
*                X3 = SOURCE LENGTH 
* 
*         VFD    6/TYPE,18/LENGTH,18/OFFSET,18/ADDRESS
*           REPEATED FOR EACH DELIMITER, DELIMITER IN, COUNT IN, AND
*           RESULT OPERAND
* 
*      THE PARAMETERS ARE GENERATED IN THE FOLLOWING ORDER
*       [ POINTER                    ] * IF POINTER 
*       [ TALLYING                   ] * IF TALLYING
*       [ FIRST DELIMITER            ] * IF DELIMITED BY
*       [ SECOND DELIMITER           ]
*         . . . 
*         FIRST RESULT
*       [ FIRST DELIMITER IN         ] * IF DELIMITER IN
*       [ FIRST COUNT IN             ] * IF COUNT IN
*         SECOND RESULT 
*       [ SECOND DELIMITER IN        ] * IF DELIMITER IN
*       [ SECOND COUNT IN            ] * IF COUNT IN
*         . . . 
* 
*         TYPE HAS THE FOLLOWING VALUES - 
*      NOTE THAT IDENTIFIER DELIMITERS HAVE TYPES OF 40B AND ABOVE, 
*      OTHER OPERANDS ARE 37B AND BELOW, SO OBJECT ROUTINES CAN USE 
*      PL AND NG INSTRUCTIONS TO CHECK FOR DELIMITERS TO SEARCH FOR.
*         00B = ALPHANUMERIC OPERAND
*         01B = JUSTIFIED RIGHT ALPHANUMERIC OPERAND
*         02B = SIGNED LEFT CHARACTER DISPLAY NUMBERIC OPERAND
*         03B = SIGNED LEFT OVERPUNCHED DISPLAY NUMERIC OPERAND 
*         04B = SIGNED RIGHT CHARACTER DISPLAY NUMERIC OPERAND
*         05B = SIGNED RIGHT OVERPUNCHED DISPLAY NUMERIC OPERAND
*         06B = UNSIGNED DISPLAY NUMERIC OPERAND
*         07B = BINARY NUMERIC OPERAND
*         10B = DELIMITER IN IDENTIFIER 
*         11B = JUSTIFIED RIGHT DELIMITER IN IDENTIFIER 
*         12B = SIGNED LEFT CHARACTER DISPLAY NUMBERIC COUNT IN IDENT 
*         13B = SIGNED LEFT OVERPUNCHED DISPLAY NUMERIC COUNT IN IDENT
*         14B = SIGNED RIGHT CHARACTER DISPLAY NUMERIC COUNT IN IDENT 
*         15B = SIGNED RIGHT OVERPUNCHED DISPLAY NUMERIC COUNT IN ID
*         16B = UNSIGNED DISPLAY NUMERIC COUNT IN IDENTIFIER
*         17B = BINARY NUMERIC COUNT IN IDENTIFIER
*         32B = POINTER SIGNED LEFT CHARACTER (FIRST PARAM) 
*         33B = POINTER SIGNED LEFT OVERPUNCH 
*         34B = POINTER SIGNED RIGHT CHARACTER
*         35B = POINTER SIGNED RIGHT OVERPUNCH
*         36B = POINTER UNSIGNED NUMERIC
*         37B = POINTER BINARY
*         42B = TALLYING SIGNED LEFT CHARACTER  (FOLLOWS POINTER) 
*         43B = TALLY SIGNED LEFT OVERPUNCH 
*         44B = TALLY SIGNED RIGHT CHARACTER
*         45B = TALLY SIGNED RIGHT OVERPUNCH
*         46B = TALLY UNSIGNED NUMERIC
*         47B = TALLY BINARY
*         60B = IDENTIFIER DELIMITER (ALSO INSPECT BEFORE DELIMITER)
*         61B = ALL IDENTIFIER DELIMITER
* 
*         OUTPUT
*         B7     = 0 IF NO OVERFLOW 
*                = 1 IF OVERFLOW
* 
*         USES -
*                C.MOVE,C.INSPT,STRSUBS 
*                ASSUMES B1=1 
*                ALL REGISTERS
* 
*         REGISTER CONVENTIONS (VERY GENERALLY FOLLOWED)
*                X0   AVOIDED WHEN POSSIBLE, ELSE TEMP
*                X1   AVOIDED WHEN POSSIBLE, ELSE POINTER 
*                X2   TEMP OR MASK
*                X3   AVOIDED WHEN POSSIBLE, ELSE TEMP
*                X4   LOAD REGISTER FOR PARAMS
*                X5   TEMP, RESULTS OF BOOLEAN MASKS
*                X6   STORE OR SAVE 
*                X7   STORE OR SAVE 
* 
*         PHILOSOPHY OF DESIGN
*         THE C.UNSTR ROUTINE SHOULD DO AS MUCH OF THE UNSTRING VERB
*         OPERATION AS POSSIBLE. IT SHOULD BE FAST AND AS SMALL AS
*         POSSIBLE. NUMERIC OPERANDS ARE THE BANE OF THIS OPERATION,
*         DUE TO THEIR VARIED CHARACTERISTICS. SINCE THE UNSTRING VERB
*         IS EXPECTED TO BE USED RELATIVELY FEW TIMES WHEN IT IS USED,
*         AND THERE ARE ONLY TWO NUMERIC OPERANDS TO BE INPUT--THE
*         POINTER AND THE TALLYING ITEM, THE MOVES OF POINTER AND 
*         TALLYING ITEM TO REGISTERS ARE DONE IN-LINE, BEFORE THE 
*         OBJECT ROUTINE, RATHER THAN IN A COMPREHENSIVE NUMERIC TO 
*         REGISTER MOVE ROUTINE. HOWEVER, THERE ARE TWO MORE KINDS OF 
*         NUMERIC RESULTS--COUNT IN ITEMS AND NUMERIC RESULT FIELDS.
*         THEREFORE A COMPREHENSIVE REGISTER TO NUMERIC MOVE ROUTINE
*         IS USED TO MOVE ALL NUMERIC REGISTERS TO NUMERIC RESULTS. 
*         THE OTHER PROBLEM OPERATION IS ON-OVERFLOW PROCESSING. THIS 
*         IS SOLVED BY RETURNING THE POINTER AND LENGTH, AND DOING
*         THE TEST IN-LINE. 
  
          TITLE  ROUTINE INITIALIZATION 
          ENTRY  C.UNSTS
 C.UNSTS  DATA   0
          BX7    X3 
          SA7    SRCLENG
          BX7    X2 
          SA7    TALLYING 
  
*      CHECK IF POINTER VALUE INITIALLY OUT OF RESULT FIELD SIZE RANGE
  
          SX2    B1                * TEST FOR LESS THAN 1 
          IX2    X1-X2
          NG     X2,OVERFLOW
          SX2    X3+1              * TEST FOR GREATER THAN RESULT LENGTH
          IX2    X1-X2
          NG     X2,PTROKAY 
 OVERFLOW BSS    0
          SB7    B1 
          EQ     C.UNSTS
  
 PTROKAY  BSS    0
  
          SPACE  4
*      ADD POINTER - 1 TO SOURCE ADDRESS. 
  
          SB4    X1+B4
          SB4    B4-B1
  
*      DECREMENT SOURCE LENGTH BY POINTER - 1.
*      THIS, PLUS THE ABOVE, ELIMINATES THE SOURCE CHARACTERS IN FRONT
*      OF THE CHARACTER THE POINTER POINTS TO.
  
          IX3    X3-X1
          SX3    X3+B1
  
          SPACE  4
*      FINISH SOURCE FIELD SUBSCRIPT CALCULATIONS.
  
          RJ     =XSTRSUBS         * STRSUBS INPUT: B3 = ADDR, B4 = OFFS
                                   *    OUTPUT: B3 = NEW ADDR, B4 = BCP 
                                   *          USES: X2, X4, X5
  
          SPACE  4
*      SAVE REGISTER PARAMETERS SO C.INSPT AND MOVE ROUTINES CAN BE 
*      CALLED.
  
          SX7    B3 
          SA7    SRCADDR           * B3 = SOURCE ADDRESS (MODIFIED) 
          SX7    B4 
          SA7    SRCBCP            * B4 = SOURCE BCP (MODIFIED) 
  
                                   * B5 = PARAMETER ADDRESS 
          SX7    B6 
          SA7    PARMEND           * B6 = LAST PARAMETER ADDRESS + 1
          BX7    X1 
          SA7    POINTER           * X1 = POINTER VALUE 
          BX7    X3 
          SA7    SRCLNSV           * SAVE RESULT LENGTH FOR MAIN LOOP 
  
          SPACE  4
*      CHECK FOR POINTER ITEM PARAMETER. IF PRESENT, IT IS THE FIRST
*      PARAMETER. 
  
          SA4    B5                * FIRST OPERAND IN X4
          MX2    3
          BX5    X2*X4
          LX5    3
          SX7    3
          IX5    X7-X5             * X5 = 30B - TYPE
          SX7    B0                * X7 = 0 IF NO POINTER 
  
*      IF THE TYPE IS 30B, THE FIRST PARAMETER IS A POINTER ITEM AND
*      X7 IS SET TO THE PARAMETER. IF NOT, X7 IS SET TO 0.
  
          NZ     X5,NOPTR          * SKIP IF NOT A POINTER PARAM
          BX7    X4                * POINTER PARAM
          SA4    A4+B1             * GET NEXT PARAMETER 
  
 NOPTR    BSS    0
          SA7    PTRPARAM          * SAVE POINTER PARAMETER 
  
          SPACE  4
*      CHECK FOR TALLYING PARAMETER. IF PRESENT, IT IMMEDIATELY FOLLOWS 
*      THE POINTER PARAMETER IF ANY.
  
          BX5    X2*X4
          LX5    3
          SX7    4
          IX5    X7-X5             * X5 = 31B - TYPE
          SX7    B0                * X7 = 0 IF NO TALLYING ITEM 
  
*      IF THE TYPE IS 31B, THE PARAMETER IS A TALLYING ITEM AND 
*      X7 IS SET TO THE PARAMETER. IF NOT, X7 IS SET TO 0.
  
          NZ     X5,NOTALLY        * SKIP IF NO TALLYING ITEM 
          BX7    X4                * TALLYING PARAM 
          SA4    A4+B1
  
 NOTALLY  BSS    0
          SA7    TALLYPAR          * SAVE TALLYING PARAMETER
  
          SX7    A4 
          SA7    DELBEGIN          * SAVE DELIMITER FIRST ADDRESS 
  
          SPACE  4
*      CHECK FOR DELIMITERS, THEY ARE ALL AT THE BEGINNING OF THE 
*      PARAMETER LIST, FOLLOWING THE POINTER AND TALLYING PARAMETERS. 
*      X4 = FIRST DELIMITER OPERAND, IF ANY.
  
*      LOOP UNTIL FIRST NONDELIMITER PARAMETER IS FOUND.
  
 DELLOOP  BSS    0
          PL     X4,LASTDEL        * EXIT WHEN NONDELIM TYPE IS FOUND 
          SA4    A4+B1             * (LEFTMOST BIT CLEAR) 
          EQ     DELLOOP           * THERE MUST BE A NONDELIM PARAMETER 
  
*      SAVE FIRST OPERAND ADDRESS 
  
 LASTDEL  BSS    0
          SX7    A4 
          SA7    PARMAD            * SAVE FIRST OPERAND ADDRESS 
  
          TITLE  MAIN LOOP PREPROCESSING
*      MAIN UNSTRING SOURCE OPERAND LOOP. DOES--
*         GETS OPERAND AND FINISHES SUBSCRIPTING. 
*         LOOPS, CALLING C.INSPT, UNTIL A DELIMITER MATCH IS FOUND. 
*         MOVES SOURCE SUBSTRING TO RECEIVING DATA ITEM.
*         MOVES DELIMITER FOUND TO DELIMITER-IN DATA ITEM.
*         MOVES CHARACTER COUNT TO COUNT-IN DATA ITEM.
  
 MAINLOOP BSS    0
  
*      PARMAD POINTS TO THE PARAMETER TO BE PROCESSED 
  
          SA4    PARMAD 
          SA4    X4 
          BX7    X4 
          SA7    PARMSAVE          * SAVE PARAMETER 
  
*      DECODE THE LENGTH OF THE PARAMETER RESULT FIELD INTO X7. 
*      IF THE TYPE OF THE RESULT IS SIGNED SEPARATE CHARACTER, USE
*      LENGTH - 1. PERTINENT TYPES ARE 02B AND 04B. 
  
          MX2    6
          BX0    X2*X4
          LX0    6                 * TYPE CODE IN X0
          MX2    42 
          LX4    24 
          BX7    -X2*X4            * X7 = LENGTH OF PARAMETER OPERAND 
          SX2    B1+B1
          IX5    X2-X0
          ZR     X5,CHARTYPE       * TYPE 2--CHANGE LENGTH
          LX2    1
          IX5    X2-X0
          NZ     X5,NOTCHAR        * NOT TYPE 4--USE ORIGINAL LENGTH
 CHARTYPE BSS    0
          SX7    X7-1              * DECREMENT LENGTH BY 1 CHARACTER
  
          SPACE  4
*      X7 NOW HAS THE MAXIMUM LENGTH TO UNSTRING (THE RESULT LENGTH). 
*      CHECK IF THERE ARE THAT MANY CHARACTERS LEFT TO UNSTRING, AND
*      USE THE SOURCE LENGTH REMAINING AS THE LENGTH TO UNSTRING, IF
*      NECESSARY. 
  
*      THE RESULT LENGTH IS OKAY IF  SRCLENG - RESLLENG \ 0 
  
 NOTCHAR  BSS    0
          SA4    SRCLNSV           * GET SRCLENG (SOURCE LENGTH)
          IX5    X4-X7             * HAVE FULL EXPRESSION 
          PL     X5,LENGOKAY
  
*      RESULT TOO BIG, USE REMAINING SOURCE LENGTH. 
  
          BX7    X4 
  
          EJECT 
*      SAVE THE LENGTH TO BE UNSTRUNG. THIS VALUE IS USED AS THE LENGTH 
*      TO BE INSPECTED IF DELIMITERS ARE PRESENT. 
  
 LENGOKAY BSS    0
          SA7    UNSTRLEN 
  
*      IF THERE ARE NO DELIMITERS, THIS IS THE TOTAL LENGTH TO UPDATE 
*      THE SOURCE ITEM BY AT THE END OF THE MAIN LOOP 
  
          SA7    SRCUPDT
  
          TITLE  DELIMITER SEARCH LOOP
*      AT THIS POINT, WE HAVE THE LENGTH TO BE UNSTRUNG IN X7, IF NO
*      DELIMITERS ARE SPECIFIED OR FOUND IF SPECIFIED. NOW, DO THE
*      DELIMITER PROCESSING IF IT IS SPECIFIED. THIS INCLUDES FINDING A 
*      DELIMITED LENGTH, STORING THE FOUND DELIMITER (IF ANY) IN THE
*      DELIMITER-IN ITEM (IF ANY), AND THE DELIMITED LENGTH IN THE
*      COUNT IN ITEM (IF ANY).
  
*      INITIALIZE CURRENT DELIMITER ADDRESS TO FIRST DELIMITER ADDRESS. 
  
          SA4    DELBEGIN          * FIRST DELIMITER ADDRESS. 
          SX6    X4 
          SA6    CURRDEL           * CURRENT DELIMITER ADDRESS. 
          SA6    MINDEL 
          SA1    UNSTRLEN 
          SA4    X4 
          SB7    X1 
          PL     X4,NODELIM       * NO DELIMITERS 
          SA1    SRCLNSV
          BX6    X1 
          SA6    MINLEN 
  
          SPACE  4
*      DELIMITER PROCESSING LOOP. 
*         CURRDEL = CURRENT DELIMITER ADDRESS.
*         UNSTLENG = LENGTH TO SEARCH FOR.
  
          SPACE  4
 DELIMLP  BSS    0
          SA4    CURRDEL           * CURRENT DILIMITER
          SA4    X4 
  
*      CHECK FOR (MORE) DELIMITER PROCESSING. 
*      DELIMITER PARAMETERS HAVE A TYPE (LEFT 6 BITS OF PARAM) OF 40B 
*      AND ABOVE, OPERANDS ARE 37B AND BELOW. 
  
          PL     X4,DELDONE        * ALL DELIMITERS PROCESSED 
  
*      SAVE THE DELIMITER FOR A C.INSPT PARAMETER.
*      THE DATA NAME DELIMITER TYPE (60B OR 61B) IS THE SAME AS A 
*      C.INSPT BEFORE PARAMETER BY DESIGN.
  
          MX6    6
          BX4    -X6*X4 
          SX6    60B         TYPE = BEFORE ALPHANUMERIC 
          LX6    54 
          BX6    X6+X4
          SA6    INSPDEL
  
*      SAVE DELIMITER LENGTH
  
          MX4    42 
          LX6    24 
          BX6    -X4*X6            * ISOLATE LENGTH FOR SAVING
          SA6    DELLENG           * SAVE LENGTH
          SX1     X6-1
          NZ      X1,LONGDEL
          SA4     INSPDEL 
          SB3     X4
          AX4     18
          SB4     X4          BYTE OFFSET 
          RJ      =XSTRSUBS 
          SA4     B3          ADDRESS DELIMITER 
          SX6     B4
          SX7     6 
          IX6     X6*X7 
          SB4     X6
          LX4     B4,X4 
          MX0     6 
          BX4     X0*X4       DELIMITER CHARACTER 
          MX2     0 
          SA1     SRCADDR 
          SA3     SRCBCP
          SB2     X3
          IX3     X3*X7 
          SA1     X1
          SB6     X3
          LX1     B6,X1 
          SB3     10
          SB4     B3-B2       CHARACTER COUNT 
          SA5     SRCLNSV 
 SCDEL1   BX6     X0*X1 
          IX7     X6-X4 
          ZR      X7,SAVELEN  MATCH 
          SX2     X2+B1 
          SX5     X5-1
          ZR      X5,SAVELEN  NO MORE CHARACTERS
          SB4     B4-B1 
          LX1     6 
          NE      B4,B0,SCDEL1
          SB4     10
          SA1     A1+B1       NEXT WORD 
          EQ      SCDEL1
  
 LONGDEL BSS     0
  
          SA1    SRCLNSV
          SB7    X1          * LENGTH TO INSPECT
          SPACE  4
*      C.INSPT WILL BE CALLED TO FIND OPERAND LENGTH, INSTEAD OF USING
*      (MODIFIED) LENGTH FIELD FROM OPERAND PARAMETER.
*      EITHER WAY, THE LENGTH TO BE UNSTRUNG IS IN B7.
  
*      SET UP C.INSPT CALL FOR THIS DELIMITER.
*      THE SIMULATED INSPECT STATEMENT IS 
*         INSPECT SOURCE TALLYING CHARACTERS BEFORE DELIMITER.
*      THE TALLY VALUE (SOURCE LENGTH TO BE UNSTRUNG) IS RETURNED IN X2.
  
          SA4    SRCADDR
          SB3    X4                * B3 = ADDR OF ITEM TO INSPECT 
          SA4    SRCBCP 
          SB4    X4                * B4 = BCP OF ITEM TO INSPECT
          SB5    INSPPARM          * B5 = ADDR OF SIMULATED PARAM LIST
          SB6    B5+B1             * B6 = LAST SIMULATED PARAMETER
                                   * B7 = LENGTH OF ITEM TO INSPECT 
  
*      INSPECT SOURCE FOR CHARACTERS BEFORE DELIMITER 
*      IF SCAN ITEM IS MORE THAN 10 CHARACTERS, USE LONG SCAN 
  
          SA5    DELLENG
          SX5    X5-11
          NG     X5,SHRTSCAN       * SHORT SCAN IF 10 CHARS OR LESS 
  
*      SCAN ITEM IS MORE THAN 10 CHARACTERS--USE LONG SCAN
  
          SB6    B6+2        LAST PARAM ADDRESS 
          SX0    1
          MX7    0
          SA7    LENGTH 
          BX7    X1 
          SA7    SAVEX1 
          RJ     =XC.INSPS
          SA2    LENGTH 
          SA1    SAVEX1 
          EQ     SAVELEN           * BYPASS SHORT SCAN ROUTINE CALL 
  
*      SCAN ITEM IS 10 CHARACTERS OR LESS--USE SHORT SCAN 
  
 SHRTSCAN BSS    0
  
          RJ     =XC.INSPF
  
*      SAVE LENGTH TO UNSTRING FOR INCREMENTING POINTER.
*      THIS IS ALSO THE COUNT-IN VALUE. 
  
 SAVELEN  BSS    0
          SA4    MINLEN 
          IX6    X2-X4
          PL     X6,SAVELN1 
          BX6    X2 
          SA6    A4                * NEW MINIMUM
          SA4    CURRDEL
          BX6    X4 
          SA6    MINDEL 
 SAVELN1  BSS    0
          SA4    CURRDEL
          SX6    X4+B1             * INCREMENT TO NEXT
          SA6    CURRDEL           * SAVE INCREMENTED DELIMITER ADDRESS 
  
          EQ     DELIMLP
  
          SPACE  4
*      CHECK WHETHER THIS IS AN ALL DELIMITER.
*      IF IT IS, FIND ANY CONSECUTIVELY FOLLOWING OCCURRENCES TO
*      ELIMINATE THEM. THERE MUST BE NO CHARACTERS BETWEEN ANY
*      OCCURRENCE IN THE SEQUENCE OF DELIMITERS AND THE NEXT OCCURRENCE.
  
 DELDONE  BSS    0
          SA2    MINLEN 
          SA4    SRCLNSV
          IX7    X2-X4
          NZ     X7,DELDONE1       * A DELIMITER FOUND
          BX7    X4 
          SA7    SRCUPDT
          SA7    COUNTIN
          SB7    X4 
          EQ     NODELIM
          SPACE  3
 DELDONE1 BSS    0
          SB7    X2 
          SX7    X2 
          SA7    UNSTRLEN 
          SA7    COUNTIN
          SA4    MINDEL            * GET MINIMUM DELIMITER
          BX7    X4 
          SA7    CURRDEL
          SA4    X4 
          BX7    X4 
          SA7    INSPDEL
          MX2    6
          BX5    X2*X4
          LX5    6                 * GET DELIMITER TYPE 
  
          SX7    B7 
          MX2    42 
          LX4    24 
          BX6    -X2*X4 
          SA6    DELLENG           * DELIMITER LENGTH 
          IX7    X6+X7
          SA7    SRCUPDT           * SAVE LENGTH TO UPDATE SOURCE BY
  
*      EXIT IF THIS IS NOT AN ALL DELIMITER 
  
          SX2    61B
          IX5    X5-X2             * X5 = DELIM TYPE - 61B
          NZ     X5,NODELIM 
  
*      THIS IS AN ALL DELIMITER.
*      LOOP UNTIL THE SOURCE IS RUN OUT OR THE DELIMITER CHAIN IS 
*      RUN OUT. 
  
 ALLOOP   BSS    0
  
*      CHECK IF SOURCE IS RUN OUT.
*      IT IS RUN OUT IF 
*         SRCLNSV - SRCUPDT < DELIM LENGTH
*      X4 = DELIMITER LENGTH
*      X7 = SRCUPDT 
  
          SB3    X4                * B3 = DELIMITER LENGTH
          SA4    SRCLNSV
          IX5    X4-X7
          SB4    X5                * B4 = SRCLNSV - SRCUPDT 
          LT     B4,B3,ENDDELIM    * END IF TOO LITTLE SOURCE LEFT
  
*      THERE IS ENOUGH SOURCE.
*      CHECK IF THE NEXT PART OF THE SOURCE STRING IS THE SAME
*      DELIMITER. 
  
          SA4    SRCADDR
          SB3    X4                * B3 = ADDR OF ITEM TO INSPECT 
          SA4    SRCBCP 
          IX4    X4+X7
          SB4    X4                * B4 = BCP OF ITEM + SRCUPDT 
          SB5    INSPPARM          * B5 = ADDR OF SIMULATED PARAM LIST
          SB6    B5+B1             * B6 = LAST SIMULATED PARAMETER
          SA4    SRCLNSV
          IX4    X4-X7
          SB7    X4                * B7 = SRCLNSV - SRCUPDT = 
                                   *      REMAINING SOURCE LENGTH 
  
*      INSPECT SOURCE FOR CHARACTERS BEFORE DELIMITER 
* IF SCAN ITEM IS MORE THAN 10 CHARACTERS, USE LONG SCAN
  
          SA5    DELLENG
          SX1     X5-1
          NZ      X1,LONGALL
          SA4     INSPDEL 
          SB3     X4
          AX4     18
          SB4     X4          BYTE OFFSET 
          RJ      =XSTRSUBS 
          SA4     B3          ADDRESS DELIMITER 
          SX6     B4
          SX7     6 
          IX6     X6*X7 
          SB4     X6
          LX4     B4,X4 
          MX0     6 
          BX6     X0*X4       DELIMITER CHARACTER 
          SA1     SRCADDR 
          SA3     SRCBCP
          SB3     X1
          SA2     SRCUPDT 
          SB4     X3
          SB4     B4+X2 
          RJ      =XSTRSUBS 
          SX3     B4
          IX3     X3*X7 
          SA1     B3
          MX2     0 
          SB6     X3
          LX1     B6,X1 
          SB3     10
          SB4     B3-B4       CHARACTER COUNT 
          SX5     B7          LENGTH
 ALLSCD   BX3     X0*X1 
          IX7     X3-X6 
          NZ      X7,ALLSCD1 MATCH
          SX2     X2+B1 
          SX5     X5-1
          ZR      X5,ALLSCD1  NO MORE CHARACTERS
          SB4     B4-B1 
          LX1     6 
          NE      B4,B0,ALLSCD
          SB4     10
          SA1     A1+B1       NEXT WORD 
          EQ      ALLSCD
  
 ALLSCD1  SA5     SRCUPDT 
          IX7     X5+X2 
          SA7     SRCUPDT 
          EQ      ENDDELIM
  
 LONGALL  BSS     0 
          SX5    X5-11
          NG     X5,SHRTSCN        * SHORT SCAN IF 10 CHARS OR LESS 
  
*      SCAN ITEM IS MORE THAN 10 CHARACTERS--USE LONG SCAN
  
          SB6    B6+2 
          SX0    B1 
          MX7    0
          SA7    LENGTH 
          BX7    X1 
          SA7    SAVEX1 
          RJ     =XC.INSPS
          SA2    LENGTH 
          SA1    SAVEX1 
          EQ     SAVELN            * BYPASS SHORT SCAN ROUTINE CALL 
  
*      SCAN ITEM IS 10 CHARACTERS OR LESS--USE SHORT SCAN 
  
 SHRTSCN  BSS    0
  
          RJ     =XC.INSPF
  
*      THE NEXT PART OF THE SOURCE STRING WAS NOT THE SAME DELIMITER IF 
*      THE TALLY VALUE IS NONZERO.
  
 SAVELN   BSS    0
          NZ     X2,ENDDELIM       * EXIT IF TALLY VALUE IS NONZERO 
  
          SA5    SRCUPDT
          SA4    DELLENG
          IX7    X4+X5
          SA7    SRCUPDT           * UPDATE THE LENGTH TO UPDATE SOURCE 
  
          EQ     ALLOOP 
  
*      END OF ALL DELIMITER SEARCH. RESTORE UNSTRING LENGTH TO B7.
  
 ENDDELIM BSS    0
          SA4    UNSTRLEN 
          SB7    X4 
  
          TITLE  MOVE (DELIMITED) SUBSTRING TO RESULT OPERAND 
*      AT THIS POINT, THE LENGTH TO BE MOVED HAS BEEN FOUND, AND IS IN
*      B7. THE ADDRESS OF THE DELIMITER WHICH WAS FOUND (IF ANY) IS IN
*      CURRDEL. 
  
 NODELIM  BSS    0
  
*      SET UP RESULT OPERAND FOR SUBSCRIPTING 
  
          SA5    PARMSAVE          * GET RESULT PARAMETER 
          MX4    6
          BX2    X4*X5
          LX2    6
          SB5    X2                * B5 = TYPE OF RESULT OPERAND
  
*      THE RESULT PARAMETER IS NOW DECODED. GET RESULT LENGTH AND FIND
*      OUT THE KIND OF RESULT FIELD THIS IS. B5 = RESULT OPERAND TYPE 
*      (LEFT 6 BITS) FROM ENCODED RESULT PARAMETER. 
  
*      THE RESULT PARAMETER IS ALPHANUMERIC IF TYPE IS 00 OR 01.
  
          GE     B1,B5,ANMOVE      * CALL C.MOVE FOR ALPHANUMERIC RESULT
          NE     B7,B0,NODELIM1    * NOT ZERO LENGTH SOURCE 
          SB7    B1 
          SA2    =XC.ZERO 
          MX0    0
          SA5    PARMSAVE 
          RJ     NUMMOVER 
          EQ     ANBYPASS 
          SPACE  3
 NODELIM1 BSS    0
  
          SPACE  4
*      THE RESULT PARAMETER IS NUMERIC (TYPE IS 02 TO 07).
*      SET UP TO MOVE SOURCE TO AN UNSIGNED DISPLAY ITEM IN A REGISTER. 
  
          SA5    SRCADDR
          SB3    X5                * B3 = SOURCE ADDRESS
          SA1    SRCBCP            * X1 = SOURCE BCP
  
*      GET C.ND2RN PARAMETER WORD.
*      THIS WORD IS PUT IN X0 AND IS STRUCTURED AS FOLLOWS
*         42/0
*         4/SHIFT COUNT = 10B 
*         1/SIGNED DESTINATION = 0
*         5/TRUNCATION INDICATOR = 0
*         1/SEPARATE SIGN FOR SOURCE = 0
*         1/LEADING SIGN FOR SOURCE = 0 
*         1/SIGNED SOURCE = 0 
*         5/NUMERIC LENGTH OF SOURCE = RESULT NUMERIC LENGTH IN B7
  
          SX0    4
          LX0    15 
          SX4    B7 
          BX0    X0+X4             * ADD NUMERIC LENGTH OF SOURCE 
  
*      MOVE SOURCE TO AN UNSIGNED DISPLAY ITEM IN A REGISTER(S) 
  
          RJ     =XC.ND2RN         * USES X0-X4, A0-A4, B3-B7 
                                   * OUTPUT: X1 = MOST SIGNIFICANT DIG. 
                                   *         X2 = LEAST SIG. DIGITS 
  
          SPACE  4
*      SET UP FOR MOVING DISPLAY ITEM TO THE RESULT FIELD 
  
          MX0    0                 * X0 = DISPLAY SOURCE FLAG 
          SA5    PARMSAVE          * X5 = RESULT PARAMETER
                                   * X1 = MOST SIGNIFICANT SOURCE DIGITS
                                   * X2 = LEAST SIGNIFICANT DIGITS
          SA4    UNSTRLEN 
          SB7    X4                * B7 = NUMERIC LENGTH OF SOURCE
  
*      MOVE DISPLAY ITEM TO THE RESULT FIELD
  
          RJ     NUMMOVER          * USES ALL REGISTERS 
  
          EQ     ANBYPASS          * BYPASS ALPHANUMERIC MOVE CODE
  
          SPACE  4
*      THE RESULT IS ALPHANUMERIC. SET UP FOR AND CALL UNIVERSAL
*      ALPHANUMERIC MOVE SUBROUTINE.
  
 ANMOVE   BSS    0                 * SET UP C.MOVE PARAMETERS 
          SB3    X5                * B3 = RESULT ADDR 
          LX5    42 
          SB4    X5                * B4 = RESULT OFFSET 
          LX5    42 
          SX4    X5                * X4 = RESULT LENGTH 
  
          SA5    SRCADDR
          SB5    X5                * B5 = ADDR OF SOURCE TO UNSTRING
          SA5    SRCBCP 
          SB6    X5                * B6 = BCP OF SOURCE TO UNSTRING 
  
*      CALL UNIVERSAL ALPHANUMERIC MOVE SUBROUTINE. 
  
          RJ     ANMOVER           * SAME PARAMETERS AS C.MOVE EXCEPT 
                                   * X4 HAS RESULT TOTAL LENGTH, AND
                                   * X2 = 0 MEANS NORMAL ALPHANUMERIC 
                                   * X2 NE 0 MEANS JUSTIFIED ALPHANUMER 
                                   * CALLS STRSUBS TO SUBSC RESULT
  
          TITLE  MOVE DELIMITER TO DELIMITER-IN ITEM
*      THE SOURCE SUBSTRING HAS BEEN UNSTRUNG INTO THE RESULT FIELD.
*      NOW CHECK WHETHER THERE IS A DELIMITER-IN FIELD TO MOVE THE
*      DELIMITER TO. IF THERE IS ONE, IT IS THE NEXT PARAMETER AFTER THE
*      RECEIVING FIELD PARAMETER. 
  
 ANBYPASS BSS    0                 * FROM NUMERIC MOVE TO RESULT
          SA4    PARMAD 
          SA5    PARMEND
          IX6    X4-X5
          ZR     X6,NOCOUNT  NO MORE PARAMETERS 
          SA4    X4+B1             * GET NEXT OPERAND 
  
*      THE NEXT OPERAND IS A DELIMITER-IN OPERAND IF ITS TYPE CODE IS 
*      10B OR 11B.
  
          MX5    6
          BX5    X5*X4
          LX5    6                 * GET OPERAND TYPE CODE
          SX2    10B
          IX6    X2-X5             * SUBTRACT OFF 10B FOR JUST RIGHT FLG
          ZR     X6,DELIMIN        * HAVE DELIM-IN IF  TYPE - 10B = 0 
          SX5    X6+B1
          NZ     X5,NODELIN        * NO DELIM-IN IF  TYPE - 11B NE 0
  
          SPACE  4
*      THERE IS A DELIMITER-IN OPERAND FOR THIS RECEIVING FIELD.
*      UPDATE THE PARAMETER POINTER.
  
 DELIMIN  BSS    0
          SA6    DELJUST           * DELIMITER-IN JUSTIFIED 
          SX7    A4 
          SA7    PARMAD            * PARAM PTR NOW POINTS TO DELIM-IN OP
  
*      SET UP FOR THE ANMOVER CALL. ANMOVER IS THE UNIVERSAL ALPHANUM 
*      MOVE ROUTINE. THE DELIMITER-IN PARAMETER IS IN X4. 
*      THE JUSTIFIED RIGHT FLAG IS IN X6. 
  
          SB3    X4                * B3 = DELIMITER-IN ADDRESS
          MX2    42 
          LX4    42 
          SB4    X4                * B4 = DELIMITER-IN OFFSET 
          SX7    B4 
          SA7    DELOFF 
          LX4    42 
          BX3    -X2*X4            * X3 = DELIMITER-IN LENGTH 
          BX7    X3 
          SA7    DELINLN           * DELIMITER-IN LENGTH
  
          SPACE  4
*      THE DELIMITER-IN PARAMETER IS NOW SET UP.
*      NOW SET UP THE DELIMITER PARAMETER, IF ANY.
  
          SA4    CURRDEL           * ADDRESS OF FOUND DELIMITER 
          SA4    X4                * GET FOUND DELIMITER PARAMETER
  
*      THE DELIMITER (IF ANY) ADDRESS AND BCP ARE ALWAYS DECODED INTO 
*      B5 AND B6, EVEN THOUGH THEY ARE NOT USED IF THERE IS NO DELIM. 
  
          SB5    X4                * B5 = DELIMITER ADDRESS 
          LX4    42 
          SB6    X4                * B6 = DELIMITER OFFSET
  
*      BY CONVENTION, A DELIMITER HAS TYPE CODE (LEFT 6 BITS OF 
*      PARAMETER) OF 40B AND ABOVE SO THE PL AND NG INSTRUCTIONS CAN BE 
*      USED TO TEST FOR A DELIMITER.
  
          LX4    18 
          PL     X4,NODEL          * BRANCH IF NO DELIMITER 
  
          LX4    24 
          SB7    X4                * B7 = DELIMITER LENGTH
          EQ     CALLMOVE          * FINISH SETUP AND CALL ANMOVER
  
*      IF THERE IS NO DELIMITER SET THE SOURCE LENGTH TO 0. 
*      B5 (DELIMITER ADDRESS) AND B6 (DELIMITER BCP) ARE NOT USED.
  
 NODEL    BSS    0
          SB7    B0                * B7 = 0 
  
          SPACE  4
*      FINISH THE SETUP AND CALL ANMOVER. 
*      X6 = JUSTIFIED RIGHT FLAG. 
*      X3 = DELIMITER-IN LENGTH.
  
 CALLMOVE BSS    0
  
*      FINISH SOURCE SUBSCRIPTING, IF APPLICABLE
  
          EQ     B7,B0,NOSRCSUB    * DONT SUBSC IF NO DELIMITER 
  
          SX2    B6 
          RJ     =XSRCSUBS         * SRCSUBS INPUT: B5 = ADDR, X2 = OFFS
                                   *    OUTPUT: B5 = NEW ADDR, B6 = BCP 
                                   *          USES: X2, X4, X5
  
 NOSRCSUB BSS    0
  
*      FINISH ANMOVER SETUP 
  
          BX2    X6                * MOVE JUSTIFIED FLAG TO X2
          BX4    X3                * MOVE RESULT LENGTH TO X4 
  
*      MOVE DELIMITER OR SPACES TO DELIMITER-IN ITEM
  
          RJ     ANMOVER           * B3 = RESULT (DELIMITER-IN) ADDRESS 
                                   * B4 = RESULT (DELIMITER-IN) BCP 
                                   * B5 = SOURCE (DELIMITER) ADDRESS
                                   * B6 = SOURCE (DELIMITER) BCP
                                   * B7 = SOURCE (DELIMITER) LENGTH 
                                   * X2 = 0 MEANS NORMAL ALPHANUM RESULT
                                   *    NE 0 MEANS JUSTIFIED AN RESULT
                                   * X4 = RESULT (DELIMITER-IN) LENGTH
                                   * CALLS STRSUBS TO SUBSC RESULT
  
          TITLE  MOVE CHARACTER-MOVE COUNT TO COUNT-IN ITEM 
*      END OF DELIMITER-IN PROCESSING.
*      NOW DO THE COUNT-IN PROCESSING IF THERE IS A COUNT-IN ITEM.
*      IF THERE IS A COUNT-IN ITEM, IT FOLLOWS THE DELIMITER-IN ITEM, 
*      IF ANY.
*      THE NEXT OPERAND IS A COUNT-IN ITEM IF ITS TYPE CODE IS
*      12B TO 17B.
  
 NODELIN  BSS    0
  
          SA5    PARMAD 
          SA4    PARMEND
          IX7    X4-X5
          ZR     X7,NOCOUNT  NO MORE PARAMETERS 
          SA5    X5+B1             * GET NEXT OPERAND 
  
          MX4    6
          BX4    X4*X5
          LX4    6                 * GET PARAMETER TYPE CODE
          SB5    X4 
          SB6    12B               * NO COUNT-IN IF TYPE IS LESS THAN 12
          LT     B5,B6,NOCOUNT     * EXIT IF NO COUNT-IN ITEM 
  
          SB6    17B
          GT     B5,B6,NOCOUNT     * NO COUNT IN
  
*      UPDATE THE PARAMETER POINTER.
  
          SX7    A5 
          SA7    PARMAD            * PARAM PTR NOW POINTS TO COUNT-IN OP
  
*      SET UP FOR THE NUMMOVER CALL.
  
          SX0    B1                * X0 = BINARY SOURCE FLAG
          SA1    COUNTIN
                                   * X5 = COUNT-IN PARAMETER
          SB7    6                 * B7 = NUMERIC LENGTH OF SOURCE
  
*      MOVE COUNT-IN VALUE TO COUNT-IN FIELD
  
          RJ     NUMMOVER          * USES ALL REGISTERS 
  
          TITLE  UPDATE POINTERS AND COUNTERS AND LOOP
*      END OF COUNT-IN PROCESSING 
*      NOW UPDATE THE POINTER AND UNSTRING SOURCE FIELD.
*      SRCUPDT CONTAINS THE TOTAL VALUE OF CHARACTERS MOVED TO THE
*      UNSTRING RESULT FIELD PLUS THE DELIMITER (OR ALL OCCURRENCES OF
*      THE DELIMITER IF DELIMITED-BY-ALL-DELIMITER WAS USED) LENGTH.
  
*      UPDATE THE POINTER 
  
 NOCOUNT  BSS    0
          SA4    SRCUPDT           * TOTAL LENGTH TO UPDATE BY IN X4
          SA5    POINTER           * CURRENT POINTER VALUE
          IX7    X4+X5
          SA7    POINTER           * SAVE UPDATED POINTER 
  
*      UPDATE THE SOURCE LENGTH 
  
          SA5    SRCLNSV
          IX6    X5-X4             * DECREMENT SOURCE LENGTH BY UPDATE
          SA6    SRCLNSV           * SAVE DECREMENTED SOURCE
  
*      UPDATE THE ADDRESS AND BCP 
  
          SA5    SRCADDR
          SB3    X5                * B3 = SOURCE ADDRESS
          SA5    SRCBCP 
          IX5    X5+X4             * UPDATE SOURCE OFFSET 
          SB4    X5                * B4 = UPDATED SOURCE OFFSET 
  
          RJ     =XSTRSUBS         * STRSUBS INPUT: B3 = ADDR, B4 = OFFS
                                   *    OUTPUT: B3 = NEW ADDR, B4 = BCP 
                                   *          USES: X2, X4, X5
          SX6    B3 
          SA6    SRCADDR           * SAVE SOURCE ADDRESS
          SX6    B4 
          SA6    SRCBCP            * SAVE SOURCE BCP
  
*      UPDATE THE TALLYING COUNT
  
          SA5    TALLYING 
          SX7    X5+B1             * INCREMENT TALLYING COUNT BY 1 OP 
          SA7    TALLYING          * SAVE INCREMENTED TALLY 
  
*      EXIT IF THERE IS NO MORE SOURCE TO UNSTRING
  
          SA4    SRCLNSV
          ZR     X4,UNSTEXIT       * IF NO MORE SOURCE
  
*      MORE SOURCE, SO CHECK FOR MORE OPERANDS, EXIT IF DONE. 
  
          SA4    PARMAD            * CURRENT PARAMETER ADDRESS
          SA5    PARMEND           * LAST PARAMETER ADDRESS + 1 
  
          IX5    X5-X4
          ZR     X5,UNSTEXIT       * EXIT WHEN CURRENT = LAST 
          SX7    X4+B1             * INCREMENT CURRENT PARAMETER ADDRESS
          SA7    PARMAD            * SAVE INCREMENTED PARAMETER ADDRESS 
  
          EQ     MAINLOOP          * PROCESS NEXT PARAMETER 
  
          SPACE  4
*      C.UNSTR EXIT POINT FOR ALL EXITS EXCEPT PRELIMINARY POINTER CHECK
  
 UNSTEXIT BSS    0
  
*      SET UP FOR MOVING POINTER VALUE TO POINTER ITEM, IF ANY
  
          SA5    PTRPARAM          * X5 = POINTER ITEM PARAMETER
  
          ZR     X5,NOPTRPAR       * SKIP POINTER MOVE IF NONE
  
          SX0    B1                * X0 = BINARY SOURCE FLAG
          SA1    POINTER           * X1 = POINTER SOURCE IN BINARY
          SB7    6                 * B7 = NUMERIC LENGTH OF SOURCE
  
*      MOVE POINTER VALUE TO POINTER ITEM 
  
          RJ     NUMMOVER          * USES ALL REGISTERS 
  
          SPACE  4
*      SET UP FOR MOVING TALLYING VALUE TO TALLYING ITEM, IF ANY
  
 NOPTRPAR BSS    0
  
          SA5    TALLYPAR          * TALLY ITEM PARAMETER 
  
          ZR     X5,NOTALPAR
  
          SX0    B1                * X0 = BINARY SOURCE FLAG
          SA1    TALLYING          * X1 = TALLYING SOURCE IN BINARY 
          SB7    6                 * B7 = NUMERIC LENGTH OF SOURCE
  
*      MOVE TALLYING VALUE TO TALLYING ITEM 
  
          RJ     NUMMOVER          * USES ALL REGISTERS 
  
          SPACE  4
*      RESTORE POINTER AND LENGTH FOR EXIT
  
 NOTALPAR BSS    0
          SA1    POINTER           * X1 = POINTER 
          SA4    SRCLENG
          SB7    B0 
          IX2    X4-X1
          NG     X2,C.UNSTS 
          SB7    B1          OVERFLOW 
  
          EQ     C.UNSTS
          SPACE  3
 INCLEN   BSS    0
          SA1    LENGTH 
          SX7    X1+B1
          SA7    A1 
          EQ     =XC.INSTE
          TITLE  TEMPORARY SAVE AREA
  
*      TEMPORARY SAVE AREA
  
*      INPUT PARAMETER TEMPS
  
 SRCADDR  DATA   0                 * B3 = SOURCE ADDRESS (MODIFIED) 
 SRCBCP   DATA   0                 * B4 = SOURCE BCP (MODIFIED) 
 PARMAD   DATA   0                 * B5 = PARAMETER ADDRESS 
 PARMEND  DATA   0                 * B6 = LAST PARAMETER ADDRESS + 1
 POINTER  DATA   0                 * X1 = POINTER VALUE 
 TALLYING DATA   0                 * X2 = TALLYING ITEM VALUE 
 SRCLENG  DATA   0                 * X3 = RESULT LENGTH 
  
*      C.INSPT SIMULATED STATEMENT PARAMETER AREA.
*      THESE TWO ITEMS MUST BE IN THE ORDER--INSPPARM, INSPDEL
  
 INSPPARM VFD    6/0,54/0          * CHARACTERS SEARCH SPECIFICATION
 INSPDEL  DATA   0                 * BEFORE OPERAND 
          VFD    6/50B,36/0,18/INCLEN 
          VFD    6/51B,36/0,18/BEFORE 
  
 BEFORE   DATA   0                 * BEFORE LENGTH SAVE AREA FOR OBJ
  
 DELTYPE  DATA   0                 * CURRENT UNSTRING DELIMITER TYPE
 DELLENG  DATA   0                 * DELIMITER LENGTH SAVE AREA 
  
*      MISCELLANEOUS TEMPS
  
 SRCLNSV  DATA   0                 * SOURCE LENGTH FOR INCREMENTING 
  
 COUNTIN  BSS    1
 DELBEGIN DATA   0                 * ADDRESS OF FIRST DELIMITER 
 DELINLN  BSS    1                 * DELIMITER-IN LENGTH
 DELJUST  BSS    1                 * DELIMITER-IN JUSTIFIED 
 DELOFF   BSS    1                 * DELIMITER-IN OFFSET
 CURRDEL  DATA   0                 * ADDRESS OF CURRENT DELIMITER 
 MINDEL   BSS    1                 * FIRST OCCURRING DELIMITER
 MINLEN   BSS    1                 * CHARACTERS PRECEEDING MINDEL 
  
 PARMSAVE DATA   0                 * OPERAND PARAMETER VALUE
  
 UNSTRLEN DATA   0                 * COUNT-IN LENGTH TO UNSTRING
  
 SIGNSRC  BSS    1               * SIGNED NUMERIC SOURCE- NUMOVER 
 SRCUPDT  DATA   0                 * TOTAL LENGTH TO UPDATE SOURCE BY 
  
 PTRPARAM DATA   0                 * POINTER ITEM PARAMETER 
 TALLYPAR DATA   0                 * TALLY ITEM PARAMETER 
 LENGTH   BSS    1
 SAVEX1   BSS    1
          TITLE  UNIVERSAL ALPHANUMERIC MOVE ROUTINE
** NAME - ANMOVER 
* 
** PURPOSE
*      UNIVERSAL ALPHANUMERIC MOVE ROUTINE, ANY LENGTH TO ANY LENGTH, 
*      JUSTIFIED OR NOT.
* 
** INPUT -
*         B3 = RESULT ADDRESS 
*         B4 = RESULT OFFSET
*         B5 = SOURCE ADDRESS 
*         B6 = SOURCE BCP 
*         B7 = SOURCE LENGTH
*         X2 = 0 MEANS NORMAL ALPHANUMERIC RESULT 
*            NE 0 MEANS JUSTIFIED RIGHT ALPHANUMERIC RESULT 
*         X4 = RESULT LENGTH
* 
* OUTPUT -
*         B3 = UPDATED RESULT ADDRESS 
*         B4 = UPDATED RESULT BCP 
* 
* USES -
*         ALL REGISTERS EXCEPT A0, X0, A2, A4 
*         CALLS STRSUBS TO FINISH RESULT SUBSCRIPT
  
          SPACE  4
 ANMOVER  DATA   0
  
*      FIND DIFFERENCE IN LENGTHS.
  
          SX7    B7 
          IX7    X4-X7             * DIFFERENCE IN X7 
  
*      IF THE DIFFERENCE IS POSITIVE THE RESULT IS LONGER THAN THE
*      SOURCE. X7 IS THUS A COUNT OF SPACES TO PREFIX OR APPEND.
  
          NG     X7,SHRTRESL       * PROCESS SHORT RESULT IF NEGATIVE 
  
*      IS THE RESULT OPERAND JUSTIFIED RIGHT ALPHANUMERIC TYPE. IF SO,
*      THE POSITIVELY-VALUED X7 IS A PREFIX COUNT. CALL C.MOVE. 
  
          NZ     X2,ALPHMOVE       * CALL C.MOVE IF JUSTIFIED TYPE
          ZR     X7,ALPHMOVE       * DONT COMPLEMENT ZERO 
          ZR     B7,ALPHMOVE       * DONT COMPLEMENT X7 IF ZERO LENGTH
  
*      THE RESULT OPERAND IS A NORMAL ALPHANUMERIC TYPE. X7 IS MADE INTO
*      A NEGATIVE VALUE FOR AN APPEND COUNT OF SPACES.
  
          BX7    -X7
          EQ     ALPHMOVE 
  
*      SHORT RESULT PROCESSING. IF THE RESULT IS NORMAL, JUST SHORTEN 
*      THE SOURCE.
  
 SHRTRESL BSS    0
          SB7    X4                * SHORTEN SOURCE 
          ZR     X2,SHRTMOVE       * BRANCH IF NORMAL RESULT
  
*      RESULT IS JUSTIFIED RIGHT. INCREMENT THE SOURCE ADDRESS TO 
*      TRUNCATE ON LEFT, AND RECOMPUTE THE ADDRESS AND BCP. 
  
          BX7    -X7
          SX2    X7+B6             * X2 = N 
  
*      FINISH RECOMPUTING ADDRESS AND BCP 
  
          RJ     =XSRCSUBS         * SRCSUBS INPUT: B5 = ADDR, X2 = OFFS
                                   *    OUTPUT: B5 = NEW ADDR, B6 = BCP 
                                   *          USES: X2, X4, X5
  
 SHRTMOVE BSS    0
          MX7    0                 * SET SPACES TO APPEND TO 0
  
*      THE NUMBER OF SPACES TO PREFIX OR APPEND IS IN X7. 
  
 ALPHMOVE BSS    0
  
*      FINISH THE C.MOVE SETUP AND CALL IT. 
  
          BX2    X7                * SPACES TO APPEND OR PREFIX IN X2 
          RJ     =XC.MOVE          * DOESNT USE A0,X0,A2,A4 
                                   * OUTPUT: B3 = NEW ADDR, B4 = NEW BCP
  
          EQ     ANMOVER           * RETURN 
  
          SPACE  4
*      TEMPORARY SAVE AREA FOR SAVING VALUES ACROSS C.MOVE CALL 
  
 MOVELEN  DATA   0                 * NUMBER OF CHARACTERS MOVED 
 B5ADDR   DATA   0                 * SOURCE ADDRESS 
 B6BCP    DATA   0                 * SOURCE BCP 
  
          TITLE  SEMI-UNIVERSAL NUMERIC MOVE ROUTINE
  
** NAME - NUMMOVER
* 
** PURPOSE
*      SEMI-UNIVERSAL REGISTER NUMERIC TO CORE NUMERIC MOVE ROUTINE.
* 
** INPUT -
*         X0 EQ 0--DISPLAY NUMERIC SOURCE IN X1 AND X2
*            NE 0--BINARY NUMERIC SOURCE IN X1
*         X1 = MOST SIGNIFICANT DIGITS OF DISPLAY SOURCE, OR
*              BINARY SOURCE
*         X2 = LEAST SIGNIFICANT DIGITS OF DISPLAY SOURCE 
*         X5= ENCODED PARAMETER WHICH WAS INPUT TO C.STRNG, C.UNSTR,
*              OR C.INSPT 
*         B7 = NUMERIC LENGTH OF SOURCE 
* 
** USES - 
*      ALL REGISTERS
*      C.RN2ND, C.RN1ND, C.U14R1, C.U10R1, STRSUBS, C.R1S06 
*      C.MASK 
* 
** RESTRICTIONS - 
*      BINARY SOURCE NO MORE THAN 6 DIGITS
*      INTEGER OPERATIONS ONLY
  
          SPACE  4
 NUMMOVER DATA   0
          MX7    0
          SA7    SIGNSRC
  
*      FIND TYPE OF SOURCE AND RESULT 
  
          MX3    3
          LX5    3
          BX4    X3*X5
          LX4    3                 * GET RESULT TYPE RIGHT OCTAL DIGIT
          SX3    7
          IX3    X4-X3             * X3 = 0 IF BINARY RESULT
  
          LX5    57                * RESTORE X5 AS INPUT TO NUMMOVER
  
          ZR     X0,DISPSRC        * BRANCH IF DISPLAY SOURCE 
  
*      THIS IS A BINARY SOURCE OPERAND
*      SEPARATE BINARY AND DISPLAY RESULT 
  
          NZ     X3,DISPRSL        * BRANCH IF DISPLAY RESULT 
  
          SPACE  4
*      THIS IS A BINARY REGISTER TO BINARY RESULT MOVE
*      FINISH RESULT SUBSCRIPT AND STORE RESULT 
  
          EQ BINSTORE              * INPUT: X1 = BINARY, X5 = PARAM 
                                   * USES: B3-4, X1-5,7, A7 
  
          SPACE  4
*      THIS IS A BINARY REGISTER TO DISPLAY RESULT MOVE.
*      CONVERT BINARY TO DISPLAY IN A REGISTER AND MOVE TO DISPLAY. 
  
 DISPRSL  BSS    0
  
*      CONVERT BINARY TO DISPLAY
          PL     X1,DISPRSL1
          SX7    B1 
          SA7    SIGNSRC
 DISPRSL1 BSS    0
  
          RJ     =XC.R1S06         * INPUT: X1 = BINARY SOURCE
                                   * OUTPUT: X1 = DISPLAY RESULT
                                   * USES: X0123, A2, B6
  
*      SET UP FOR DISPLAY MOVE
  
          BX2    X1                * X2 = LEAST SIGNIFICANT SOURCE DIGIT
                                   * X5 = ENCODED PARAMETER 
          SB7    6                 * B7 = SOURCE NUMERIC LENGTH 
  
          EQ     DIS2DIS           * MOVE DISPLAY REGISTER TO DISPLAY 
  
          SPACE  4
*      THIS IS A DISPLAY SOURCE OPERAND.
*      SEPARATE BINARY AND DISPLAY RESULT.
  
 DISPSRC  BSS    0
          NZ     X3,DIS2DIS        * BRANCH IF DISPLAY RESULT 
  
          SPACE  4
*      THIS IS A DISPLAY REGISTER TO BINARY RESULT MOVE.
*      CONVERT DISPLAY TO BINARY AND STORE THE BINARY RESULT. 
  
*      TEST FOR SOURCE MORE THAN 14 DIGITS. SHORTEN TO 14 IF SO 
  
          SB6    15                * B6 = 14 DIGIT COMPARE VALUE
                                   * B7 = SOURCE NUMERIC LENGTH 
          LT     B7,B6,BINLT15     * OKAY IF 14 OR LESS DIGITS
  
          SB7    14                * SHORTEN TO 14 IF MORE THAN 14
 BINLT15  BSS    0
  
*      TEST FOR 1 TO 10 OR 11 TO 14 DIGITS
  
          SB6    11                * B6 = 10 DIGIT COMPARE VALUE
                                   * B7 = SOURCE NUMERIC LENGTH 
          GE     B7,B6,BINGT10     * BRANCH IF 11 TO 14 DIGITS
  
*      CONVERT 1 TO 10 DIGITS TO BINARY 
  
          BX1    X2                * X1 = DISPLAY NUMERIC INPUT 
          RJ     =XC.U10R1         * INPUT: X1 = 10 DIGIT DISPLAY INPUT 
                                   * OUTPUT: X1 = BINARY OUTPUT 
                                   * USES: X0-3, A2, B7 
  
*      STORE BINARY RESULT
  
          EQ     BINSTORE          * INPUT: X1 = BINARY, X5 = PARAM 
                                   * USES: B3-4, X1-5,7, A7 
  
          SPACE  4
*      CONVERT 11 TO 14 DIGITS TO BINARY
  
 BINGT10  BSS    0
          SB6    24 
          SB6    B6-B7             * B6 = 24 - RESULT NUMERIC LENGTH
          SA4    B6+=XC.MASK
          BX0    X4          * X0 = MASK FOR DIGITS 
                                   * X1 = MOST SIGNIFICANT 1 TO 4 DIGITS
                                   * X2 = LEAST SIGNIFICANT 10 DIGITS 
  
          RJ     =XC.U14R1         * OUTPUT: BINARY RESULT IN X1
                                   * USES: X0-4, A2, B7 
  
*      STORE BINARY RESULT
  
          EQ     BINSTORE          * INPUT: X1 = BINARY, X5 = PARAM 
                                   * USES: B3-4, X1-5,7, A7 
  
          TITLE  DISPLAY NUMERIC TO DISPLAY NUMERIC MOVE CODE 
** NAME - DIS2DIS 
* 
** PURPOSE
*      MOVE DISPLAY NUMERIC SOURCE IN A REGISTER TO DISPLAY IN CORE 
* 
** INPUT -
*         X1 = MOST SIGNIFICANT DIGITS OF DISPLAY SOURCE
*         X2 = LEAST SIGNIFICANT DIGITS OF DISPLAY SOURCE 
*         X5 = ENCODED PARAMETER WHICH WAS INPUT TO C.UNSTR 
*         B7 = NUMERIC LENGTH OF SOURCE 
* 
** USES - 
*         B3-7, ALL X, A1,4-6 
*         C.RN1ND AND C.RN2ND 
  
 DIS2DIS  BSS    0
  
*      SET UP X0 PARAMETER REGISTER 
  
          SX0    1000B             * ENTER SHIFT COUNT PARAMETER = 10B
          SX3    B7 
          BX0    X0+X3             * ADD SOURCE NUMERIC LENGTH TO X0
  
*      DECODE RESULT PARAMETER
  
          MX4    3
          LX4    57 
          BX7    X4*X5
          LX7    6
          SB6    X7          * B6 = TYPE
          SB3    X5                * B3 = RESULT ADDRESS
          LX5    42 
          SX3    X5                * X3 = RESULT OFFSET 
          LX5    42 
          SX4    X5                * X4 = RESULT LENGTH 
  
*      ADD SIGN FLAGS TO X0, BASED ON TYPE
  
          SB5    B6-2              * B5 = TYPE - 2
          SA5    B5+DISFLAG        * X5 = 1/SEP SIGN, 1/LD SIGN, 1/SIGN 
          LX0    3
          BX0    X0+X5             * ADD SIGN FLAGS TO X0 
  
*      FIGURE NUMERIC LENGTH OF RESULT FROM LENGTH AND TYPE 
  
          SB5    B1+B1             * B5 = 2 
          EQ     B5,B6,DISSEPCH    * IF TYPE 2, N.L. = LENGTH - 1 
  
          SB5    B5+B5             * B5 = 4 
          NE     B5,B6,NOSEPCH     * IF NOT TYPE 2 OR 4, N.L. = LENGTH
  
 DISSEPCH BSS    0
          SX4    X4-1              * SEPARATE SIGN: DECREMENT LENGTH
  
 NOSEPCH  BSS    0
  
*      ADD RESULT NUMERIC LENGTH TO X0
  
          LX0    5
          BX0    X0+X4             * ADD RESULT NUMERIC LENGTH
          SA4    SIGNSRC
          LX4    13 
          BX0    X4+X0
  
*      CALL OBJECT ROUTINE TO STORE RESULT, BASED ON NUMERIC LENGTH.
*      USE C.RN1ND IF 1 TO 10 DIGITS. 
*      USE C.RN2ND IF 11 TO 14 DIGITS.
  
          SB5    B7-11
          SB7    NUMMOVER          * B7 = RETURN ADDRESS FOR OBJ ROUTINE
          PL     B5,CALL2ND 
  
*      SOURCE IS 1 TO 10 DIGITS 
  
          EQ     =XC.RN1ND         * INPUT: X0 = PARAMETERS 
                                   *   X2 = SOURCE DIGITS 
                                   *   X3 = DESTINATION CHAR. OFFSET
                                   *   B3 = DESTINATION ADDRESS 
                                   *   B7 = RETURN ADDRESS
                                   * USES: ALL X, A1,4-6, B3-7
  
*         SOURCE IS 11 TO 14 DIGITS 
  
 CALL2ND  BSS    0
          EQ     =XC.RN2ND         * INPUT: X0 = PARAMETERS 
                                   *   X1 = MOST SIG. SOURCE DIGITS 
                                   *   X2 = LEAST SIG. SOURCE DIGITS
                                   *   X3 = DESTINATION CHAR. OFFSET
                                   *   B3 = DESTINATION ADDRESS 
                                   *   B7 = RETURN ADDRESS
                                   * USES: ALL X, A1,4-6, B3-7
  
          SPACE  4
*      DISPLAY NUMERIC SIGN FLAGS 
  
 DISFLAG  BSS    0
          DATA   7                 * TYPE 2 = SIGNED LEFT CHARACTER 
          DATA   3                 * TYPE 3 = SIGNED LEFT OVERPUNCHED 
          DATA   5                 * TYPE 4 = SIGNED RIGHT CHARACTER
          DATA   1                 * TYPE 5 = SIGNED RIGHT OVERPUNCHED
          DATA   0                 * TYPE 6 = UNSIGNED
  
          TITLE  BINARY STORE CODE
** NAME - BINSTORE
* 
** PURPOSE
*      FINISH BINARY RESULT SUBSCRIPT AND STORE BINARY RESULT 
* 
** INPUT -
*         X1 = BINARY RESULT
*         X5 = STORE PARAMETER
* 
** USES - 
*      B3-4, X1-5, X7, A7 
  
BINSTORE  BSS    0
  
          SB3    X5          ADDRESS
          LX5    42 
          SB4    X5          OFFSET 
          AX5    18 
          SB7    X5          LENGTH 
  
*      FINISH SUBSCRIPT CALCULATION.
  
          RJ     =XSTRSUBS         * STRSUBS INPUT: B3 = ADDR, B4 = OFFS
                                   *    OUTPUT: B3 = NEW ADDR, B4 = BCP 
                                   *          USES: X2, X4, X5
  
*      STORE RESULT 
  
          SX7    X1 
          SB6    10 
          NE     B6,B7,BINS1 JP IF LENGTH NOT 10 - IS COMP-4
          ZR     B4,BINS2    JP IF BCP IS 0 - IS COMP-1 
 BINS1    BSS    0           COMP-4 RECEIVER
          SA7    =XC.BUFF    SOURCE FIELD 
          SB6    B6-B7       SOURCE OFFSET
          SB5    A7          SOURCE ADDR
          MX2    0           NO FILL
          RJ     =XC.MOVE    MOVE THE RESULT
          EQ     NUMMOVER 
 BINS2    BSS    0
          SA7    B3                * B3 = SUBSCRIPTED RESULT ADDRESS
  
          EQ     NUMMOVER          * RETURN TO CALLER 
 C.FUNST  EJECT 
* 
*         C.UNSTF - FAST UNSTRING 
* 
*         USED WHEN ALL DELIMITERS SIZE ONE, NO DELIMITER-IN, NO
*         COUNT-IN AND NO NUMERIC OPERANDS
* 
*         SEE C.UNSTR FOR CALLING SEQUENCE
* 
          ENTRY  C.UNSTF
 C.UNSTF  DATA   0
          SX7    B1 
          SA7    OVFLAG 
          BX7    X3 
          SA7    SRCLENG
          BX7    X2 
          SA7    TALLYING 
          SX7    X1 
          SA7    POINTER
          SX2    B1 
          IX2    X1-X2
          NG     X2,FUNST12  POINTER LESS THAN 1
          IX2    X3-X1
          NG     X2,FUNST12  POINTER GREATER THAN SOURCE LENGTH 
          MX7    0
          SA7    OVFLAG 
          SB4    B4+X1
          SB4    B4-B1       OFFSET+POINTER-1 
          RJ     =XSTRSUBS   UPDATE ADDR, BCP 
          SX7    B3          NEW SOURCE ADDRESS 
          SA7    SRCADDR
          SX7    B4 
          SA7    SRCBCP      NEW SOURCE BCP 
          SX7    B6 
          SA7    PARMEND     LAST PARAM ADDR + 1
          SA4    B5          FIRST PARAM
          MX2    3
          BX5    X2*X4
          LX5    3
          SX7    3
          IX5    X7-X5
          MX7    0
          NZ     X5,FUNST1   NOT POINTER
          BX7    X4 
          SA4    A4+B1       NEXT PARAM 
 FUNST1   SA7    PTRPARAM 
          BX5    X2*X4
          LX5    3
          SX7    4
          IX5    X7-X5
          MX7    0
          NZ     X5,FUNST2   NOT TALLY
          BX7    X4 
          SA4    A4+B1       NEXT PARAM 
 FUNST2   SA7    TALLYPAR 
* 
*    MOVE DELIMITERS TO DELIMITER LIST
* 
          SB2    B0          DELIMITER COUNT
          MX0    6
 FUNST3   SB3    X4          ADDR 
          AX4    18 
          SB4     X4         OFFSET 
          RJ     =XSTRSUBS   CONVERT OFFSET TO BCP
          SX6    B4 
          LX6    1
          SX5    X6+B4
          LX5    1           6*BCP
          SB4    X5 
          SA1    B3 
          LX1    B4,X1       LEFT JUSTIFY DELIMITER 
          MX7    6
          BX7    X0*X1
          SA7    DELIMLST+B2
          SB2    B2+B1       INCREMENT DELIMITER COUNT
          SA4    A4+B1
          NG     X4,FUNST3   DELIMITER
          SX7    B2 
          SA7    NDEL        NUMBER OF DELIMITERS 
          SX7    A4 
          SA7    NXTPARAM    NEXT PARAMETER ADDRESS 
* 
*    START UNSTRING OPERATION 
* 
*    GET NEXT CHARACTER 
* 
 FUNST4   SA3    SRCADDR
          SA4    SRCBCP 
          SB3    X3 
          SB4    X4 
          SA1    POINTER
          BX7   X1
          SA7    PTRSAVE
 FUNST5   SX6    B4-10
          NZ     X6,FUNST6
          SB3    B3+B1       ADDR = ADDR+1
          SB4    B0          BCP = 0
 FUNST6   SX6    B4+B4
          SX6    X6+B4
          LX6    1           6*BCP
          SB2    X6 
          SA1    B3 
          MX0    6
          LX2    X1,B2       LEFT JUSTIFY CHARACTER 
          BX1    X0*X2       CHARACTER
          SA2    NDEL 
          SA3    DELIMLST 
 FUNST7   IX6    X3-X1
          ZR     X6,FUNST13  MATCH
          SA3    A3+B1
          SX2    X2-1 
          NZ     X2,FUNST7   MORE DELIMITERS
          SA1    POINTER
          SX7    X1+B1
          SA7    A1 
          SB4    B4+B1       UPDATE BCP 
          SA2    SRCLENG
          IX6    X2-X7
          PL     X6,FUNST5   MORE SOURCE CHARACTERS 
          SA2    PTRSAVE
          IX6    X7-X2
* 
*    MOVE REMAINING SOURCE CHARACTERS TO RECEIVER 
* 
          SA2    TALLYING 
          SX7    X2+B1
          SA7    A2 
          SA1    SRCADDR
          SB5    X1          SOURCE ADDR
          SA2    SRCBCP 
          SB6    X2          SOURCE BCP 
          SB7    X6          SOURCE LENGTH
          SA3    NXTPARAM 
          SA3    X3 
          SB3    X3          RESULT ADDR
          AX3    18 
          SB4    X3          RESULT BCP 
          AX3    18 
          SX4    X3          RESULT LENGTH
          AX3    18 
          MX2    0
          ZR     X3,FUNST9   NOT JUSTIFIED RIGHT
          SX2    B1 
 FUNST9   RJ     =XANMOVER
 FUNST10  SA5    TALLYPAR 
          ZR     X5,FUNST11  NO TALLYING
          SA1    TALLYING 
          SX0    B1          BINARY SOURCE
          SB7    14          LENGTH 
          RJ     =XNUMMOVER 
 FUNST11  SA5    PTRPARAM 
          ZR     X5,FUNST12  NO POINTER 
          SA1    POINTER
          SX0    B1          BINARY 
          SB7    14          LENGTH 
          RJ     =XNUMMOVER 
 FUNST12  SA2    OVFLAG 
          SB7    X2 
          EQ     C.UNSTF
          SPACE  3
*    DELIMITER   FOUND
* 
 FUNST13  SA1    TALLYING 
          SX6    X1+B1
          SA6    A1          INCREMENT TALLY
*    MOVE SOURCE
          SA1    SRCADDR
          SB5    X1          SOURCE ADDR
          SA2    SRCBCP 
          SB6    X2          SOURCE BCP 
          SX7    B3          SAVE SOURCE ADDR 
          SA7    A1 
          SX7    B4+B1       SAVE SOURCE BCP
          SA7    A2 
          SA1    POINTER
          SA2    PTRSAVE
          IX6    X1-X2
          SB7    X6          SOURCE LENGTH
          SA3    NXTPARAM 
          SA3    X3 
          SB3    X3          RESULT ADDR
          AX3    18 
          SB4    X3          RESULT BCP 
          AX3    18 
          SX4    X3          RESULT LENGTH
          AX3    18 
          MX2    0
          ZR     X3,FUNST14  NOT JUSTIFIED RIGHT
          SX2    B1 
 FUNST14  RJ     =XANMOVER
          SA1    POINTER
          SX7    X1+B1
          SA7    A1 
          SA2    SRCLENG
          IX6    X2-X7
          NG     X6,FUNST10  SOURCE EXHAUSTED 
          SA3    NXTPARAM 
          SA4    PARMEND
          SX7    X3+B1
          IX6    X4-X3
          SA7    A3 
          NZ     X6,FUNST4   MORE RECEIVING FIELDS
          SX6    B1          OVERFLOW INDICATOR 
          SA6    OVFLAG 
          EQ     FUNST10     EXIT 
          SPACE  3
 DELIMLST BSS    20          DELIMIETER LIST
 NDEL     BSS    1           NUMBER OF DELIMITERS 
 NXTPARAM BSS    1           NEXT PARAMETER ADDRESS 
 PTRSAVE  BSS    1           PREVIOUS POINTER VALUE 
 OVFLAG   BSS    1           OVERFLOW FLAG
  
          END                      * END OF C.UNSTR 
