*DECK     FUN 
          IDENT  FUN
 FUN      SECT   (INLINE / EXTERNAL FUNCTION PROCESSORS),1
  
          SST    A,B,C,D
          NOREF  A,B,C,D
  
 B=FUN    RPVDEF             DEFINE ROUTINE FWA FOR REPRIEVE UTILITY
  
          ENTRY  O=ARG,O=RJT,O=FUN,O=BEF,ARGNUM 
  
*         IN TABLES 
          EXT    RJSUB,RJTDUM,ROUTNAM,REGFILE,RREG
          EXT    TG.PRO,TP.APL,T.VDIM,TT.SCR,UUC
  
*         IN PIG
          EXT    WIN
  
*         IN ALLOC
          EXT    ADW,NAP
  
*         IN KEY
          EXT    EMT
  
*         IN REG
          EXT    ASR,CLI,CIA,CRJ,CWI,DIT,GST
  
*         IN GEN
          EXT    EIS.PNX,SA=BK,XMITS3,SLD 
  
 O=BEF    SPACE  4,8
**        O=BEF - RETURN JUMP TO CALL-BY-VALUE FUNCTION.
* 
*         ENTRY  (1OP) = ROUTINE TAG. 
*                (B4) _ TURPLE BEING PROCESSED. 
*                CODE TO LOAD THE ARGUMENT(S) HAS BEEN COMPILED BY
*                            PRECEDING *O=RAG* TURPLES. 
*         EXIT   TO *O=FUN2*. 
*         CALLS  CRJ. 
  
  
 O=BEF    SA1    B4+OR.1OP
          BX6    X1 
          CRJ    NONE 
          EQ     O=FUN2      CONTINUE.. 
 O=FUN    SPACE  4,8
**        O=FUN - RETURN JUMP TO CALL-BY-NAME FUNCTION. 
* 
*         ENTRY  (1OP) = ROUTINE TAG. 
*                (B4) _ TURPLE BEING PROCESSED. 
*                ARGUMENTS HAVE BEEN SET UP BY PRECEEDING *O=ARG* 
*                            TURPLES -- 
*                (ARGNUM) SET-UP BY *O=ARG*.
*                (TP.APL) SET-UP BY *O=ARG*.
* 
*         EXIT   TO *EIS.PNX*.
*                (B4) ADVANCED
*         CALLS  PEJ, TRF.
* 
*         NOTE   ALSO CONTAINS PROCESSING USED BY *O=BEF*.
  
  
 O=FUN    SA1    B4+OR.1OP
          BX6    X1 
          SA6    ROUTNAM
          RJ     PEJ         COMPILE EXTERNAL JUMP. 
  
**        JOINED HERE BY CALL-BY-VALUE RETURN JUMP. 
  
 O=FUN2   BX5    0
          MX7    0
          SB2    R.X6-RGFILE 0TR (UPPER HALF) 
          =B3    0           RESULTS OF UPPER HALF
          SA7    UUC
          RJ     DIT         DEFINE INTERMEDIATE RESULTS
          =A1    B4+OR.OPR
          MX0    -L.MODE
          AX1    P.DMOD 
          BX2    -X0*X1 
          IFBIT  X2,-LONG,O=FUN5   IF SINGLE RESULT 
          BX5    0
          SB2    R.X7-RGFILE 0TR (LOWER HALF) 
          =B3    1           RESULTS OF LOWER HALF
          RJ     DIT         DEFINE INTERMEDIATE RESULTS
  
 O=FUN5   =B4    B4+L.TURP
          EQ     EIS.PNX     CONTINUE 
 O=ARG    SPACE  4,20 
**        O=ARG -  PROCESS EXTERNAL ARGUMENT REFERENCE. 
* 
*         ENTRY  DEFINE ONLY FROM *EIS* - EXPAND INSTRUCTION SKELETON.
*                (B4) _ CURRENT TURPLE. 
*                (1OP) = N/A
*                (2OP) = ARGUMENT TAG + BIAS
*                (B5) _ START OF PARSED FILE. 
*                (ARGNUM) = NUMBER OF ARGUMENTS PREVIOUSLY PROCESSED FOR
*                            THIS CALL. 
*                (TP.APL) = CONTAINS THOSE PREVIOUS ARGUMENTS.
* 
*         EXIT   (B4) = B4+L.TURP 
* 
*         CALLS  ADDWD
*         USES   CANNOT DESTROY *B4*, *A7*
  
  
 O=ARG    BSS    0
          DRITE  DEACTIVATE 
          SA1    ARGNUM 
          SA2    B4+OR.2OP   FETCH ARGUMENT 
          =X6    X1+1 
          BX0    X2 
          SBIT   X0,INTR
          SA6    A1          UPDATE ARGUMENT COUNT. 
          ZR     X2,ARG64    IF NULL ARG SIGNALING FOR -0 WORD
          LX5    X2 
          BX6    X2 
          BX3    X2 
          AX3    P.TGB
          SB7    X3-C.STN/1S13
          ZR     B7,ARG60    IF STATEMENT NUMBER TAG
          BX1    X0 
          IFBIT  X1,ADDR/INTR,ARG70  IF ADDRESS SET 
          PL     X0,ARG60    IF NOT INTERMEDIATE
  
**        PROCESS IF *INTERMEDIATE* 
  
          IFBIT  X0,2ARY/INTR,ARG40 
          BX1    X6 
  
**        PROCESS IF *TEMPORARY* VALUE. 
  
          =B2    0           STATUS OF LOWER HALF 
          =B7    0           STATUS OF TAG ONLY 
          RJ     GST         GET STATUS OF TAG
          BX6    X1 
          ZR     B2,ARG60    IF INTERMEDIATE NOT IN REGISTER
          RJ     CWI         COMPILE STORE OF INTERMEDIATE. 
          SA2    B4+OR.2OP
          MX0    -L.MODE
          BX5    X2 
          AX2    P.DMOD 
          BX1    -X0*X2 
          IFBIT  X2,-LONG,ARG60    IF SINGLE RESULT 
          SA6    ARGNUM+1 
          =B2    1                   STATUS OF LOWER HALF 
          =B7    0
          RJ     GST
          ZR     B2,ARG10    IF LOWER HALF NOT IN REGISTER
          SA5    B2+REGFILE 
          RJ     CWI
 ARG10    SA5    ARGNUM+1 
          BX6    X5 
          EQ     ARG60
  
**        PROCESS IF *PLUG* VALUE.
  
 ARG40    SB2    B0 
          SB7    B0 
          RJ     GST         GET STATUS OF TAG
          NZ     B2,ARG43    IF IN REGISTER 
  
*         INTERMEDIATE REQUIRES PROCESSING OF LOAD INTO REGISTER
*         (KNOWN TO BE *SUBSCRIPTED ARRAY LOAD BY FLAG IN OPERATOR WORD)
  
 ARG42    RJ     ASR         ASSIGN RESULT REGISTER 
          SX7    B2 
          SA7    RREG        SET HARD REGISTER
          SA1    B4+OR.2OP
          =X0    M.ADDR      SET ADDRESS BIT
          SB2    B0 
          BX5    X1+X0
          RJ     SLD         PROCESS ARRAY LOAD 
          SX3    B2          RESULT REGISTER LOAD = 0TR.
          EQ     ARG45       CONTINUE 
  
*         INTERMEDIATE ALREADY LOADED, CHECK IF IN RESULT REGISTER AND
*         IF NOT PUT IT THERE.
  
 ARG43    SA1    B2+REGFILE 
          SX0    B2-R.X6+RGFILE 
          SX3    B2 
          IFBIT  X1,-ADDR,ARG42  IF ADDRESS 
          PL     X0,ARG45   IF IN RESULT REGISTER 
          RJ     ASR         ASSIGN STORE REGISTER
          SX3    B2 
          MX0    -3 
          BX7    -X0*X4 
          IX2    X7+X6
          SX7    X2+XMITS3
          LX7    P.LI15+3 
          WCODE  X7          OUTPUT *XMIT* TO RESULT REGISTER 
  
*         (X3) = 0TR. FOR REGISTER TO STORE FROM, INTO *AP-LIST* TAG
  
 ARG45    MX0    -3 
          SA2    TG.PRO 
          BX3    -X0*X3      =00R 
          SA1    ARGNUM 
          LX3    6           =R00 
          =X1    X1-1        ARGNUM-1 FOR APLIST OFFSET 
          =X2    X2+1        NEXT PROGRAM TAG WILL BE OUR AP-LIST 
          SX6    X3+SA=BK 
          LX1    P.LBIAS
          LX2    P.LTAG 
          BX3    X1+X2
          LX6    P.LI15 
          IX7    X3+X6
          WCODE  X7          OUTPUT *STORE* INTO *AP-LIST* TAG
          MX6    L.ABIAS+L.ATAG    INDICATE *PLUG*
          EQ     ARG65
  
**        ADD ELEMENT TO AP-LIST TABLE
*         ENTRY  (X6) = TAG.
  
 ARG60    MX0    L.ATAG 
          SBIT   X6,ATAG/2TAG 
          BX1    X6 
          AX1    P.TGB
          SB7    X1-C.SCR/1S13
          NZ     B7,ARG62 
          AX6    P.ATAG 
          =X1    C.SCR
          IX1    X6-X1
          SA2    TT.SCR 
          MX0    L.ATAG+L.ABIAS 
          SB7    X2 
          SA5    X1+B7
          BX6    X5 
          SBIT   X6,ATAG/2TAG 
  
**        CHECK IF ARGUMENT IS A FORMAL PARAMETER.
  
 ARG62    BX2    X5 
          MX7    -L.2FPNO 
          BX6    X0*X6
  
*         BIT *ALCM* MUST BE TURNED ON IN THE AP-LIST ENTRY FOR AN
*         ECS/LCM ITEM. 
  
          RJ     =XCLT       CHECK FOR LCM/ECS TAG
          ZR     X3,ARG63    IF LCM OR ECS TAG
          EQ     ARG635 
  
 ARG63    MX0    1
          LX0    P.ALCM+1    TURN ON *ALCM* BIT 
          BX6    X0+X6
 ARG635   AX2    P.2FPNO
          BX7    -X7*X2 
          AX2    P.TGB-P.2FPNO
          SX1    X2-C.SYM/1S13
          NZ     X1,ARG65    IF NOT *SYMB0L*
          ZR     X7,ARG65    IF NOT A FORMAL PARAMETER
          RJ     ASR
          =X0    M.ADDR 
          BX5    X0+X5
          MX7    L.2TAG+L.2BIAS+L.2FPNO 
          BX1    X7*X5
          RJ     CLI         COMPILE LOAD INSTRUCTION 
          SX3    B2 
          EQ     ARG45
  
 ARG64    MX6    60          -0 WORD PRECEDING RETURNS LIST 
 ARG65    ADDWD  TP.APL 
  
**        RETURN TO *ARITH* 
  
          SB4    B4+L.TURP
          EQ     EIS.PNX     CONTINUE 
 ARG70    RJ     ASR
          BX0    X5 
          IFBIT  X0,INTR,ARG75  IF ARRAY ADDRESS SET
  
*         ADDR OPERANDS ARE ALWAYS IN SCRATCH TABLE.
  
          SA3    TT.SCR 
          AX5    P.2TAG 
          SB7    X3 
          MX7    L.2TAG+L.2BIAS+L.2FPNO 
          SX5    X5-C.SCR 
          SA5    X5+B7
          BX1    X7*X5
          RJ     CLI
  
 ARG71    SA3    =XTG.TEM 
          =X7    X3+1 
          SA7    A3 
          LX3    P.LTAG 
          SX2    B2 
          MX0    -3 
          BX2    -X0*X2 
          LX2    6           =R00 
          SX6    X2+SA=BK 
          LX6    P.LI15 
          IX7    X3+X6
          WCODE  X7 
          LX3    P.ATAG-P.LTAG
          BX6    X3 
          EQ     ARG65
  
 ARG75    SX7    B2 
          SA7    RREG 
          SB2    B0 
          RJ     SLD
          EQ     ARG71
 O=RJT    SPACE  4,8
**        O=RJT - GENERATE RETURN JUMP TO EXTERNAL. 
* 
*         ENTRY  (1OP) = ROUTINE TAG. 
*                (B4) _ TURPLE BEING PROCESSED. 
*                ARGUMENTS HAVE BEEN SET UP BY PRECEEDING *O=ARG* 
*                            TURPLES -- 
*                (ARGNUM) SET-UP BY *O=ARG*.
*                (TP.APL) SET-UP BY *O=ARG*.
*         EXIT   TO *EIS.PNX*.
*                (B4) ADVANCED. 
*         CALLS  PEJ
  
  
 O=RJT    BSS    0           ENTRY... 
          =A4    B4+OR.1OP
          BX6    X4 
          SA6    ROUTNAM
          RJ     PEJ         PROCESS EXTERNAL JUMP
          SB4    B4+L.TURP
          EQ     EIS.PNX     EXIT.. 
 PEJ      SPACE  4,20 
**        PEJ -  PROCESS EXTERNAL JUMP. 
* 
*         ENTRY  (ARGNUM) = NUMBER OF ARGUMENTS.
*                (ROUTNAM)= TAG OF ROUTINE TO CALL. 
*                (TP.APL) = CONTAINS THE ARGUMENTS, AT THE VERY END OF
*                            THE TABLE. 
*                (TRACE) = LINE NO. FOR TRACEBACK 
* 
*         EXIT   EXTERNAL JUMP COMPILED.
*                (ARGNUM) = 0 
* 
*         CALLS  ADDWD, CLOAD, CRJ
  
  
 PEJ6     SA1    ROUTNAM
          MX0    -L.2FPNO 
          BX6    X1 
          AX1    P.2FPNO
          BX2    -X0*X1 
          NZ     X2,PEJ4     IF FORMAL PARAMETER
  
 PEJ8     SA3    =XTRACE
          CRJ    MUST 
  
 PEJ      SUBR   -           ENTRY/EXIT...
          RJ     CIA         CLEAR INTEMEDIATES / ASSOCIATES
          SA2    ARGNUM 
          BX6    0
          =B6    X2+1        = ARGUMENT COUNT + ZERO WORD 
          SA6    A2          CLEAR ARG COUNT FOR NEXT ENTRY 
          ADDWD  TP.APL      ADD ENDING WORD OF 0 
  
 SNAP=L   IFNE   TEST        DUMP AP-LIST TABLE 
         SA3    =XCO.SNAP 
          LX3    1RL
          PL     X3,PEJ3S    IF AP-LIST SNAP NOT SELECTED 
          DUMPT  (TP.APL) 
 PEJ3S    BSS    0
 SNAP=L   ENDIF 
  
          SB3    B6 
          RJ     NAP         SCAN/ENTER AP-LIST TABLE.
          AX6    P.TAG
          SX1    SA=BK+100B 
          LX1    18-3 
          BX7    X1+X6
          LX7    30 
          WCODE  X7,PEJ6     COMPILE LOAD OF AP-LIST TAG
  
**        HERE TO HANDLE *RJ* TO DUMMY ARGUMENT.
*                EMIT AN ADDRESS SUBSTITUTION TURPLE TO THE VAR-DIM 
*                GENERATOR. 
  
 PEJ4     SA3    TG.PRO 
          SA4    ROUTNAM
          =X7    X3+1 
          SB3    RJSUB
          SB3    -B3
          BX5    X7 
          =X0    M.ADDR 
          SA7    A3          ADVANCE (TG.PRO) 
          BX4    X4+X0
          SA1    T.VDIM 
          LX5    P.2TAG 
          RJ     EMT         EMIT  (O=RJSUB, ROUTNAM, *)
          AX5    P.2TAG 
          CBSS   X5 
  
**        IF THIS WAS THE FIRST *RJ* TO A FORMAL PARAMETER, NOTIFY *FVD*
*                THAT A SKELETON *RJT* WORD WILL BE NECESSARY.
  
          SA1    RJTDUM 
          BX6    0
          NZ     X1,PEJ8     IF PREVIOUS DUMMY CALL 
          SX7    CT.RJS 
          SA7    A1 
          EQ     PEJ8        CONTINUE.. TO OUTPUT DUMMY *RJ* WORD 
  
 ARGNUM   DATA   0,0
          LIST   D
          END 
