*DECK DB$CRMR 
USETEXT CDCSCTX 
      PROC DB$CRMR; 
      BEGIN 
 #
* *   DB$CRMR - CRM RECALL INTERFACE             PAGE  1
* *   R L MCALLESTER                             DATE  01/23/80 
* 
* DC  PURPOSE 
* 
*     PROVIDE AN INTERFACE FROM CRM FOR RECEIVING CDCS REQUEST
*     WHILE CRM WOULD OTHERWISE BE IN RECALL STATUS.
* 
* DC  ENTRY CONDITIONS
* 
*     NONE
* 
* DC  EXIT CONDITIONS 
* 
*     NONE
* 
* DC  CALLING ROUTINES
* 
*     CRM ROUTINE RM$TSYS IS SUBSTITUTED FOR RM$SYS=. 
*     RM$TSYS CALLS TAF$RM TO INTERFACE WITH TAF DURING RECALL PERIODS. 
*     CDCS SUBSTITUTES DB$CRMR FOR RM$TSYS.  (SEE SKELETON) 
* 
* DC  CALLED ROUTINES 
# 
      XREF LABEL DB$CRER;    # GENERATE AREA DOWN MESSAGE.             #
      XREF PROC DB$FLOP;     # GENERATE FLOW POINT                     #
      XREF PROC DB$RCBC;     # CREATE AN RCB                           #
      XREF PROC DB$RCBQ;     # PLACE A NEW REQUEST IN THE RCB QUEUE    #
      XREF PROC DB$RCLM;     # RECALL MACRO WITHOUT DB$IREC CALL       #
      XREF ITEM DB$RCVD;     # REPRIEVE DUMP ENTRY POINT, 0 TIL CALLED #
      XREF PROC DB$TARE;     # TERMINATE AREA                          #
# 
* DC  NON-LOCAL VARIABLES MODIFIED
* 
*     RCB AND RA.SSC MAY BE MODIFIED BY DB$RCBQ AND DB$RCBC.
# 
      XREF ITEM CRMRC   I;   # COUNT OF DB$CRMR CALLS SINCE DB$MTR     #
      XREF ITEM DB$IRQR B;   #TRUE IF AN RCB IS AVAILABLE FOR QUEUING. #
      XREF ARRAY DB$SSC;     #SSC COMMUNICATIONS WORD#
        BEGIN 
        ITEM IRFULLF B(00,00,01);      #TRUE IF DATA IN INPUT REGISTER# 
        ITEM IRPOINT I(00,42,18);      #POINTER TO CURRENT INPUT AREA  #
        END 
      XREF ITEM IN$LNKG B;   # TRUE IF WE ARE NOW EXECUTING DB$LNKG.   #
      XREF ITEM TAKEDMP B;   # FLAG FOR DB$TARE TO TAKE DUMP           #
# 
* DC  DESCRIPTION 
* 
*     IF THE QUEUE READY FLAG (DB$IRQR) IS FALSE, THE REQUEST PACKET HAS
*     ALREADY BEEN PLACED IN THE EXECUTION QUEUE AND IT IS NOT POSSIBLE 
*     TO ALLOCATE A NEW RECEIVING RCB AT THIS TIME. 
*     DO ONE RECALL AND RETURN TO CRM.
* 
*     IF NO REQUEST PACKET HAS BEEN RECEIVED, GO INTO RECALL. 
*     AFTER THE RECALL, TEST AGAIN IF THERE IS A NEW REQUEST. 
*     IF NO REQUEST HAS BEEN RECEIVED ON EITHER TEST, THEN RETURN.
* 
*     WHEN THERE IS A REQUEST, CALL DB$RCBQ TO PREPARE THE REQUEST
*     FOR SCHEDULING. 
*     THEN IF THERE IS AN IDLE RCB, CALL DB$RCBC TO PREPARE THE 
*     IDLE RCB TO RECEIVE ANOTHER REQUEST.
* 
*     DB$CRMR MUST NOT INITIATE A CALL TO CMM SO IT WILL NOT CALL 
*     DB$RCBC WHEN THERE IS NO IDLE RCB.
 #
# 
*     LOCAL ITEMS 
# 
      ITEM RCBSAVED I;       # SAVE RCB POINTER                        #
  
      DEF CRMRCLIM #10000#; 
  
  
  
#     S T A R T   O F   D B $ C R M R   E X E C U T A B L E   C O D E  #
  
      CRMRC = CRMRC +1; 
      IF CRMRC GR CRMRCLIM
      THEN
        BEGIN 
        IF TQLTCF[0]
          AND SCHDFLAG EQ 0 
        THEN
          BEGIN 
  
          CONTROL IFGR DFFLOP,0;
            DB$FLOP("CRMR-TA"); 
          CONTROL ENDIF;
  
          CRMRC = 0;
          TAKEDMP = FALSE;
          DB$TARE(P<OFT>, LOC(DB$CRER)); # LOOPING IN CRM, DOWN AREA   #
          GOTO DB$CRER; 
  
          END 
        END 
  
      IF NOT DB$IRQR         # THE REQUEST IS ALREADY QUEUED AND NO NEW#
      THEN                   # RCB IS AVAILABLE.                       #
        BEGIN 
  
        CONTROL IFGR DFFLOP,0;
          IF CRMRC LS 1000
          THEN
            BEGIN 
            DB$FLOP("CRMR-1");
            END 
        CONTROL ENDIF;
  
        DB$RCLM;
        RETURN; 
  
        END 
      IF NOT IRFULLF[0]      # NO REQUEST HAS BEEN RECEIVED            #
      THEN
        BEGIN 
        DB$RCLM;             # RECALL MACRO                            #
        IF NOT IRFULLF[0] 
        THEN
          BEGIN 
  
          CONTROL IFGR DFFLOP,1;
            DB$FLOP("CRMR-2");
          CONTROL ENDIF;
  
          RETURN;            # RETURN IF NO INPUT                      #
  
          END 
        END 
  
      IF DB$RCVD NQ 0        # IF THE REPRIEVE ROUTINE HAS BEEN CALLED #
      THEN                   # DO NOT PROCESS NEW REQUESTS             #
        BEGIN 
        DB$RCLM;
        RETURN; 
  
        END 
  
      CONTROL IFGR DFFLOP,0;
        DB$FLOP("CRMR");
      CONTROL ENDIF;
  
      RCBSAVED = P<RCB>;
      DB$RCBQ;               # PLACE THE NEW REQUEST IN EXECUTE QUEUE  #
  
      IF IDLERCBP EQ 0
        OR IN$LNKG
      THEN
        BEGIN 
        DB$IRQR = FALSE;     # PREVENTS A REPEAT OF DB$RCBQ.           #
        END 
      ELSE
        BEGIN 
        P<RCB> = RCPRIOR[0];
        DB$RCBC;             # PREPARE ANOTHER RCB FOR INPUT           #
        IRPOINT[0] = LOC(RCIR[0]);
        DB$IRQR = TRUE; 
        IRFULLF[0] = FALSE;  # READY TO ACCEPT ANOTHER REQUEST         #
        END 
      P<RCB> = RCBSAVED;
      END 
      TERM; 
