*DECK     ASF 
          IDENT  ASF
 ASF      SECT   (*ASF* DEFINITION / REFERENCE PROCESSORS),1
  
          SST    A,B,D,EXIT.
          NOREF  A,B,D,EXIT.
  
 B=ASF    RPVDEF             DEFINE ROUTINE FWA FOR REPRIEVE UTILITY
  
          ENTRY  AFDEX,AFR,AFD
  
*         IN TABLES 
          EXT    INAFR,REFVAR,TT=SCR,TT.SCR,TS.SYM,TT=ASF,TT.ASF
  
*         IN ERRORS 
          EXT    E.AF10,E.AF11
          EXT    E.AF15,E.AF16,E.AF3,E.AF4,E.AF5,E.AF6,E.AF7,E.AF9
          EXT    FILL.,FILL.2,ERR=F 
          EXT    E.AF17 
  
*         IN ALLOC
          EXT    ALC.ASF,ALC.REG,SCSA,ADW,SSY,SCT,SCS 
  
*         IN MAIN 
          EXT    PSP
  
*         IN INIT 
          EXT    ASFERR,ASFARG,FWAASF,FWAARG,FWAREF,SCR,SVB6,SCR2 
  
 ASF      SPACE  4,8
**        *ASF* IS ENTERED BY MASTER LOOP WHEN A STATEMENT FUNCTION 
*                DEFINITION IS ENCOUNTERED, AND IS CALLED BY *PAR* TO 
*                EXPAND A STATEMENT FUNCTION REFERENCE. 
 AFD      SPACE  4,12 
**        AFD -  ARITHMETIC FUNCTION DEFINITION PROCESSOR.
*         ENTERED FROM COMPILERS MASTER LOOP. 
*         ENTRY  (B4) - START OF STATEMENT. 
*         EXIT   TO *PSP*.
* 
*         TT.ASF ENTRY FORMAT.
*         1      = 24/0, 18/0, 18/LENGTH OF SKELETON + ARGUMENT WORDS 
*         2 TO N = 6/0, 18/LEN OF REF, 18/FWA OF REF, 18/NO OF USES 
* 
*         N+1    = ACTUAL SKELETON, WITH DUMMY PARAMETERS ENTRIES IN THE
*                  FOLLOWING FORMAT 
*                  18/PARAMETER NUMBER, 24/0, 18/O.ASFA 
* 
*         USES TT.SCR FOR PARAMETER CHECKING. 
  
  
 AFD      SHRINK TT=SCR,0 
          MX0    L.SYM
          =A2    B4          CHECK IF ALREADY DEFINED 
          BX6    X0*X2
          SA6    FILL.
          SCAN   TS.SYM,SSY 
          MX0    L.SYM
          MI     B7,AFD05    IF SYMBOL NOT FOUND
          SX2    M.NVAR 
          BX2    X2*X6
          NZ     X2,AFD03    IF NVAR
          SX2    M.VAR+M.FP 
          BX2    X2*X6
          ZR     X2,AFD05    IF NOT NVAR, VAR OR FP 
          EQ     E.AF17      CONFLICTING DEFINITION 
  
 AFD03    SX2    M.ASF       HERE IF NVAR 
          BX2    X2*X6
          ZR     X2,E.AF17   IF NOT ASF, FATAL ERROR
          WARN   E.AF16      DUPLICATE ASF, NEW OVERRIDES 
          MX0    L.SYM
 AFD05    =A2    B4+1 
          =B4    B4+1 
          SB7    X2-O.( 
          NZ     B7,AFD05    IF LEFT PAREN NOT FOUND
          =A2    B4-1 
          BX6    X0*X2
          ADDWD  TT.SCR 
          SA6    FILL.
  
**        ADD DUMMY ARGS TO SCRATCH TABLE 
  
 AFD10    =A4    B4+1 
          =B4    B4+1 
          SB7    X4-O.VAR 
          NZ     B7,=XE.AF15       IF NOT VARIABLE
          MX0    L.SYM
          BX6    X4*X0
          SA6    FILL.2 
          SCAN   TT.SCR,SCT  LOOK FOR DUMMY ARG 
          MI     B7,AFD13    IF NOT ALREADY REFERENCED
          FATAL  =XE.AF9     DUPLICATE DUMMY ARG
          EQ     AFD13A      DONOT ADD ERROR ENTRY TO TT.SCR
 AFD13    ADDWD  TT.SCR 
 AFD13A   =A4    B4+1 
          SB7    X4-O.VAR 
          NZ     B7,AFD14    IF NOT LONG NAME 
          RJ     =XTLV       TRUNCATE NAME
AFD14     =A4    B4+1 
          =B4    B4+1 
          SB7    X4-O.COMMA 
          ZR     B7,AFD10    IF MORE ARGS 
          SB7    X4-O.) 
          ZR     B7,AFD20    IF RIGHT PAREN FOUND 
          BX6    X4 
          SA6    FILL.
          EQ     =XE.TC2     EXPECTED COMMA OR RIGHT PAREN
  
**        HERE IF END OF ARGUMENT STRING FOUND
*         (B4) _ CLOSING *)*
  
 AFD20    SA2    B4+B1
          SB4    B4+B1
          SB7    X2-O.= 
          NZ     B7,E.AF3    IF NO *=* FOLLOWING END OF ARUGMENTS 
          SX6    B4 
          SB5    B4          LENGTH OF *ASF* SKELETON 
          SA2    ASFMASK
          SA6    SCR+1       SAVE START OF *ASF*
          BX6    X2 
          SA6    SCSA        SET MASK FOR *SCS* 
  
**        HERE IF *=* FOUND AFTER END OF ARGUMENTS. 
*         SCAN THROU *ASF* REPLACING ALL REFERENCES TO DUMMY PARAMETERS 
**T  DUM-ARG     18/ PARAM NUM,  24/ ,  18/ O.AFSA
*                CHECK IF ASF IS RECURSIVE, AND OUTPUT ERROR IF SO. 
  
 AFD30    SA1    B4+B1
          SB4    B4+B1
          BX6    X1 
          ZR     X1,AFD50    IF *EOS* 
          SB7    X1-O.VAR 
          NZ     B7,AFD30    IF NOT VARIABLE, WHY BOTHER
          BX0    X1 
          SA1    OCTCK
          IX0    X1-X0
          NZ     X0,AFD31    IF NOT OCTAL CONSTANT
          =A1    B4-1 
          SB7    X1-O.CONS
          NZ     B7,AFD31    IF NOT OCTAL CONSTANT
          EQ     AFD30
 AFD31    SCAN   TT.SCR,SCS  SCAN TO SEE IF ARGUMENT
          MI     B7,AFD30    IF NOT IN TABLE (NOT ARGUMENT) 
          ZR     B7,E.AF6    IF RECURSIVE DEFINITION. 
          =X0    1
          IX7    X0+X2       UPDATE USE COUNT 
          SX6    B7 
          SA7    A2          RESET WITH USE COUNT UPDATED 
  
**        HERE IF ARGUMENT REFERENCE FOUND. 
  
          LX6    P.TAG
          SX0    O.ASFA 
          IX6    X0+X6
          SA6    B4          RESET TO INDICATE ARGUMENT.
          =A3    B4+1 
          SB7    X3-O.VAR 
          NZ     B7,AFD30    IF NOT LONG NAME 
  
**        THROW AWAY EXCESS TOKENS IN NAME (OVERWRITE STRING BUFFER)
  
 AFD32    =A3    A3+1 
          SB7    X3-O.VAR 
          ZR     B7,AFD32    IF MORE TOKENS IN NAME 
          =A1    A3-1 
 AFD34    =A1    A1+1 
          NZ     X1,AFD34    IF NOT EOS 
          =B7    A3-1 
          MVE    A1-B7,A3,B4+1     THROW AWAY THE WHOLE BLOODY MESS 
          EQ     AFD30       CONTINUE 
  
**        VALIDATE THAT ALL DUMMY PARAMETERS ARE USED.
*         (IF ONE IS NOT USED OUTPUT WARNING MESSAGE.)
  
 AFD50    SA2    TT=SCR 
          SA4    TT.SCR 
          SB3    X2-1        DO NOT CHECK ASF NAME ITSELF.
          MX5    L.SYM
          SB5    B4-B5       LENGTH OF ASF SKELETON 
          SB6    B3          NUMBER OF PARAMETERS.
  
 AFD52    SA2    X4+B3
          SB3    B3-B1
          SX1    X2 
          MI     B3,AFD60    IF END OF ARGUMENT LIST. 
          NZ     X1,AFD52    IF ARGUMENT USED 
          BX6    X5*X2
          SA6    FILL.2      ARGUMENT NOT USED. 
          WARN   E.AF7       ARGUMENT NEVER USED. 
          EQ     AFD52       LOOP THROUGH TABLE 
  
**        HERE WHEN ALL ARGUMENT REFERENCES IN *ASF* HAVE BEEN
*         TRANSLATED AND VALIDATED
*         NOW ADD SKELETON FOR *ASF* TO TT.ASF TABLE. 
*         (B5) = LENGTH OF SKELETON FOR THIS ASF. 
*         (B6) = NUMBER OF PARAMETERS.
  
 AFD60    LE     B5,B1,E.AF4 IF NULL PARAMETER LIST.
          SA2    ERR=F
          NZ     X2,AFDEX    IF ERRORS, SUPPRESS DEFINITION 
          =X6    B6+1 
          SX7    B5 
          SA6    ARGNUM      SAVE B6 CELL 
          SA7    ASFLEN      SAVE B5 CELL 
  
**        MAKE SYMBOL TABLE ENTRY 
  
          SA1    TT.SCR 
          =X6    CR.DEC 
          SA2    X1 
          SA6    REFVAR      SET REF MAP VALUE
          BX6    X2 
          SCAN   TS.SYM,SSY 
          MI     B7,AFD62    IF NOT ALREADY IN TABLE
          =X3    M.DEF+M.ASF+M.NVAR+M.FUN 
          =B7    B7+1 
          BX7    X3+X6
          SA7    A2 
          EQ     AFD64
  
**        TAG ASF IF NOT ALREADY DEFINED
  
 AFD62    SA1    TT.SCR 
          TAGASF X1 
 AFD64    SX6    B7 
          SA6    SCR
  
**        ADD SKELETON TO TABLE 
  
          SA1    ARGNUM 
          SA2    ASFLEN 
          SB6    X1 
          SB5    X2 
          SA1    SCR+1
          SB4    X1 
          SX4    B5+B6
          SA5    TT=ASF 
          ALLOC  TT.ASF,X4   ALLOCIATE ROOM FOR CURRENT *ASF* 
  
**        PREFIX SKELETON WITH USE COUNTS OF ARGUMENTS
  
          SA2    TT.SCR 
          SB2    B7-B5       STORE ADDRESS
          SA3    X2+B6       LAST ARGUMENTS USE COUNT 
          SB3    B6 
 AFD65    BX6    X3 
          =B3    B3-1 
          SA6    B2 
          =A3    A3-1 
          =B2    B2-1 
          NZ     B3,AFD65    IF NOT END OF ARGUMENTS
          SA3    TT=SCR      NUMBER OF ARGS + 1 
          IX6    X4-X3
          SA6    A6-1        LENGTH OF SKELETON = 1ST WORD OF ASF 
  
**        (X1) = NEW ORGIN OF TS.ARG. 
*         (X2) = LENGTH.
*         (X5) = FWA FOR CURRENT SKELETON RELATIVE TO TT.ASF
*         (B6) = NUMBER OF PARAMETERS +1. 
  
          SA4    TS.SYM 
          IX1    X1+X5
          SA3    SCR         SYMBOL TABLE ORDINAL 
          =X0    B6-1        NUMBER OF ARGUMENTS
          SB7    X4 
          SA2    X3+B7       TAG FOR CURRENT ASF
          MX6    -L.ARGC     CLEAR FIELDS IN CASE OF DUP DEF
          LX6    P.ARGC 
          BX2    X6*X2
          MX6    -L.ASFP
          LX6    P.ASFP 
          BX2    X6*X2
          LX0    P.ARGC 
          SB3    A6+B6       FWA FOR SKELETON 
          IX6    X0+X2       ADD IN PARAMETER FIELD 
          =A4    B4+1        FWA OF SKELETON
          LX5    P.ASFP 
          BX6    X6+X5       TT.ASF ORDINAL TO POINTER FIELD
          SA6    A2          ASF TAG WITH PARAMETER COUNT TO SYMBOL TAB 
  
**        ADD SKELETON TO *ASF* TABLE FOR LATER PROCESSING WHEN *ASF* 
*         USED. 
*         (B5) = LENGTH OF SKELETON.
*         (A4) _ SKELETON 
*         (B3) _ FWA FOR SKELETON 
  
 AFD70    BX6    X4 
          =B5    B5-1 
          SA6    B3          ADD SKELETON WORD TO ASF TABLE 
          =A4    A4+1        NEXT WORD
          =B3    B3+1 
          NZ     B5,AFD70    IF NOT END 
          =X6    O.EOS       INDICATE END OF ASF
          SA6    A6 
 AFDEX    SHRINK TT=SCR,0    CLEAR TABLE
          EQ     PSP         EXIT.. 
  
 ASFMASK  VFD    L.SYM/-0,*P/0
 ASFLEN   DATA   0           TEMP SAVE CELL 
 ARGNUM   DATA   0           TEMP SAVE CELL 
  
 OCTCK    VFD    L.SYM/0LB,L.SBPR/O.VAR  OCTAL CONSTANT CHECK 
 AFR      EJECT  4,20 
**        AFR -  ARITHMETIC STATEMENT FUNCTION REFERENCE PROCESSING.
* 
*         ENTERED FROM *PARSE* UPON FINDING A REFERENCE TO AN *ASF* 
*            FOLLOWED BY A *(*. 
* 
*         ENTRY  (B4) _ *ASF* TO PROCESS. 
*                FILL. = *ASF* NAME.
*                (X7)  = *ASF* SYMBOL TABLE TAG.
*                (B6)  _ *ASF* ENTRY IN ESTACK. 
*                (INAFR) SET
* 
*         EXIT   (B6) RESET, ELIMINATING *ASF* FROM ESTACK
*                (B4) = WHERE TO INPUT FROM.
*                (INAFR) RESET, IF NECESSARY. 
*                (ALC.REG) LOCKS (B4) TO TT.ASF 
  
  
 AFR      SUBR               ENTRY/EXIT...
          =X6    B6-1        ELIMINATE *ASF* FROM ESTACK
          MX1    -L.ARGC
          SA6    SVB6        SAVE (B6)
          SX6    B5 
          =A6    A6+1        SAVE (B5)
          SA2    TT=SCR 
          =X6 
          AX7    P.ARGC 
          SA6    ASFERR      INDICATE NO ARGUMENT ERROR 
          BX6    X2 
          MX3    -L.ASFP
          SA6    SCR2 
          =B4    B4+1 
          BX6    -X1*X7      NUMBER OF PARAMETERS 
          AX7    P.ASFP-P.ARGC
          SA1    TT.ASF 
          SA2    INAFR
          BX7    -X3*X7      ASF DEFINITION RELATIVE ADDRESS
          SB6    X6 
          IX0    X7+X1
          SA6    ASFARG 
          SA7    FWAASF 
          BX6    0
          =X7    B4-1        FWA OF REFERENCE 
          SA6    FWAARG 
          ZR     X2,AFR17    IF INPUT FROM *SB* 
          IX7    X7-X1
 AFR17    SA7    FWAREF      SAVE FWA OF REFERENCE
          =B3    X0+1        (B3) = ADDRESS OF ARG DESCRIPTORS
  
*         NOW    (ASFARG) = NUMBER OF PARAMS
*                (ASFERR) = 0 (NO ERROR)
*                (FWAREF) = *SB* ADDR OF FWA REFERENCE
*                (FWAARG) = RELATIVE ADDRESS OF ACTUAL ARGUMENTS
  
**        SCAN THRU PARAMETER CALL FOR ZERO LEVEL COMMA.
*         AND ENTERING IN PARAMETER CELLS FOR *ASF* 
*         ENTRY  (B3) = ADDRESS OF FWA DESCRIPTORS IN DEFINITION
*                (B4) = FWA OF ARGUMENT 
*                (B6) = NUMBER OF PARAMETERS REMAINING TO DO
*         USES   (B2) = PC COUNT. (PC= PAREN COUNT) 
*                (B5) = FWA OF ARGUMENT 
*                (X5) = SPACE ACCUMULATOR 
  
          =B5    B4          START OF ARGUMENT
          =B2    0           INITIALIZE PAREN LEVEL 
          =X5    1           CLEAR SPACE REQUIRED TOTAL 
  
 AFR20    SA1    B4 
          SX2    X1-O.LP
          =B4    B4+1 
          ZR     X1,E.AF5    IF PREMATURE END OF STATEMENT. 
          NZ     X2,AFR25    IF NOT *(* 
          =B2    B2+1        PC=PC+1
          EQ     AFR20       CONTINUE 
  
 AFR25    =X2    X2+O.LP-O.RP 
          NZ     X2,AFR26    IF NOT *)* 
          =B2    B2-1        PC=PC-1
          PL     B2,AFR20    IF NOT ENDING PAREN
          NE1    B6,E.AF11
          EQ     AFR30
  
 AFR26    NZ     B2,AFR20    IF NOT IN ZERO LEVEL 
          SX2    X1-O.COMMA 
          NZ     X2,AFR20    IF NO COMMA
  
**        FOUND ZERO LEVEL COMMA OR RIGHT PARENTHESIS.
*                (B3) = ADDRESS OF FWA DESCRIPTORS IN DEFINITON 
*                (B4) _ NEXT ELEMENT AFTER *,* OR *)*.
*                (B5) _ START OF CURRENT ARGUMENT 
*                (B6) = NUMBER OF ARGS REMAINING TO DO
  
 AFR30    NE     B4,B5,AFR32 IF NOT NULL PARAMETER. 
          FATAL  E.AF10      EMPTY PARAMETER LIST.
  
 AFR32    SA1    B3 
          SA2    FWAARG 
          SX3    B4-B5       LENGTH OF ARGUMENT + 1 
          IX7    X2+X3
          =X3    X3-1        ACTUAL ARGUMENT LENGTH 
          =B5    B4          START OF NEXT PARAMETER
          LX2    18 
          SA7    A2          UPDATE RELATIVE ARG START
          BX0    X3 
          SX4    X1          ISOLATE ARGUMENT USE COUNT 
          LX3    2*18 
          =X0    X0-1 
          ZR     X0,AFR37    IF ARGUMENT IS SINGLE ELEMENT
          SX0    X0+2        OTHERWISE ALLOW SPACE FOR PARENTHESES
 AFR37    IX4    X0*X4       (X4)  = LENGTH * USES
          BX7    X3+X2
          =B3    B3+1 
          SX1    X1          ISOLATE ARGUMENT USE COUNT 
          BX6    X1+X7       6/ 0,  18/ LENARG,  18/ FWA ARG,  18/ USES 
          =B6    B6-1 
          IX5    X5+X4       ACCUMULATE EXPANSION SIZE
          =A6    B3-1        RESET ARG POINTER WORD 
          GT     B6,AFR20    IF ALL ARGUMENTS NOT PROCESSED 
  
          PL     B2,E.AF11   IF NOT TERMINAL *)* FOUND - ARGUMENT ERROR 
  
  
**        WE HAVE NOW COMPUTED THE LENGTH NECESSARY TO HOLD ALL OF THE
*         ACTUAL ARGUMENTS.  THEY MUST NOW BE MOVED OUT OF THE WAY, SO
*         WE CAN START STORING THE EXPANSION OVER TOP OF THEM.
*                (X5) = LENGTH OF ALL ACTUAL ARGUMENTS
*                       + PARENTHESES (IF NEEDED) 
*                (B4) = END OF ACTUAL ARGS + 1
*                (FWAREF) = IF IN *SB* -- ADDRESS 
*                           IF TT.ASF  -- RELATIVE ADDRESS
*                (FWAASF) = RELATIVE ADDRESS OF FWA ASF DEFINITION
  
          SA2    FWAARG 
          =X2    X2+1 
          ALLOC  TT.SCR,X2
          SA3    INAFR
          SA2    FWAREF 
          ZR     X3,AFR52    IF INPUT WAS ALREADY FROM AN ASF 
          SA3    TT.ASF 
 AFR52    IX2    X2+X3       FROM = (FWAREF) + OFFSET 
          SB5    X2 
          SX3    B7 
          SX1    B4-B5       W.C. = LEN OF ALL ACTUAL ARGS
          IX3    X3-X1       DEST = (LWA) - (LENGTH)
          MVE    X1,X2,X3    MOVE ACTUAL ARGUMENTS TO SCRATCH AREA
  
          SA1    TT.ASF 
          SA2    FWAASF 
          IX0    X1+X2       (X0) = ADDRESS OF DEFINITION 
          SA3    X0          LENGTH OF SKELETON 
          SA2    INAFR
          IX0    X3+X5
          SB6    X0          (B6) = TOTAL LENGTH NEEDED FOR EXPANSION 
          ZR     X2,AFR60    IF NOT ALREADY INSIDE *ASF*
  
  
**        IF WE WERE ALREADY INSIDE A STATEMENT FUNCTION, THEN THE
*         SPACE FORMERLY OCCUPIED BY THE ACTUAL ARGUMENT TEXT MUST BE 
*         TRASHED.  THE SPACE ACTUALLY NEEDED FOR THE EXPANSION IS -- 
*         (REQ)  = (CURRENT) + (B6) - (ACTUAL ARG LEN)
*                (B6) = LENGTH NEEDED TO HOLD THIS EXPANSION -- 
*                     = (SKELETON LENGTH) + (X5)
*                (X0) = (B6)
*                (X5) = LENGTH NEEDED FOR ALL OCCURENCES OF ACTUAL
*                            ARGUMENTS IN THE SKELETON. 
*                (B5) = FWA ACTUAL ARGS 
*                (B4) = END ACTUAL ARGS, +1 
*                (ACTUAL ARG LENGTH) = (B4) - (B5)
  
          =B4    B4-1 
          =B6    B6-1        DONT THE CELL FOR AN *EOS* 
          SB5    B4-B5       ACTUAL ARGUMENT LENGTH 
  
  
**        FORTUNATELY, WE CAN ADJUST THE ALLOCATION BEFORE MOVING STUFF 
*         AROUND, REGARDLESS OF WHETHER THE TABLE EXPANDS OR CONTRACTS. 
*         THIS IS BECAUSE A SHRINKING TABLE WILL NOT CAUSE ANY MOVEMENT 
*         OF TABLES, AND THE WORDS WHICH ARE NOT NOW FORMALLY IN THE
*         TABLE WILL STILL EXIST, RIGHT WHERE THEY WERE.  ANY SUCH WORDS
*         ARE THEN MOVED TO THEIR NEW POSITION. 
*                (B6) = SIZE OF EXPANSION 
*                (B5) = ACTUAL ARGUMENT LENGTH
*                ADJUSTMENT TO LENGTH = (B6) - (B5) 
*                (B7) = NEW END OF TABLE + 1
  
          SX0    B6-B5
          ALLOC  TT.ASF,X0
          SB2    B6-B5
          SX0    B7 
          =X3    B4+B2       DEST = (FROM) + (ADJUSTMENT) 
          SA5    B4 
          SX2    B4          FROM = END +1 OF ACTUAL ARGS 
          IX1    X0-X3       W.C. = (LWA) - (DESTINATION) 
          MVE    X1,X2,X3    SLIDE THE TRAILING PORTION AROUND
          SA1    TT.ASF 
          SB2    B4-B5       FWA TO STORE SKELETON = (END ARGS) - (LEN) 
          BX7    X5 
          EQ     AFR65       BYPASS RE-ALLOCATION.. 
  
**        WHEN INPUT IS FROM THE *SB*, TT.ASF MUST BE ALLOCATED ENOUGH
*         ROOM TO HOLD THE SKELETON + THE ACTUAL ARGUMENTS IN ALL THEIR 
*         OCCURRENCES.  THIS WAS COMPUTED LONG AGO. 
*                (B6) = AFOREMENTIONED LENGTH 
*                (X0) = DITTO 
*         ALSO, NOW RESET --
*                (INAFR) _ PAST TERMINAL RPAREN OF ACTUAL ARGUMENT. 
  
 AFR60    ALLOC  TT.ASF,X0
          =X6    B4 
          SB2    B7-B6       FWA TO STORE EXPANDED ASF
          SA6    INAFR       SET *SB* ADDRESS TO (EVENTUALLY) RESUME AT 
          BX7    0
  
  
**        ONE WAY OR ANOTHER, ALL NECESSARY ALLOCATIONS AND PRELIMINARY 
*         MOVES HAVE BEEN ACCOMPLISHED. 
*                (X1) = FWA TT.ASF
*                (B2) = FWA TO STORE EXPANSION
  
 AFR65    SA2    FWAASF 
          SA4    ASFARG 
          IX3    X1+X2       (X3) _ SKELETON LENGTH WORD
          SX6    O.LP 
          SB5    X3          (B5) _ FWA OF ARG PARMETER WORDS - 1 
          SA2    TT.SCR 
          SA1    SCR2 
          IX0    X4+X3       (X0) _ FWA SKELETON - 1
          =A4    X0+1        (A4) _ FWA SKELETON
          IX2    X2+X1
          SB3    X2          (B3) _ FWA ACTUAL ARGS 
          SA6    B2 
          SB4    B2 
  
**        IT REMAINS TO DO THE ACTUAL EXPANSION.  THE SKELETON IS MOVED 
*         INTO THE SPACE JUST ALLOCATED -- WHENEVER A FORMAL PARAMETER
*         IS ABOUT TO BE MOVED, WE PICK UP THE SAVED TEXT OF IT (FROM 
*         TT.SCR) AND MOVE THAT, INSTEAD.  MUST NOT FORGET TO SURROUND
*         THE ACTUAL ARGUMENTS WITH PARENS.  THIS IS TO PRESERVE PROPER 
*         GROUPING WITHIN THE ASF EXPANSION.  FOR SINGLE ELEMENT
*         ARGUMENTS, PARENTHESIS BRACKETING IS NOT DONE.
*                (B3) = FWA OF ACTUAL ARGUMENTS (IN TT.SCR) 
*                (B4) = FWA SKELETON
*                (B5) = FWA ARGUMENT POINTERS - 1 
*                (A4) = SKELETON FETCH ADDRESS
*                (A6) = EXPANSION STORE ADDRESS 
*                (X7) = FINAL CHARACTER OF STRING.
  
 AFR72    SB7    X4-O.ASFA
          BX6    X4 
          AX4    P.TAG
          NZ     B7,AFR78    IF NOT REFERENCE TO ARGUMENT 
  
          SA2    X4+B5       FETCH ARGUMENT DESCRIPTOR FROM DEFINITION
          AX2    18 
          SA1    X2+B3       PRE-FETCH 1ST ARGUMENT WORD
          =A1    A1+1        SKIP LEADING DELIMITER 
          AX2    18 
          SB7    X2          (B7) = LENGTH OF THIS ACTUAL ARGUMENT
          SB6    B7-1        FOR LATER TEST 
          EQ1    B7,AFR75    IF SINGLE ELEMENT ARGUMENT 
          =A1    A1-1        RESTORE TO ORIGINAL POSITION 
          =B7    B7+1        ALLOW FOR PARENTHESES
          SX1    O.LP 
 AFR75    BX6    X1 
          =B7    B7-1 
          =A6    A6+1 
          =A1    A1+1 
          GE1    B7,AFR75    LOOP TILL END OF ARGUMENT
          ZR     B6,AFR79    IF SINGLE ELEMENT ARGUMENT 
          SX6    O.RP 
  
 AFR78    =A6    A6+1 
 AFR79    =A4    A4+1 
          NZ     X6,AFR72    IF NOT END OF SKELETON 
          SA7    A6 
  
**        EXPANSION FINISHED, RETURN TO *PAR*.
  
          SA3    SVB6 
          =A2    A3+1 
          SA4    ALC.ASF
          SA1    SCR2 
          SB6    X3          RESTORE (B6) 
          SB5    X2          RESTORE (B5) 
          SHRINK TT=SCR,X1
          BX6    X4 
          SA6    ALC.REG
          NZ     X7,EXIT.    IF NOT ZERO-LEVEL STATEMENT FUNCTION 
          SX7    O.RP 
          BX6    O.EOS
          SA7    A7 
          ADDWD  TT.ASF      ADD AN EXTRA *EOS* 
          EQ     EXIT.
  
          LIST   D
          END 
