*DECK S$GTSPC 
          PROC S$GTSPC(SPEC$, UNUSED, STATUS$, LONGSUM);
  
#**       S$GTSPC -  GET ENTIRE USER SPECIFICATION                     #
#                                                                      #
#     CALLING SEQUENCE-                                                #
#         S$GTSPC(SPEC$, STATUS$):                                     #
#                                                                      #
#     GIVEN-                                                           #
#         SPEC$ = UNSET ARRAY DESCRIBED BY COMDECK SPEC$.              #
#         UNUSED = NUMBER OF UNUSED WORDS IN SPEC$                     #
#         STATUS$ = UNSET ARRAY DESCRIBED BY COMDECK STATUS$.          #
#                                                                      #
#     DOES-                                                            #
#         IF ERRORS WERE DETECTED,                                     #
#             SETS STATUS$ ACCORDINGLY                                 #
#         ELSE                                                         #
#             SETS STATUS$STATE TO NORMAL AND                          #
#             SETS ALL FIELDS OF SPEC$.                                #
  
  
          BEGIN 
  
*CALL A 
  
*CALL OWNF$ 
*CALL JCREG 
  
          ITEM UNUSED   I;        # UNUSED WORDS OF SPEC$ ARRAY        #
          ITEM  I;         # SCRATCH #
  
*CALL OWNNA$
  
*CALL SPEC$ 
  
*CALL STATUS$ 
  
          ITEM  LONGSUM         B;
          XREF
              BEGIN 
              ITEM S$MXERR;          # MAXIMUM SEVERITY ENCOUNTERED    #
              ITEM S$JCRV S:JCREG;   # CONTROL REGISTER                #
  
              ARRAY S$ARRY[1:15]; 
                  ITEM S$ARRYELEM        I(0, 0, 60); 
  
              END 
          XREF
              BEGIN 
              PROC  S$ABT;
              PROC  S$CMOP1;           # TELL CMM TO NOT MEM DOWN      #
              PROC  S$ERROR;
              PROC  S$PRSPC;           # PROCESS SPEC$                 #
              PROC  S$PSPEC;           # PRINT SPEC$                   #
              PROC  S$SETWH;           # SET ALMOST WHOLE OF SPEC$     #
              END 
  
              PROC SPCLFT(UNUSED);
  
#             SPCLFT - CALCULATE SPACE LEFT UNUSED IN SPEC$            #
#                                                                      #
#         CALLING SEQUENCE                                             #
#             SPCLFT(UNUSED):                                          #
#                                                                      #
#         GIVEN -                                                      #
#             USES SPEC$ TO CALCULATE THE VALUE UNUSED                 #
#         RETURNS -                                                    #
#             UNUSED = NUMBER OF UNUSED WORDS IN SPEC$                 #
#                                                                      #
#         DOES -                                                       #
#             FINDS THE NUMBER OF WORDS USED BY SPEC$ BY FINDING       #
#             THE GREATEST INDEX OF THE SPEC$ ARRAY.  THEN             #
#             SUBTRACTING THE WORDS USED FROM SPEC$LEN                 #
#                                                                      #
  
              BEGIN 
              ITEM  UNUSED     I;     # NUMBER OF UNUSED WORDS OF BLOCK#
              ITEM  MAX        I;     # GREATEST INDEX PROCESSED       #
              ITEM  I          I;     # INCREMENT VALUE                #
  
              MAX = SPEC$1STINDX; 
  
              FOR I = SPEC$1STKEY  WHILE I NQ 0  DO 
                  BEGIN 
                  IF I+1 GR MAX  THEN 
                      MAX = I+1;
                  IF SPEC$KEYCS[I] NQ 0  THEN 
                      BEGIN 
                      IF (SPEC$KEYCS[I] + 63) GR MAX  THEN
                          MAX = SPEC$KEYCS[I] + 63; 
                      END 
                  I = SPEC$NEXTKEY[I];
                  END 
  
              FOR I = SPEC$1STSUM  WHILE I NQ 0  DO 
                  BEGIN 
                  IF I+1 GR MAX  THEN 
                      MAX = I+1;
                  I = SPEC$NEXTSUM[I];
                  END 
  
              FOR I = SPEC$1STINF  WHILE I NQ 0  DO 
                  BEGIN 
                  IF I+1 GR MAX  THEN 
                      MAX = I+1;
                  I = SPEC$NEXTIN[I]; 
                  END 
  
              UNUSED = SPEC$LEN - (MAX + 1);
  
              END 
  
          CONTROL DISJOINT; 
  
          CONTROL INERT;
  
CONTROL EJECT;
  
#     TELL CMM TO NOT MEM DOWN                                         #
  
          S$CMOP1;
  
# INITIALIZE THE INTERNAL INFORMATION ARRAY                            #
  
          FOR I=1 STEP 1 UNTIL 15 DO
              S$ARRYELEM[I] = 0;
  
#     SET OWNF$, OWNNA$, SPEC$, STATUS$                                #
  
          S$JCRV = 0; 
          STATUS$NORML = TRUE;
          S$SETWH(OWNF$, OWNNA$, SPEC$, STATUS$, LONGSUM);
  
          IF NOT STATUS$NORML  AND  S$MXERR EQ 0  THEN
                 # S$QUIT WAS CALLED FROM INTERACTIVE DIALOG           #
              RETURN; 
  
  
          # IF NO FATAL OR CATASTROPHIC ERRORS, THEN                   #
          # PROCESS SPEC$, CREATING ANY NECESSARY FITS                 #
  
          IF S$MXERR LQ 30 THEN 
              S$PRSPC(SPEC$,STATUS$); 
  
          IF NOT STATUS$NORML  THEN 
              BEGIN 
              IF S$MXERR GQ 40 OR S$MXERR EQ 0  THEN
#                FATAL OR CATASTROPHIC ERRORS FOUND, OR S$QUIT CALLED  #
                  BEGIN 
#***#             RETURN;                       # TO S$MAIN            #
                  END 
  
              END 
          SPCLFT(UNUSED);            # CALCULATE SPACE UNUSED IN SPEC$ #
  
#      PRINT SPEC$, OWNF$, OWNNA$ ON FILE "CODE" IF                    #
#      STATUS$NORML EQUALS TRUE.   DON'T CALL                          #
#      'S$PSPEC' IF S$PRSPC WASN'T CALLED OR YOU'LL                    #
#      ENCOUNTER AN INFINITE LOOP WHILE PRINTING                       #
  
          $BEGIN
          S$PSPEC(SPEC$, OWNF$, OWNNA$);
          $END
  
          END  # S$GTSPC #
          TERM
