*DECK STARTUP 
USETEXT COMCBEG 
USETEXT COMRAPL 
USETEXT COMRDSD 
USETEXT COMRLRA 
USETEXT COMRMEM 
USETEXT COMRNDR 
USETEXT COMRNET 
USETEXT COMRQUE 
USETEXT COMRRHH 
USETEXT COMRRTN 
USETEXT COMRSSC 
PROC STARTUP; 
# TITLE STARTUP - START RHF PROCESSING. # 
  
      BEGIN  # STARTUP #
  
# 
**    STARTUP - START RHF PROCESSING. 
* 
*     INITIATES RHF AS A VIABLE SYSTEM CONTROL POINT. 
* 
*     PROC STARTUP. 
* 
*     ENTRY   -  NONE.
* 
*     EXIT    -  INITIALIZATION COMPLETED.
* 
*     PROCESS -  SET UP RA$ ARRAY 
*                SET SHUTDWN FLAG TO TRUE.
*                CHECK JOB ORIGIN TYPE OR SUBSYSTEM ORDINAL.
*                CALL RHH TO OBTAIN MAINFRAME PID.
*                PROCESS CONTROL STATEMENT ARGUMENTS. 
*                IF NOS 
*                THEN 
*                  CALL GETLIDT TO OBTAIN SYSTEM LID TABLE
*                  RESERVE SPACE FOR GETPIDA/GETLIDC CALLS
*                  VERIFY AT LEAST ONE PID IS DEFINED.
*                CALL GETRCF TO OBTAIN LOCAL CONFIGURATION RECORD.
*                CALL SSC TO REQUEST SCP STATUS.
*                CALL RECOVR TO ADD CLRSCP TO REPRIEVE LIST.
*                IF NOS 
*                THEN 
*                  CALL CLRLIDT TO SET ALL RHF PATHS TO N/A 
*                  CALL RECOVR TO ADD CLRLDT TO REPRIEVE LIST.
*                SET UP POINTER WORDS IN LOW RA.
*                SET UP FIRST AND LAST APPLICATION TABLE ADDRS IN LOW RA
*                SET UP NETWORK DESCRIPTION TABLE ADDR IN LOW RA
*                REDUCE MAXNDRS IF THE VALUE SPECIFIED IN THE CONFIGU-
*                  RATION FILE EXCEEDS THE UPPER LIMIT DEFINED IN RHF.
*                SET UP RHH CALL PARAMETER ADDRESS
*                AUTO-LOAD CONTROLWARE IN LOCAL NADS. 
*                SET UP L/K DISPLAY.
*                INITIATE AUTO-START APPLICATIONS.
*                CALL RECOVR TO ADD CLEANUP TO REPRIEVE LIST. 
*                CALL RECOVR TO ADD DUMPFL TO REPRIEVE LIST.
*                CLEAR SHUTDWN FLAG (RHF IS NOW IN-SERVICE).
*                RETURN.
* 
* 
****  PROC STARTUP - XREF LIST BEGIN. 
# 
  
      XREF
        BEGIN 
        LABEL FETADR;                # ADDRESS OF FET FOR CIO CALL #
        LABEL FWAPTRS;               # FWA OF RCFDATA POINTERS #
        ITEM APLNAME  I;             # ADDRESS OF APLNAME # 
        ITEM CONSLPM  I;             # ADDR OF PARAM WORD FOR CONSOLE # 
        ITEM JOBNAME  I;             # ADDRESS OF JOBNAME # 
        ITEM FAPLADR  I;             # FIRST APPLICATION TABLE ADDR # 
        ITEM LAPLADR  I;             # LAST APPLICATION TABLE ADDR #
        ITEM MAXNDRS  I;             # MAXIMUM NDRS # 
        ITEM NADTBL   I;             # LOCAL NAD TABLE ADDRESS #
        ITEM NDRCOM   I;             # NDR COMMUNICATION TABLE ADDRS #
        ITEM NDTADDR  I;             # NETWORK DESCRIPTION TABLE ADDR # 
        ITEM NUMNADS  I;             # NUMBER OF LOCAL NADS # 
        ITEM NUMPWDS  I;             # NUMBER OF PTR WORDS IN RCFDATA # 
        ITEM RCFBVER  U;             # RCFGEN NAME AND VERSION #
        ITEM RCFLGTH  U;             # LENGTH OF RCF RECORD # 
        PROC AUTLOAD;                # AUTO-LOAD CONTROLWARE #
        PROC AUTSTRT;                # AUTO-START APPLICATIONS #
        PROC CALLSYS;                # MAKE RA + 1 CALL # 
        PROC CLEANUP;                # CLEAN UP LOCAL NADS #
        PROC CLRLIDT;                # CLEAR RHF PID STATUS # 
        PROC CLRSCP;                 # CLEAR SCP STATUS # 
        PROC DUMPFL;                 # DUMP MEMORY #
        PROC GETRCF;                 # GET CONFIGURATION RECORD # 
        PROC MOVE;                   # MOVE WORDS # 
        PROC N$CONSL;                # CALL NOS CONSOLE MACRO # 
        PROC N$EESET;                # CALL NOS EESET MARCO # 
        PROC GETLIDT;                # GET CENTRAL LID TABLE  # 
        PROC RECOVR;                 # SYSTEM REPRIEVE INTERFACE #
        PROC RHFMSG;                 # SEND DAYFILE MESSAGE TO RHF CP  #
        FUNC YZTB       C(10);       # CONVERT ZEROS TO BLANKS #
        FUNC BINTODD    C(10);
        END 
  
  
# 
****  PROC STARTUP - XREF LIST END
# 
  
      DEF DATALENGTH #O"4000"#;      # GUESS AT LENGTH OF RCFILE #
  
    CONTROL IFEQ OS$NOS;
      DEF RHF$SSID   #O"7775"#; 
    CONTROL ENDIF;
  
    CONTROL IFEQ OS$NOSBE;
      DEF RHF$SSID   #O"0004"#; 
    CONTROL ENDIF;
  
      ITEM BIAS       I = 0;         # BIAS FOR RCFDATA POINTERS #
      ITEM I          I;             # LOOP VARIABLE #
      ITEM PARMWORD   I = 0;         # PARM WORD FOR SSC CALL # 
      ITEM PREVVER    B = FALSE;     # PREVIOUS RCF VERSION FLAG #
      ITEM RCFFILE    C(10);         # FILE WHERE RCF RECORD FOUND #
  
      DEF MSG$JOPERL #27#;
      ITEM MSG$JOPER  C(MSG$JOPERL) = 
          " RHF, INCORRECT JOB ORIGIN.";
  
      DEF MSG$RHVERL #17#;
      ARRAY MSG$RHVER [0:0] S(2); 
        BEGIN 
        ITEM $DHDR1    C(00,00,06) = [" RHF, "];
        ITEM $DHDR2    C(00,36,03) = [RHFVER];
        ITEM $DHDR3    C(00,54,03) = [" - "]; 
        ITEM $DHDR4    C(01,12,05) = [RHFPSR];
        END 
  
      DEF MSG$RCFERL #46#;
      ARRAY [0:0] S(5); 
        BEGIN 
        ITEM MSG$RCFER  C(00,00,MSG$RCFERL) = 
          [" RHF, CONFIGURATION RECORD XXXXXXX NOT FOUND."];
        ITEM MSG$RCFERN C(02,42,07);
        END 
  
      DEF MSG$RCFL1L #46#;
      ARRAY [0:0] S(5); 
        BEGIN 
        ITEM MSG$RCFL1  C(00,00,MSG$RCFL1L) = 
          [" RHF, USING CONFIGURATION RECORD XXXXXXX FROM"];
        ITEM MSG$RCFLRN C(03,18,07);
        END 
  
      DEF MSG$RCFL2L #48#;
      ARRAY [0:0] S(5); 
        BEGIN 
        ITEM MSG$RCFL2  C(00,00,MSG$RCFL1L) = 
          [" RHF, FILE XXXXXX.  CREATED MM/DD/YY  HH.MM.SS."];
        ITEM MSG$RCFLFN C(01,06,06);
        ITEM MSG$RCFDAT C(02,48,10);
        ITEM MSG$RCFTIM C(03,48,10);
        END 
  
      DEF MSG$RCFVML #45#;
      ITEM MSG$RCFVM  C(MSG$RCFVML) = 
          " RHF, CONFIGURATION RECORD VERSION MISMATCH."; 
  
      DEF MSG$RCFVNL #45#;
      ITEM MSG$RCFVN  C(MSG$RCFVNL) = 
          " RHF, REBUILD CONFIGURATION FILE WITH RCFGEN.";
  
      DEF MSG$MNDRL  #41#;
      ARRAY [0:0] S(4); 
        BEGIN 
        ITEM MSG$MNDR     C(00,00,MSG$MNDRL) =
          [" RHF, MAXIMUM NDRS REDUCED FROM XX TO YY."];
        ITEM MSG$RCFMNDR  C(03,12,02);
        ITEM MSG$RHFMNDR  C(03,42,02);
        END 
  
    CONTROL IFEQ OS$NOS;
      DEF MSG$NLIDTL #21#;
      ITEM MSG$NLIDT  C(MSG$NLIDTL) = 
          " RHF, LID TABLE EMPTY."; 
    CONTROL ENDIF;
  
      ITEM ARGCNT     I;             # ARGUMENT COUNT # 
  
      DEF CST$KW$MAX #01#;           # CONTROL STATEMENT PARAMS # 
  
      STATUS CSTKW
           ERR   # INVALID KEYWORD #
          ,RN    # RN= #
          ; 
  
      SWITCH SW$KW:CSTKW
           SW$KW$ERR:ERR
          ,SW$KW$RN:RN
          ; 
  
      ARRAY [0:CST$KW$MAX] S(1);
        BEGIN 
        ITEM CST$KW     C(00,00,07);
        ITEM CST$KW1    C(00,00,02) = 
          ["RN" 
          ,"**" 
          ];
        ITEM CST$KW2    U(00,12,30) = [CST$KW$MAX(0), 0]; 
        ITEM CST$KW$TYP S:CSTKW(00,42,18) = 
          [S"RN"
          ,S"ERR" 
          ];
        END 
  
      BASED ARRAY KW [0:0] S(1);
        BEGIN 
        ITEM KW$ARG$VAL C(00,00,07);
        ITEM KW$ARG$WD  U(00,00,60);
        ITEM KW$ARG$COD U(00,42,18);
        END 
  
      ARRAY  [0:0] S(1);
        BEGIN 
        ITEM RASSID     U(00,00,60) = [0];
        ITEM RASSNAME   C(00,00,03) = ["RHF"];
        ITEM RASSCODE   U(00,42,18) = [RHF$SSID]; 
        END 
  
      ARRAY  [0:0] S(1);
        BEGIN 
        ITEM SSCCALL    U(00,00,60) = [0];
        ITEM SSCNAME    C(00,00,03) = ["SSC"];
        ITEM SSCRCL     B(00,19,01) = [TRUE]; 
        ITEM SSCPARM    U(00,42,18);
        END 
  
      ARRAY ABTCALL [0:0] S(1);     # ABT CALL REQUEST #
        BEGIN 
        ITEM ABTNAME    C(00,00,03) = ["ABT"];
        ITEM ABTRCL     B(00,19,01) = [TRUE]; 
        ITEM ABTNODUMP  U(00,22,01) = [1];
        END 
  
      ARRAY MEMCALL [0:0] S(1);     # MEM CALL REQUEST #
        BEGIN 
        ITEM MEMNAME    C(00,00,03) = ["MEM"];
        ITEM MEMRCL     B(00,19,01) = [TRUE]; 
        ITEM MEMADDR    I(00,42,18);
        END 
  
      ARRAY MEMPARM [0:0] S(1);     # MEM PARAMETER WORD #
        BEGIN 
        ITEM MEMWD      I(00,00,60) = [0];
        ITEM MEMWORDS   I(00,00,30); # WORDS REQUESTED #
        ITEM MEMCOMPL   B(00,59,01); # MEM COMPLETE # 
        END 
  
      BASED ARRAY RCFILE [0:0] S(1);
        BEGIN 
        ITEM RCF$50TBL  U(00,00,60);  # OVERLAY (50) TABLE #
        ITEM RCF$RECNAM U(01,00,42);  # RECORD NAME # 
        ITEM RCF$DATE   C(02,00,10);  # COMPILE DATE #
        ITEM RCF$TIME   C(03,00,10);  # COMPILE TIME #
        ITEM RCF$COM    C(04,00,70);  # COMMENTS #
#                       U(11,00,60)     UNUSED #
#                       U(12,00,60)     UNUSED #
#                       U(13,00,60)     UNUSED #
#                       U(14,00,60)     UNUSED #
#                       U(15,00,60)     UNUSED #
        ITEM RCF$PTRS   U(16,00,60);  # FIRST POINTER WORD #
        END 
  
      BASED ARRAY RCFPTRS [0:999] S(1); 
        BEGIN 
        ITEM RCFPTRSWD  U(00,00,60);
        END 
  
      ARRAY [0:0] S(1); 
        BEGIN 
        ITEM RCFNAMEWD  U(00,00,60) = [0];
        ITEM RCFNAME    C(00,00,07);
        ITEM RCFRCF     C(00,00,03) = ["RCF"];
        ITEM RCFNAMEPID C(00,18,03);
        END 
  
    CONTROL IFEQ OS$NOS;
      ARRAY         [0:0] S(1);      # DISPLAY BUFFERS ADDRESSES #
        BEGIN 
        ITEM KDISBUF    U(00,00,60); # CPM PARAMETER   #
        ITEM KDISKEY    U(00,00,24); # KEYBOARD BUFFER #
        ITEM KDISRSC    U(00,24,18); # RIGHT SCREEN BUFFER #
        ITEM KDISLSC    U(00,42,18); # LEFT SCREEN BUFFER # 
        END 
  
      ARRAY LDTFET [0:0] S(8);
        BEGIN 
        ITEM LDTFET$WD0    U(00,00,60) = [0]; 
        ITEM LDTFET$EC     U(00,46,04); 
        ITEM LDTFET$CMP    B(00,59,01) = [TRUE];
        ITEM LDTFET$WD1    U(01,00,60) = [0]; 
        ITEM LDTFET$EP     B(01,15,01) = [TRUE];
        ITEM LDTFET$FIRST  I(01,42,18); 
        ITEM LDTFET$WD2    U(02,00,60) = [0]; 
        ITEM LDTFET$IN     I(02,42,18); 
        ITEM LDTFET$WD3    U(03,00,60) = [0]; 
        ITEM LDTFET$OUT    I(03,42,18); 
        ITEM LDTFET$WD4    U(04,00,60) = [0]; 
        ITEM LDTFET$LIMIT  I(04,42,18); 
        ITEM LDTFET$WD5    U(05,00,60) = [0]; 
        ITEM LDTFET$LEN    U(05,00,12); 
        END 
  
      BASED ARRAY LDT$HDR [0:0] S(1); 
        BEGIN 
        ITEM LDT$PCNT   I(00,48,12); # GETLIDT RETURN PID COUNT  #
        END 
  
      ITEM LDTPCNT    I;             # PIDS DEFINED IN SYSTEM LIDT #
  
      DEF GETSSID    #O"110"#;       # GET SUBSYSTEM ID # 
  
      ARRAY CPMCALL [0:0] S(1);      # CPM CALL REQUEST # 
        BEGIN 
        ITEM CPMNAME    C(00,00,03) = ["CPM"];
        ITEM CPMRCL     B(00,19,01) = [TRUE]; 
        ITEM CPMFUNC    U(00,24,12) = [GETSSID];
        ITEM CPMADDR    U(00,42,18);
        END 
  
      ARRAY CPMPARM [0:0] S(1);      # CPM PARAMETER WORD # 
        BEGIN 
        ITEM CPMWD      U(00,00,60) = [0];
        ITEM CPM$SSID   U(00,48,12);
        END 
  
    CONTROL ENDIF;
  
CONTROL EJECT;
  
      SHUTDWN = TRUE;              # SET SHUTDWN FLAG # 
      P<RA$ZERO> = 0; 
      RA$APLADRW = 0;              # CLEAR APPL ADDR WORD # 
      RA$NDTADRW = 0;              # CLEAR NDT ADDR WORD #
  
    CONTROL IFEQ OS$NOS;
      CPMADDR = LOC(CPMPARM); 
      CALLSYS(CPMCALL);            # GET JOB SUBSYSTEM ID # 
      IF CPM$SSID NE RHF$SSID      # IF NOT RHF SUBSYSTEM # 
      THEN
    CONTROL ENDIF;
  
    CONTROL IFEQ OS$NOSBE;
      IF (RA$JOP NE 0)             # IF NOT SYSTEM ORIGIN # 
        AND (RA$JOP NE 1)          #   AND NOT BATCH ORIGIN # 
      THEN
    CONTROL ENDIF;
  
        BEGIN 
        RHFMSG(LOC(MSG$JOPER), MSG$JOPERL); 
        CALLSYS(ABTCALL); 
        END 
  
      RHHPARMAD = LOC(RHH$PARAM); 
      RHHFUNCTN = RH$PID; # OBTAIN THIS MAINFRAMES PID #
      RHHRCL    = TRUE; 
      CALLSYS(RHHCALL); 
      RHHRCL    = FALSE;
      THISPID   = RHH$PID;
      RCFNAMEPID = THISPID; 
      RCFFWA = ((RA$HHA + 7) / 8) * 8;
      FIELDLEN = RCFFWA + DATALENGTH + O"20"; 
      MEMWORDS = (FIELDLEN + O"77") / O"100" * O"100";
      MEMCOMPL = FALSE; 
      MEMADDR = LOC(MEMPARM); 
      CALLSYS(MEMCALL); 
      SHUTDWN = FALSE;
      RHFMSG(LOC(MSG$RHVER), MSG$RHVERL); 
      SHUTDWN = TRUE; 
      ARGCNT = RA$ACT;             # CONTROL CARD ARGUMENT COUNT #
      P<KW> = LOC(RA$ARG) - 1;     # FIRST CONTROL CARD ARGUMENT #
      ASLONGAS (ARGCNT GT 1)
      DO
        BEGIN 
        ARGCNT = ARGCNT - 1;
        P<KW> = P<KW> + 1;
        IF (KW$ARG$COD EQ O"54")   # IF *KW=* # 
          OR (KW$ARG$COD EQ 2)
        THEN
          BEGIN 
          KW$ARG$COD = 0; 
          CST$KW[CST$KW$MAX] = KW$ARG$VAL;
          I = 0;
          ASLONGAS CST$KW[I] NE KW$ARG$VAL
          DO
            BEGIN 
            I = I + 1;
            END 
  
          ARGCNT = ARGCNT - 1;
          P<KW> = P<KW> + 1;
          GOTO SW$KW[CST$KW$TYP[I]];
  
SW$KW$RN:                          # RN=RCFNAME # 
            RCFNAME = KW$ARG$VAL; 
            GOTO SW$KW$END; 
  
SW$KW$ERR:  
SW$KW$END:  
          END 
  
        END 
  
      MSG$RCFERN = YZTB(RCFNAME); 
      MSG$RCFLRN = YZTB(RCFNAME); 
  
    CONTROL IFEQ OS$NOS;
      LDT$BPTR = RCFFWA;
      P<LDT$HDR> = LDT$BPTR;
      LDTFET$FIRST = LDT$BPTR;
      LDTFET$IN = LDTFET$FIRST; 
      LDTFET$OUT = LDTFET$FIRST;
      LDTFET$LIMIT = FIELDLEN - 4;
      GETLIDT(LDTFET, 0);          # GET NUMBER OF PIDS IN LIDT # 
      IF LDTFET$EC EQ 6            # IF LIDT TOO LARGE FOR BUFFER # 
      THEN
        BEGIN 
        FIELDLEN = FIELDLEN - (LDTFET$LIMIT - LDTFET$FIRST) 
                     + LDTFET$LEN + O"20";
        MEMWORDS = (FIELDLEN + O"77") / O"100" * O"100";
        MEMCOMPL = FALSE; 
        MEMADDR = LOC(MEMPARM); 
        CALLSYS(MEMCALL); 
        LDTFET$LIMIT = FIELDLEN - 4;
        GETLIDT(LDTFET, 0); 
        END 
  
      LDTPCNT = LDT$PCNT; 
      IF LDTPCNT EQ 0 
      THEN
        BEGIN 
        RHFMSG(LOC(MSG$NLIDT), MSG$NLIDTL); 
        CALLSYS(ABTCALL); 
        END 
  
    CONTROL ENDIF;
  
      RCFFILE = THISPID;
      BIAS = FIELDLEN;
      I = RCFFWA; 
      GETRCF(RCFNAMEWD, RCFFILE, I, BIAS);
      IF RCFFILE EQ "      "       # IF RECORD NOT FOUND #
        OR BIAS EQ 0               #   OR INSUFFICIENT SPACE #
      THEN
        BEGIN 
        RHFMSG(LOC(MSG$RCFER), MSG$RCFERL); 
        CALLSYS(ABTCALL); 
        END 
  
      P<RCFILE> = I;
      P<RCFPTRS> = LOC(RCF$PTRS); 
      IF ( (RCFBVER-1) EQ RCFPTRSWD[LOC(RCFBVER)-LOC(FWAPTRS)]) 
        AND (NUMPWDS EQ RCFPTRSWD[LOC(NUMPWDS)-LOC(FWAPTRS)]) 
      THEN
        BEGIN 
        PREVVER = TRUE; 
        END 
  
      ELSE
        BEGIN 
        IF (RCFBVER NE RCFPTRSWD[LOC(RCFBVER)-LOC(FWAPTRS)])
          OR (NUMPWDS NE RCFPTRSWD[LOC(NUMPWDS)-LOC(FWAPTRS)])
        THEN
          BEGIN 
          RHFMSG(LOC(MSG$RCFVM), MSG$RCFVML); 
          RHFMSG(LOC(MSG$RCFVN), MSG$RCFVNL); 
          CALLSYS(ABTCALL); 
          END 
  
        END 
  
      MSG$RCFLFN = RCFFILE; 
      MSG$RCFDAT = RCF$DATE;
      MSG$RCFTIM = RCF$TIME;
      SHUTDWN = FALSE;
      RHFMSG(LOC(MSG$RCFL1), MSG$RCFL1L); 
      RHFMSG(LOC(MSG$RCFL2), MSG$RCFL2L); 
      IF C<0,1>RCF$COM EQ " " 
      THEN
        BEGIN 
        C<0,1>RCF$COM = ">";
        END 
  
      I = 68; 
      ASLONGAS C<I,1>RCF$COM EQ " " 
      DO
        BEGIN 
        I = I - 1;                 # REMOVE TRAILING BLANKS # 
        END 
  
      IF I GT 1                    # IF COMMENT IS NOT ALL BLANKS # 
      THEN
        BEGIN 
        RHFMSG(LOC(RCF$COM), (I + 1) ); 
        END 
  
      SHUTDWN = TRUE; 
      MOVE(NUMPWDS, LOC(RCF$PTRS), LOC(FWAPTRS) );
      MOVE(RCFLGTH, (LOC(RCF$PTRS) + NUMPWDS), RCFFWA); 
      LDT$BPTR = RCFFWA + RCFLGTH;
      LDT$BUFL = 0; 
      BIAS = RCFFWA;
      NDRCOM = (LOC(NDRCOMAREA) + 7) / O"10" * O"10"; 
      FAPLADR = FAPLADR + BIAS; 
      RA$FRSTAPL = FAPLADR; 
      LAPLADR = LAPLADR + BIAS; 
      RA$LASTAPL = LAPLADR; 
      NDTADDR = NDTADDR + BIAS; 
      RA$NDT = NDTADDR; 
      NADTBL = NADTBL + BIAS; 
      JOBNAME = JOBNAME + BIAS; 
      APLNAME = APLNAME + BIAS; 
      P<NET$HEADER> = NDTADDR;
      ASLONGAS P<NET$HEADER> NE 0 
      DO
        BEGIN 
        IF NET$NXTPID NE 0
        THEN
          BEGIN 
          NET$NXTPID = NET$NXTPID + BIAS; 
          END 
  
        NET$LIDADR = NET$LIDADR + BIAS; 
        NET$PATHAD = NET$PATHAD + BIAS; 
  
        P<PTH$ENTRY> = NET$PATHAD;
        SLOWFOR I = 1 STEP 1 UNTIL NET$NMPATH 
        DO
          BEGIN 
          PTH$RMTNAD = PTH$RMTNAD + BIAS; 
          PTH$PIDADR = PTH$PIDADR + BIAS; 
          P<PTH$ENTRY> = P<PTH$ENTRY> + PTH$LENGTH; 
          END 
  
        LDT$BUFL = LDT$BUFL + 1;
        P<NET$HEADER> = NET$NXTPID; 
        END 
  
      IF MAXNDRS GT RHF$MAXNDRS 
      THEN
        BEGIN 
        MSG$RCFMNDR = BINTODD(MAXNDRS,2); 
        MAXNDRS = RHF$MAXNDRS;
        MSG$RHFMNDR = BINTODD(MAXNDRS,2); 
        RHFMSG(LOC(MSG$MNDR), MSG$MNDRL); 
        P<NAD$ENTRY> = NADTBL;
        SLOWFOR I = 1 STEP 1 UNTIL NUMNADS
        DO
          BEGIN 
          IF NAD$MAXNDR GT MAXNDRS
          THEN
            BEGIN 
            NAD$MAXNDR = MAXNDRS; 
            END 
  
          P<NAD$ENTRY> = P<NAD$ENTRY> + NAD$LENGTH; 
          END 
  
        END 
  
      IF PREVVER                   # IF PREVIOUS VERSION OF RCF # 
      THEN
        BEGIN 
        P<NAD$ENTRY> = NADTBL;
        SLOWFOR I = 1 STEP 1 UNTIL NUMNADS
        DO
          BEGIN 
          P<NST$ENTRY> = LOC(NAD$NSTWD0); 
          NST$LOG = TRUE;          # SET LOCAL NAD ERROR LOG FLAG # 
          P<NAD$ENTRY> = P<NAD$ENTRY> + NAD$LENGTH; 
          END 
  
        P<RMT$ENTRY> = NADTBL + (NUMNADS*NAD$LENGTH); 
        ASLONGAS P<RMT$ENTRY> LT JOBNAME
        DO
          BEGIN 
          P<NST$ENTRY> = LOC(RMT$NSTWD0); 
          NST$LOG = RMT$LOG;       # SET REMOTE NAD ERROR LOG FLAG #
          P<RMT$ENTRY> = P<RMT$ENTRY> + RMT$LENGTH; 
          END 
  
        P<APL$HEADER> = FAPLADR;
        ASLONGAS P<APL$HEADER> LE LAPLADR 
        DO
          BEGIN 
          IF APL$NAME EQ "MLTF" 
          THEN
            BEGIN 
            APL$ENABLE = FALSE;    # DISABLE MLTF # 
            END 
  
          P<APL$HEADER> = P<APL$HEADER> + APL$LENGTH +
                           (APL$NUMCON * CON$LENGTH); 
          END 
  
        END 
  
    CONTROL IFEQ OS$NOS;
      IF LDTPCNT GT LDT$BUFL
      THEN
        BEGIN 
        LDT$BUFL = LDTPCNT; 
        END 
  
      LDT$BUFL = LDT$BUFL + 3;
    CONTROL ENDIF;
  
    CONTROL IFEQ OS$NOSBE;
      LDT$BUFL = 0; 
    CONTROL ENDIF;
  
      FIELDLEN = ((RCFFWA + RCFLGTH + LDT$BUFL + 7) / 8) * 8 + 4; 
      INITIALFL = FIELDLEN; 
      P<NDT$HEADER> = NDTADDR - 1;
      NDT$NUMLN = NUMNADS;
      NDT$FWALNT = NADTBL;
      NDT$FWA = NDTADDR;
  
    CONTROL IFEQ OS$NOSBE;
      RA$CCDBUFF[0] = LOC(DSD$CMDW[0]); 
      RA$CCDLDIS[0] = "LDISPLAY"; 
    CONTROL ENDIF;
  
    CONTROL IFEQ OS$NOS;
      N$EESET;
      KDISKEY = LOC(DSD$CMDW);
      KDISRSC = LOC(DSD$LSCR);
      KDISLSC = LOC(DSD$LSCR);
      CONSLPM = KDISBUF;
      N$CONSL;
    CONTROL ENDIF;
  
      RA$SSC = 0; 
      RA$SSC$VF = TRUE; 
      RA$SSC$LP = 5;
      RA$SSC$AP = LOC(REQ$BLOCK); 
      RA$SSID = RASSID; 
      SSCPARM = LOC(PARMWORD);
      CALLSYS(SSCCALL);            # ATTEMPT TO BECOME AN SCP # 
      RECOVR(CLRSCP, O"377", 0);
  
    CONTROL IFEQ OS$NOS;
      CLRLIDT;                     # SET ALL PATHS N/A #
      RECOVR(CLRLIDT, O"377", 0); 
    CONTROL ENDIF;
  
      RECOVR(CLEANUP, O"377", 0); 
      RECOVR(DUMPFL, O"077", 0);   # DUMP ONLY ON ERRORS #
      AUTLOAD;                     # INITIALIZE LOCAL NAD TABLE # 
      AUTSTRT;                     # AUTO-START APPLICATIONS #
      SHUTDWN = FALSE;             # RHF NOW IN SERVICE # 
  
      END  # STARTUP #
  
      TERM
  
