*DECK S$GNSUM 
          PROC  S$GNSUM(SPEC$,ORSA,IRRL,LR,BUFREC); 
#**       S$GNSUM- GENERATED SUMMING CODE                              #
  
#     CALLING SEQUENCE-                                                #
#         S$GNSUM(SPEC$,ORSA,IRRL,LR,BUFREC)                           #
  
#     GIVEN-                                                           #
#         SPEC$ = USER SPECIFICATION ARRAY                             #
#         ORSA = OFFSET FOR RECORD STORAGE AREA                        #
#         IRRL = INTERNAL RECORD LENGTH                                #
#         LR = NUMBER OF BITS TO HOLD INDEX TO RSA                     #
#         BUFREC = TRUE (I.E. NON-ZERO IF REMAINDER OF RECORD IN       #
#                  I/O BUFFER, FALSE IF IN RSA                         #
  
#     DOES-                                                            #
#         GENERATE CODE INTO CODE$.                                    #
  
#     NOTES-                                                           #
#         THIS GENERATED CODE SUUMS FIELDS OF UP TO 60 BITS EACH       #
#         FROM THE LL AND CR RECORDS.  THIS SUM IS PLACED IN CR,       #
#         AND 0 IN LL.                                                 #
  
#         IF OVERFLOW OCCURS, THE MAXIMUM (POSITIVE OR NEGATIVE)       #
#         VALUE IS PLACED IN CR, AND THE REMAINDER OF THE              #
#         SUM-MAXIMUM IS PLACED IN LL.                                 #
  
#         SUM FIELDS HAVE BEEN INVERTED LIKE KEYS.                     #
  
          BEGIN 
  
          ITEM  ORSA                  I;
          ITEM  IRRL                  I;
          ITEM  LR                    I;
          ITEM  BUFREC                B;
  
*CALL A 
  
*CALL SPEC$ 
*CALL MACHINE 
*CALL KT$ 
  
          XREF
              BEGIN 
  
              PROC  S$GNSMA;             # INITIALIZATION              #
              PROC  S$GNSMB;             # SETUP FOR BUFFER ACCESS     #
              PROC  S$GNSMC;             # SETUP FOR RSA ACCESS        #
              PROC  S$GNSMF;             # SETUP FOR EACH FIELD        #
              PROC  S$GNSMH;             # OBTAIN TRN SUB(FIELD)       #
              PROC  S$GNSMI;             # OBTAIN RSA/BUFFER (SUB)FIELD#
              PROC  S$GNSMK;             # PERFORM SUMMING + OVERFLOW  #
              PROC  S$GNSMM;             # SAVE (SUB)FIELD TO TRN      #
              PROC  S$GNSMN;             # SAVE (SUB)FIELD TO RSA/BUF. #
              PROC  S$GNSMO;
              PROC  S$GNSMP;
              PROC  S$GNSM9;             # FINISH                      #
  
              END 
  
          ITEM  SK                    I; # INDEX TO SPEC$SUM ENTRY     #
          ITEM  FULLWORD              I; # FULL WORD SIZE IN BITS      #
          ITEM  WORDOFFSET            I; # RSA/BUFFER OFFSET FOR FIELD #
                                         # -1  FIELD STARTS IN TRN     #
                                         #  0   IN RSA/BUFFER WORD 1   #
                                         # +N   IN RSA/BUFFER WORD N+1 #
          ITEM  BITOFFSET             I; # BIT OFFSET WITHIN WORD      #
          ITEM  NBITS                 I; # LENGTH OF (SUB)FIELD        #
          ITEM REP    I;               #  LOCAL VARIABLE FOR REP LOOP  #
          ITEM TEMPSUMOFF  I;          # CALCULATE OFFSET FOR REPEATED #
                                       # SUM FIELDS                    #
          ITEM  SUMNO        I;        # SUM  NO OF OVERFLOW FIELD     #
          ITEM  SMBCCALLED   B;        # TRUE IF GNSMB OR GNSMC CALLED #
          ITEM  REMAIN       I;        # NO OF REMAINING BITS IN NEXT  #
                                       #   WORD OF SUM FIELD           #
          ITEM  C10          C(10);    # STRING OF 10 CHAR.            #
          ITEM  OVFIELD      C(40);    # STRING CONTAIN OVERFLOW FIELD #
          ITEM  JJ I; 
          ITEM  MAX I;
          ITEM  MIN I;
          ITEM  NUMCHARS I; 
  
          FUNC  DEC(VALUE) C(10); 
              ITEM  VALUE       I;     # VALUE TO BE CONVERTED         #
              ITEM  C10PLUS     C(20);
              ITEM  I            I; 
              ITEM  N            I; 
              BEGIN 
              C10PLUS = "         0          "; 
              N = VALUE;
              IF N LS 0  THEN 
                  N = -N; 
              IF N GR 999999999 THEN
                  BEGIN 
                  C10PLUS = " *********          "; 
                  I = 0;
                  END 
              ELSE
                  BEGIN 
                  FOR I = 9 WHILE N NQ 0  DO
                      BEGIN 
                      C<I,1>C10PLUS = N - (N/10)*10 + 27; 
                      N = N/10; 
                      I = I - 1;
                      END 
                  END 
              IF VALUE LS 0 THEN
                  C<I,1>C10PLUS = "-";
              DEC = C<I,10>C10PLUS; 
              END  # DEC #
  
  
          CONTROL DISJOINT; 
          CONTROL INERT;
          CONTROL EJECT;
  
          FULLWORD = BYTE*WORD; 
  
#         INITIALIZE SUMMING CODE                                      #
  
          S$GNSMA(BUFREC);
  
          SUMNO = 0;    # INITIALIZE SUM FIELD NO BEFORE LOOP # 
  
#         LOOP THROUGH SUM FIELDS                                      #
  
          FOR SK = SPEC$1STSUM WHILE SK NQ 0 DO 
              BEGIN 
  
              SUMNO = SUMNO + 1;    # SUM FIELD NO #
              SMBCCALLED = FALSE;        # RESET FOR THIS SUM FIELD # 
  
#         HANDLE THE FAMOUS REPETITION FACTOR FOR SUM FIELDS           #
#         WITH AN INNER LOOP HERE                                      #
  
              FOR REP = 1 STEP 1 UNTIL SPEC$SUMREP[SK] DO 
                  BEGIN 
#             OBTAIN UPPER (SUB)FIELD PART OF FIELD                    #
  
                  TEMPSUMOFF = SPEC$SUMOFF[SK] +
                      (SPEC$SMLENI[SK] * ( REP - 1 ));
                  WORDOFFSET = TEMPSUMOFF / FULLWORD; 
                  BITOFFSET = TEMPSUMOFF - FULLWORD * WORDOFFSET; 
                  WORDOFFSET = WORDOFFSET-1;
                  NBITS = FULLWORD-BITOFFSET; 
                  IF SPEC$SMLENI[SK] LS NBITS THEN
                      NBITS = SPEC$SMLENI[SK];
  
                  REMAIN = SPEC$SMLENI[SK] - NBITS; 
                  IF WORDOFFSET LS 0 THEN 
                      S$GNSMH(BITOFFSET, NBITS);
                  ELSE
                      BEGIN 
                      IF NOT SMBCCALLED THEN
                          BEGIN 
                          SMBCCALLED = TRUE;
                          IF BUFREC THEN
                              S$GNSMB(LR);
                          ELSE
                              S$GNSMC(ORSA, IRRL, LR);
                          END 
  
  
                      S$GNSMF;  # ZERO X3,X5 FOR THIS FIELD            #
  
                      S$GNSMI(BITOFFSET,NBITS,WORDOFFSET,BUFREC); 
                      END 
  
#             OBTAIN LOWER PART OF FIELD, IF NECESSARY                 #
  
                  IF REMAIN GR 0 THEN 
                      BEGIN 
                      IF NOT SMBCCALLED THEN
                          BEGIN 
                          SMBCCALLED = TRUE;
                          IF BUFREC THEN
                              S$GNSMB(LR);
                          ELSE
                              S$GNSMC(ORSA, IRRL, LR);
                          END 
  
                      S$GNSMI(0, REMAIN, WORDOFFSET+1, BUFREC); 
                      END 
  
#             SUM AND HANDLE OVERFLOW                                  #
  
                  OVFIELD = "*** OVERFLOW ON SUMFIELD       REP      "; 
                  C10 = DEC(SUMNO); 
                  C<25,5>OVFIELD = C<0,5>C10; 
                  C10 = DEC(REP); 
                  C<35,5>OVFIELD = C<0,5>C10; 
                  B<228,12>OVFIELD = 0; 
  
  
  
                  IF SPEC$SUMTYPE[SK] EQ KT$T"LOGICAL" THEN  # BINARY # 
                      S$GNSMK(SPEC$SMLENI[SK],FALSE,OVFIELD,0); 
                      # FALSE MEANS UNSIGNED NUMBERS  # 
                      # FINAL ZERO MEANS NO EXTRA RANGE CHECKING #
                  ELSE IF SPEC$SUMTYPE[SK] EQ KT$T"INTEGER" THEN
                      S$GNSMK(SPEC$SMLENI[SK],TRUE,OVFIELD,0);
                      # TRUE MEANS SIGNED NUMBERS  #
                      # FINAL ZERO MEANS NO EXTRA RANGE CHECKING #
                  ELSE    #  WE HAVE DISPLAY NUMERIC SUM FIELDS # 
                      # EXTRA CHECKING WILL BE NEEDED FOR OVERFLOW #
                      BEGIN 
                      NUMCHARS = SPEC$SMLENE[SK]/BYTE;
                      IF SPEC$SUMTYPE[SK] EQ KT$T"NUMERICLS"
                                         OR 
                         SPEC$SUMTYPE[SK] EQ KT$T"NUMERICTS" THEN 
                             NUMCHARS = NUMCHARS - 1; 
                      MAX = 0;
                      FOR JJ = 1 STEP 1 UNTIL NUMCHARS DO 
                          BEGIN 
                          MAX = MAX*10; 
                          MAX = MAX + 9;
                          END 
                      MIN = -MAX; 
                      IF SPEC$SUMTYPE[SK] EQ KT$T"NUMERICNS" THEN 
                          MIN = 0;  # NEGATIVE NUMBERS ILLEGAL HERE # 
                      S$GNSMK(SPEC$SMLENI[SK],TRUE,OVFIELD,1,MAX,MIN);
                      END 
  
#             SAVE RESULT UPPER (SUB)FIELD PART OF FIELD               #
  
                  IF WORDOFFSET LS 0 THEN 
                      BEGIN 
                      S$GNSMM(BITOFFSET, NBITS, REMAIN);
                      IF REMAIN GR 0 THEN 
                          S$GNSMP(0, REMAIN, WORDOFFSET+1, BUFREC); 
                      END 
                  ELSE
                      BEGIN 
                      IF REMAIN LQ 0 THEN 
                          S$GNSMN(BITOFFSET, NBITS, WORDOFFSET, BUFREC);
                      ELSE
                          BEGIN 
                          S$GNSMO(BITOFFSET, NBITS, WORDOFFSET, 
                                         REMAIN, BUFREC); 
                          S$GNSMP(0, REMAIN, WORDOFFSET+1, BUFREC); 
                          END 
                      END 
  
                  END # OF REPETITION FACTOR LOOP                      #
  
                  SK = SPEC$NEXTSUM[SK];
  
              END # SUM FIELD LOOP #
  
#         FINISH                                                       #
  
          S$GNSM9;
  
          END 
          TERM
