Retro1.org codex

*DECK     SSTAQE
USETEXT TEXTSS
PROC SSTAQE(P$TABL$,WC,HEAD,ENTRYQ);
# TITLE SSTAQE - ACCEPT QUEUE ENTRY. #
 
      BEGIN  # SSTAQE # 
# 
**    SSTAQE - ACCEPT QUEUE ENTRY.
* 
*     F. HOU.                81/09/09.
* 
*     THIS PROCEDURE ENTERS A NEW ENTRY INTO A FIFO QUEUE AND 
*     MAKE A WORKLIST REQUEST IF THIS IS THE FIRST ENTRY. 
* 
*     PROC SSTAQE(P$TABL$,WC,HEAD,ENTRYQ) 
* 
*     ENTRY       P$TABL$ = BASED ARRAY POINTER FOR TABLE TABL. 
*                 WC      = WORD COUNT WORD FOR NEW ENTRY.
*                 HEAD    = HEADER WORD FOR NEW ENTRY.
*                 ENTRYQ  = ARRAY OF WC-2 WORDS TO BE ADDED TO QUEUE. 
* 
*     EXIT        A NEW ENTRY HAS BEEN ACCEPTED TO THE QUEUE. 
* 
*     NOTES       NONE. 
* 
*     METHOD
* 
*     ALLOCATES TABLE SPACE FOR NEW ENTRY.
*     MOVES THE NEW ENTRY TO THE ALLOCATED TABLE SPACE OF TABL. 
*     IF TABL WAS EMPTY BEFORE THE MOVE, CALL SSSAWR TO ACCEPT
*     WORKLIST REQUEST WITH WORKLIST NUMBER CORRESPONDING TO TABL.
* 
# 
 
      ITEM P$TABL$    I;     # BASED ARRAY POINTER FOR QUEUE TABL.     #
      ITEM HEAD       I;     # HEADER WORD FOR NEW ENTRY.              #
 
      ARRAY WC [0:0] S(1);   # WORD COUNT WORD FOR NEW ENTRY.          #
        BEGIN 
        ITEM WC$WORD U(00,00,60);  # OVERLAPPING WORD                  #
        ITEM WC$CNT  U(00,48,12);  # 12 BIT WORD COUNT                 #
        END 
 
      ARRAY ENTRYQ[0:0] S(1);  # ARRAY OF WC-2 WORDS TO BE ADDED.      #
        BEGIN 
        ITEM ENTRYQQ U(00,00,60); 
        END 
 
# 
****  PROC SSTAQE - XREF LIST.
# 
 
      XREF
        BEGIN 
        PROC SSTATS;         # ALLOCATE TABLE SPACE.                   #
        PROC MOVEI;          # MOVE BLOCK OF CENTRAL MEMORY WORDS.     #
        PROC SSSAWR;         # ACCEPT WORKLIST REQUEST.                #
        END 
 
# 
****
# 
 
      ITEM COUNT      I;     # WORD COUNT FOR ENTRY TO MOVE.           #
      ITEM FROM       I;     # FIRST WORD ADDRESS OF FROM BLOCK        #
      ITEM INDEX      I;     # INDEX OF QWD-QUEUE TO WORKLIST DEF TABLE#
      ITEM TABLEN     I;     # LENGTH OF TABL                          #
      ITEM TO         I;     # FIRST WORD ADDRESS OF TO BLOCK          #
      ITEM WLN        I;     # WORKLIST NUMBER                         #
 
      BASED ARRAY TEMP [0:0] S(2);  # TEMP FOR GETTING LENGTH OF TABL  #
        BEGIN 
        ITEM TEMP$F U(00,00,60);    # FOR WC                           #
        ITEM TEMP$S U(01,00,60);    # FOR HEAD                         #
        END 
 
 
 
 
 
      $BEGIN                 # INCREMENT COUNT FOR STATISTICS          #
      SVT$VAL[SVL"AQE"] = SVT$VAL[SVL"AQE"] + 1;
      $END
 
 
      P<TEMP>=LOC(P$TABL$)+1;  # SAVE CURRENT LENGTH OF TABL IN TABLEN #
      TABLEN=TEMP$F[0]; 
 
      SSTATS(P$TABL$,WC$CNT[0]);  # ALLOCATE TABLE SPACE               #
 
      P<TEMP>=P$TABL$+TABLEN;  # SET TEMP POINTER TO THE END OF TABL   #
      TEMP$F[0]=WC$WORD[0];  # MOVE WORD COUNT                         #
      TEMP$S[0]=HEAD;        # MOVE HEAD                               #
 
      COUNT=WC$CNT[0]-2;     # WORD COUNT FOR ENTRY PORTION            #
      FROM=LOC(ENTRYQ);      # FIRST WORD ADDRESS OF FROM BLOCK        #
      TO=P$TABL$+TABLEN+2;   # FIRST WORD ADDRESS OF TO BLOCK          #
      MOVEI(COUNT,FROM,TO);  # MOVE ENTRY PORTION TO QUEUE             #
 
      IF(TABLEN EQ 0)        # EMPTY QUEUE CASE                        #
      THEN
        BEGIN 
        INDEX=(LOC(P$TABL$)-SSMEM)/2-1; #TRANSLATE FROM P$TABL$ TO WLN #
        WLN=QWD$WLN[INDEX];  # WORKLIST NUMBER                         #
        SSSAWR(WLN);         # ACCEPT WORKLIST REQUEST                 #
        END 
 
      END  # SSTAQE # 
 
      TERM