*DECK S$INSEQ 
          FUNC  S$INSEQ(SQNAME) B;
  
#**       S$INSEQ -  TRUE IFF CALLED IN CORRECT SEQUENCE               #
#                                                                      #
#     CALLING SEQUENCE-                                                #
#         IF NOT S$INSEQ(SQ$"<NAME-OF-THIS-PROCEDURE>")  THEN          #
#             (ERROR)                                                  #
#                                                                      #
#     GIVEN-                                                           #
#         SQNAME = SQ$ STATUS CONSTANT INDICATING WHICH PROCEDURE      #
#           CALLED S$INSEQ.                                            #
#                                                                      #
#     DOES-                                                            #
#         IF THE CALLED PROCEDURE WAS CALLED IN THE CORRECT SEQUENCE,  #
#             RETURNS WITH S$INSEQ = TRUE                              #
#         ELSE                                                         #
#             RETURNS WITH S$INSEQ = FALSE.                            #
  
  
          BEGIN 
          ITEM  SQNAME       I; 
          ITEM  SMUSED       I=0;  # 0 = NEITHER 1 NOR 2 OCCURRED      #
                # 1 = SMSORT/SMMERGE CALLED BUT SMEND NOT YET CALLED   #
                # 2 = SM5SORT/SM5MERG CALLED BUT SM5END NOT YET CALLED #
  
          XREF
              PROC  S$ABORT;           # HANDLE INTERNAL ERROR         #
  
*CALL A 
  
*CALL SQ$ 
  
*CALL SQ$SWITCH 
  
CONTROL DISJOINT; 
  
CONTROL INERT;
  
CONTROL EJECT;
  
          $BEGIN
          IF SQNAME LQ 0
           OR SQNAME GQ SQ$"$MAX$"  THEN
              S$ABORT("S$INSEQ-1"); 
          $END
  
          GOTO SQ$SWITCH[SQNAME]; 
  
SMMERGE:  
SMSORT: 
          IF SMUSED EQ 0  THEN
              BEGIN 
              SMUSED = 1; 
              S$INSEQ = TRUE; 
              END 
          ELSE
              BEGIN 
              S$INSEQ = FALSE;         # PROVOKE ERROR                 #
              SMUSED = 0;              # IN CASE OF RECOVERY           #
              END 
          RETURN; 
  
SMEND:  
          IF SMUSED EQ 1  THEN
              BEGIN 
              SMUSED = 0; 
              S$INSEQ = TRUE; 
              END 
          ELSE
              BEGIN 
              S$INSEQ = FALSE;         # PROVOKE ERROR                 #
              SMUSED = 0;              # IN CASE OF RECOVER            #
              END 
          RETURN; 
  
SM5MERG:  
SM5SORT:  
          IF SMUSED EQ 0  THEN
          BEGIN 
              SMUSED = 2; 
              S$INSEQ = TRUE; 
              END 
          ELSE
              BEGIN 
              S$INSEQ = FALSE;         # PROVOKE ERROR                 #
              SMUSED = 0;              # IN CASE OF RECOVERY           #
              END 
          RETURN; 
  
SM5END: 
          IF SMUSED EQ 2  THEN
              BEGIN 
              SMUSED = 0; 
              S$INSEQ = TRUE; 
              END 
          ELSE
              BEGIN 
              S$INSEQ = FALSE;         # PROVOKE ERROR                 #
              SMUSED = 0;              # IN CASE OF RECOVERY           #
              END 
          RETURN; 
  
SMEQU:  
SMFILE: 
SMKEY:  
SMOPT:  
SMOWN:  
SMSEQ:  
          IF SMUSED EQ 1  THEN
              S$INSEQ = TRUE; 
          ELSE
              BEGIN 
              S$INSEQ = FALSE;         # PROVOKE ERROR                 #
              SMUSED = 0;              # IN CASE OF RECOVERY           #
              END 
          RETURN; 
  
SM5E: 
SM5EL:  
SM5ENR: 
SM5EQU: 
SM5EXC: 
SM5FAST:  
SM5FROM:    
SM5KEY: 
SM5MRL: 
SM5MSLI:  
SM5NODA:  
SM5OFL: 
SM5OMRL:  
SM5OPT: 
SM5OWN1:  
SM5OWN2:  
SM5OWN3:  
SM5OWN4:  
SM5OWN5:  
SM5RETA:  
SM5SEQ: 
SM5ST:  
SM5SUM: 
SM5TO:  
          IF SMUSED EQ 2  THEN
              S$INSEQ = TRUE; 
          ELSE
              BEGIN 
              S$INSEQ = FALSE;         # PROVOKE ERROR                 #
              SMUSED = 0;              # IN CASE OF RECOVERY           #
              END 
          RETURN; 
  
$MAX$:  
          $BEGIN
          S$ABORT("S$INSEQ-2"); 
          $END
          END  # S$INSEQ #
          TERM
