*DECK S$OWN 
          PROC  S$OWN(NPARMS, ARRY);
  
#**       S$OWN -  GATHER PARAMETERS ABOUT OWNCODE PROCEDURES          #
#                                                                      #
#     CALLING SEQUENCE-                                                #
#         CALL SMOWN(<OWN-NUM>,<OWN-LOC>, ..., <OWN-NUM>,<OWN-LOC>)    #
#         (THIS CALLS THE MACHINE-DEPENDENT ROUTINE SMOWN WHICH        #
#          COUNTS PARAMETERS AND PUTS THE VALUE OF EACH <OWN-NUM>      #
#          AND THE LOCATION OF EACH <OWN-LOC> INTO AN ARRAY THAT IS    #
#          A PARAMETER TO S$OWN.)                                      #
#                                                                      #
#     GIVEN-                                                           #
#         <NPARMS> = NUMBER OF PARAMETERS ORIGINALLY SUPPLIED.         #
#         <ARRY> = ARRAY WITH <OWN-XXX>, ...                           #
#         <OWN-NUM> = OWNCODE NUMBER.                                  #
#         <OWN-LOC> = ADDRESS (NAME) OF OWNCODE PROCEDURE.             #
#                                                                      #
#     DOES-                                                            #
#         IF MORE THAN 10 PARAMETERS WERE ORIGINALLY GIVEN,            #
#             ISSUE A DIAGNOSTIC, AND                                  #
#             RETURN.                                                  #
#         FOR EACH <OWN-NUM> AND <OWN-LOC>,                            #
#             IF <OWN-LOC> IS NOT SPECIFIED,                           #
#                 ISSUE A DIAGNOSTIC, AND                              #
#                 RETURN.                                              #
#             SAVE A RAW PARAMETER OF-                                 #
#                 TYPE = RP$T"OWN<OWN-NUM>",                           #
#                 VALUE = LOCATION OF <OWN-LOC>.                       #
  
  
          BEGIN 
*CALL NPARMS
          ARRAY  ARRY  [1:10];
              ITEM  ARRY$VAL     I(0, 0,60);     # <OWN-NUM>/<OWN-LOC> #
  
          XREF
              BEGIN 
              PROC  S$ERROR;           # HANDLE A USER ERROR           #
              FUNC  S$INSEQ  B;        # TRUE IFF CALL IN SEQUENCE     #
              PROC  S$SVREL;           # SAVE RAW PARAM. FROM RELOC.   #
              END 
  
*CALL A 
  
*CALL E$
  
*CALL RP$ 
  
*CALL SQ$ 
  
          ITEM  I            I; 
          ARRAY[1:5]; 
              BEGIN 
              ITEM   OWNTYPE     I(0, 0,60)  =
                                       [ RP$T"OWN1" 
                                       , RP$T"OWN2" 
                                       , RP$T"OWN3" 
                                       , RP$T"OWN4" 
                                       , RP$T"OWN5" 
                                       ]; 
              END 
CONTROL DISJOINT; 
  
CONTROL INERT;
  
CONTROL EJECT;
  
#     IF MORE THAN 10 PARAMETERS WERE ORIGINALLY GIVEN,                #
#         ISSUE A DIAGNOSTIC, AND                                      #
#         RETURN.                                                      #
  
          IF NPARMS GQ 11  THEN 
              BEGIN 
              S$ERROR(E$108);          # TOO MANY PARAMETERS           #
#***#         RETURN; 
              END 
  
#     IF NPARMS EQUAL TO 1,3,5,7, OR 9                                 #
#         ISSUE A DIAGNOSTIC, AND                                      #
#         RETURN.                                                      #
  
          IF NPARMS EQ 1
           OR NPARMS EQ 3 
           OR NPARMS EQ 5 
           OR NPARMS EQ 7 
           OR NPARMS EQ 9  THEN 
              BEGIN 
              S$ERROR(E$108);          # TOO FEW/MANY PARAMETERS       #
#***#         RETURN; 
              END 
  
#     FOR EACH PAIR OF PARAMETERS                                      #
#         SAVE RAW PARAMETER OF-                                       #
#             TYPE = RP$T"OWN<OWN-NUM>",                               #
#             VALUE = LOCATION OF <OWN-LOC>.                           #
  
          FOR I=1 STEP 2 UNTIL NPARMS  DO 
              BEGIN 
              IF ARRY$VAL[I] LS 1 
               OR ARRY$VAL[I] GR 5  THEN
                  BEGIN 
                  S$ERROR(E$107);      # ILLEGAL PARAMETER VALUE       #
#***#             RETURN; 
                  END 
              RP$TYPE = OWNTYPE[ARRY$VAL[I]]; 
              RP$VALUE = ARRY$VAL[I+1]; 
              S$SVREL(RP$); 
              END 
  
#     SAVE RAW PARAMETER OF-                                           #
#         TYPE = RP$T"OWNT",                                           #
#         RP$VALUEC = "OLD".                                           #
  
          RP$TYPE = RP$T"OWNT"; 
          RP$VALUEC = "OLD";
          S$SVREL(RP$); 
  
  
          END  # S$OWN #
          TERM
