*DECK S$ERROR 
          PROC S$ERROR(ENUM,STRING$,VAL); 
  
#**       S$ERROR -  ISSUE A DIAGNOSTIC                                #
#                                                                      #
#     CALLING SEQUENCE-                                                #
#         S$ERROR(ENUM[,STRING$,NUM]):                                 #
#                                                                      #
#     GIVEN-                                                           #
#         ENUM = E$<NUMBER> INDICATING MESSAGE, SEVERITY, AND WHETHER  #
#           A VALUE IS TO BE INSERTED INTO THE MESSAGE.                #
#         VAL = VALUE TO BE INSERTED.                                  #
#           (MAY BE CHARACTER OR INTEGER DEPENDING ON ENUM.)           #
#         STRING$ = ARRAY CONTAINING A STRING AND IT'S LENGTH          #
#                                                                      #
#     DOES-                                                            #
#         ENSURES THAT THE DIAGNOSTIC IS HANDLED PROPERLY.             #
#                                                                      #
#     METHOD-                                                          #
#         THE TASK IS COMPLICATED BECAUSE ERRORS CAN OCCUR BEFORE THE  #
#         SPECIFICATIONS FOR ERROR PROCESSING HAVE BEEN SUPPLIED.      #
#         THESE SPECIFICATIONS ARE THE ERROR-FILE AND THE ERROR-LEVEL. #
#                                                                      #
#         IF ERROR-FILE AND ERROR-LEVEL HAVE NOT BEEN SPECIFIED,       #
#             SAVE THE DIAGNOSTIC NUMBER AND VALUE ON A FILE, AND      #
#             RETURN.                                                  #
#         WHILE DIAGNOSTICS ARE STILL ON THE FILE,                     #
#             READ DIAGNOSTIC NUMBER AND VALUE, AND                    #
#             PROCESS DIAGNOSTIC.                                      #
#         PROCESS THE CURRENT DIAGNOSTIC.                              #
#         RETURN.                                                      #
#                                                                      #
#         "PROCESS DIAGNOSTIC" CONSISTS OF-                            #
#             IF ERROR-FILE IS "NULL",                                 #
#                 DONE.                                                #
#             IF THE DIAGNOSTIC SEVERITY IS LESS THAN ERROR-LEVEL,     #
#                 DONE.                                                #
#             COPY THE MESSAGE TO A BUFFER CHARACTER BY CHARACTER.     #
#             WHEN AN APPROPRIATE SIGNAL CHARACTER IS FOUND,           #
#                 FORMAT THE VALUE AND INSERT IT IN THE BUFFER.        #
#             CONTINUE COPYING.                                        #
#             WRITE THE BUFFER TO THE ERROR-FILE.                      #
#                                                                      #
#     NOTE-                                                            #
#         THE USER MAY OMIT ERROR-FILE AND/OR ERROR-LEVEL.             #
#         AT END OF PARAMETER GATHERING, SORT MAY SET ONE OR BOTH TO   #
#         DEFAULT VALUES.  IF SO, S$ERROR WILL BE CALLED WITH THE      #
#         SPECIAL DIAGNOSTIC NUMBER E$0 WHOSE SEVERITY WILL ALWAYS BE  #
#         LESS THAN ERROR-LEVEL.  THIS WILL FLUSH THE FILE WITHOUT     #
#         ANY SPECIAL CONSIDERATION ON THE PART OF S$ERROR.            #
  
          BEGIN 
          ITEM  ENUM         I;        # E$<NUMBER>  #
          ITEM  VAL          I;         # VALUE (OPTIONAL)  # 
  
*CALL A 
  
*CALL STRING$ 
  
*CALL JCREG 
  
          XDEF
              BEGIN 
              ITEM S$ELEV = 100;         # ERROR LEVEL SPECIFIED       #
              ITEM S$EFNAM C(10) = " ";  # ERROR FILE NAME             #
              ITEM S$LFNAM C(10) = " ";  # LIST FILE NAME              #
              ITEM S$MXERR = 0;          # MAXIMUM SEVERITY            #
              ITEM S$LOGLN = 0;  # LOGICAL LINE NUMBER                 #
              ITEM S$JCRV S:JCREG = S"DUMB";  # CONTROL REGISTER       #
              END 
          XREF
              BEGIN 
              PROC  S$LOADS;           # LOAD AND EXECUTE CAPSULE      #
              PROC  S$ULODS;
              END 
  
          ITEM  LOADEDCAP    B = FALSE; 
  
          CONTROL DISJOINT; 
  
          CONTROL INERT;
  
CONTROL EJECT;
  
          S$LOADS(ENUM, STRING$, VAL);
          IF ENUM EQ 0 THEN 
              S$ULODS("S$ERR"); 
  
          END  # S$ERROR #
          TERM
