*COMDECK     COMLIT     - LITERAL GENERATING ROUTINES.
#*        LIT  -  LITERAL GENERATING ROUTINES.
* 
*         R. H. GOODELL.     76/11/01.
* 
*         *LIT* CONTAINS SUBROUTINES USED IN THE FIRST PASS OF THE
*         DDL CODE GENERATOR, TO CONVERT CONSTANTS INTO SOURCE AND
*         BINARY FORMATS SUITABLE FOR ENTRY INTO THE LITERALS TABLE.
*         EACH *LIT* ROUTINE IS A FUNCTION WHOSE RETURN VALUE, WHEN 
*         COMPLEMENTED, CAN BE USED AS THE ARGUMENT TO *LDN* IN 
*         *PASS1* WHICH FINDS OR ENTERS IT IN THE LITERALS TABLE. 
* 
*         CONTENTS (XDEF ENTRY POINTS). 
* 
*         FUNC   LIT         GENERATE LITERAL DESCRIPTOR (USED
*                               BY ALL BELOW).
*         FUNC   LITCH       CHARACTER STRING (H).
*         FUNC   LITCL       ITEM DATA CLASS CODE.
*         FUNC   LITCPLX     COMPLEX FLOATING POINT NUMBER PAIR.
*         FUNC   LITCR       CHARACTER STRING (R).
*         FUNC   LITCZ       CHARACTER STRING (L).
*         FUNC   LITDP       DOUBLE PRECISION NUMBER. 
*         FUNC   LITEC       DBP ENTRY CODE.
*         FUNC   LITFP       FLOATING POINT NUMBER. 
*         FUNC   LITINT      INTEGER NUMBER (DECIMAL).
*         FUNC   LITOCT      OCTAL WORD.
*         FUNC   LITSI       SHORT INTEGER NUMBER (1-10 DECIMAL DIGITS).
# 
  
  
*CALL     COMDDEF            GENERAL DEFINITIONS. 
  
     XREF BEGIN               # EXTERNALS # 
  
          ITEM E$LITCR ;           # ERROR - LITCR ARGUMENT TOO LONG #
          ITEM E$LITCZ ;           # ERROR - LITCZ ARGUMENT TOO LONG #
          PROC CFG ;               # CONVERT FLOATING TO *G* FORMAT # 
          PROC PUNT ;              # PROCESS INTERNAL ERROR # 
          PROC XCDDL ;             # CONVERT TO DECIMAL LEFT JUSTIFIED #
  
          END 
  
  
*CALL     COMDCHAR           DISPLAY CODE CHARACTERS. 
  
  
*CALL     COMDDBPE           DATA BASE PROCEDURE ENTRY CODES. 
  
  
*CALL     COMDITEM           ITEM CLASS AND TYPE CODES. 
  
  
#         LOCAL DATA. 
# 
          ITEM A C (240) ;         # ASSEMBLY BUFFER #
          ITEM B C (20) ;          # WORK BUFFER #
          ITEM C I ;               # CHARACTER COUNT #
          ITEM D I ;               # DIGIT COUNT #
          ITEM L I ;               # LENGTH # 
          ITEM W U ;               # WORD INDEX # 
  
  
  
  
#***      LIT  -  GENERATE LITERAL DESCRIPTOR.
  
          FUNC LIT (SL, STR, VL, VAL) I 
# 
          ITEM SL I ;              # STRING LENGTH IN CHARACTERS #
          ARRAY STR [1:26] ;       # LITERAL STRING OF WORDS #
               ITEM SW U ;              # AS IF ITEM STR C (SL) # 
          ITEM VL I ;              # VALUE LENGTH IN WORDS #
          ARRAY VAL [1:26] ;       # VALUE ARRAY OF WORDS # 
               ITEM VW U ;              # AS IF ARRAY VAL [1:VL] #
  
#         FUNCTION VALUE IS LOC OF LITERAL DESCRIPTOR.
****
# 
          BEGIN 
  
          ARRAY LITD [0:52] ;      # LITERAL DESCRIPTOR # 
               BEGIN
               ITEM DL I (0, 0, 6) ;    # LENGTH OF VALUE IN TCON # 
               ITEM DA I (0, 6,18) ;    # INDEX OF VALUE IN LITD #
               ITEM DC I (0,24,18) ;    # CHAR LENGTH OF LITERAL #
               ITEM DN I (0,42,18) ;    # LENGTH OF THIS LITD ENTRY # 
               ITEM DW U ;              # LITERAL WORD #
               END
          ITEM I, T ;              # TEMPORARIES #
  
          T = (SL + WC - 1) / WC ;           # STRING LENGTH IN WORDS # 
          DL [0] = VL ;                      # VALUE LENGTH # 
          DA [0] = T + 1 ;                   # INDEX OF VALUE # 
          DC [0] = SL ;                      # LITERAL LENGTH IN CHARS #
          DN [0] = T + 1 ;                   # TLIT ENTRY LENGTH #
          FOR  I = 1 THRU T  DO 
               DW [I] = SW [I] ;             # MOVE LITERAL WORDS # 
          I = T * WC - SL ; 
          IF  I NE 0                         # SPACE FILL LAST WORD # 
          THEN C<WC-I,I> DW [T] = " " ; 
          FOR  I = 1 THRU VL  DO             # MOVE VALUE WORDS # 
               DW [T+I] = VW [I] ;
          LIT = LOC (LITD) ;                 # FUNCTION VALUE # 
          RETURN ;
  
  
  
  
#***      LITCH - GENERATE LITERAL DESCRIPTOR FOR A CHARACTER STRING. 
# 
          XDEF FUNC LITCH ; 
          FUNC LITCH ((L), V) I ; 
  
          ITEM L I ;               # STRING LENGTH IN CHARACTERS #
          ITEM V C (240) ;         # CHARACTER STRING VALUE # 
  
#         LITCH CREATES A LITERAL OF THE FORM  =(L)H(V)  AND
*         RETURNS, AS FUNCTION VALUE, LOC OF LITERAL DESCRIPTOR.
****
# 
          BEGIN 
  
          CALL XCDDL (L, A, C) ;             # CONVERT L TO DECIMAL # 
          C = C / CL ;                       # L LENGTH IN CHARACTERS # 
          W = (L + WC - 1) / WC ;            # VALUE LENGTH IN WORDS #
          C<C> A = "H" ;                     # INSERT *H* AFTER L # 
          C<C+1,L> A = C<0,L> V ;            # MOVE VALUE TO STRING # 
          LITCH = LIT (C+1+L, A, W, V) ;     # MAKE LITERAL DESCRIPTOR #
          RETURN ;
  
          END 
  
  
  
  
#***      LITCL - GENERATE LITERAL DESCRIPTOR FOR ITEM DATA CLASS CODE. 
# 
          XDEF FUNC LITCL ; 
          FUNC LITCL (C) I ;
  
          ITEM C S:CLASS ;         # CLASS CODE VALUE # 
  
#         LITCL CREATES A LITERAL OF THE FORM  =CL"MNEMONIC"  AND 
*         RETURNS, AS FUNCTION VALUE, LOC OF LITERAL DESCRIPTOR.
*         THE LITERAL VALUE IS A DATA ITEM CLASS CODE FOR USE IN
*         RUN-TIME PROCEDURE ARGUMENTS.  IT IS ACTUALLY A SMALL 
*         INTEGER VALUE BUT IS TREATED AS A SPECIAL LITERAL TYPE
*         TO IMPROVE OBJECT CODE READABILITY.  THE MNEMONICS AND
*         VALUES ARE DEFINED IN COMMON DECK *COMDITEM*. 
****
# 
          BEGIN 
  
          ARRAY [CLASS"ALPHANUMERIC" : CLASS"LOGICAL"] S (2) ;
               ITEM CLSYM C (0, 0, 16)  = 
                  [ "CL""ALPHANUMERIC"""     #    0    ALPHANUMERIC    #
                  , "CL""ALPHABETIC""  "     #    1    ALPHABETIC      #
                  , "CL""DATABASEKEY"" "     #    2                    #
                  , "CL""DCNUMERIC""   "     #    3    NUMERIC, SOVP   #
                  , "CL""DCFIXED""     "     #    4    NUMERIC, DEC PT #
                  , "CL""DCFLOAT""     "     #    5    NUMERIC, EXPONT #
                  , "CL""DCDOUBLE""    "     #    6    DISPLAY DOUBLE  #
                  , "CL""DCCOMPLEX""   "     #    7    DISPLAY COMPLEX #
                  , "CL""DCLOGICAL""   "     #    8    DISPLAY LOGICAL #
                  , "CL""BITSTRING""   "     #    9    BIT STRING      #
                  , "CL""INTEGER""     "     #   10    BINARY INTEGER  #
                  , "CL""FIXED""       "     #   11    PACKED INTEGER  #
                  , "CL""FLOATUNNORM"" "     #   12    PACKED INTEGER  #
                  , "CL""FLOATNORM""   "     #   13    FLOATING POINT  #
                  , "CL""DOUBLE""      "     #   14    F.P. DOUBLE PRE #
                  , "CL""COMPLEX""     "     #   15    F.P. COMPLEX    #
                  , "CL""LOGICAL""     "     #   16    LOGICAL (0 / 1) #
                  , "CL""FTNLOGICAL""  "     #   17    FTN LOGICAL,WORD#
                  , "CL""FTNBOOLEAN""  "     #   18    FTN BOOLEAN,WORD#
                  ] ; 
  
          LITCL = LIT (16, CLSYM [C], 1, C) ; 
          RETURN ;
  
          END 
  
  
  
  
#***      LITCPLX - GENERATE LITERAL DESCRIPTOR FOR COMPLEX NUMBER PAIR.
# 
          XDEF FUNC LITCPLX ; 
          FUNC LITCPLX (V) I ;
  
          ARRAY V [0:1] ;          # COMPLEX VALUE #
               ITEM W R (0,0,WL) ;      # EACH WORD # 
  
#         THE COMPLEX VALUE IS CONVERTED TO A DISPLAY FORMAT OF 
*         THE FORM   (W0,W1)   WHERE W0 AND W1 ARE THE REAL AND 
*         IMAGINARY PARTS, RESPECTIVELY, EACH IN A FORMAT THAT
*         RESEMBLES A FORTRAN *G20.12* SPECIFICATION.  FUNCTION 
*         VALUE IS LOC OF LITERAL DESCRIPTOR. 
****
# 
          BEGIN 
  
          CALL CFG (W [0], 1, D, B) ;        # CONVERT REAL PART #
          C<0> A = "(" ;
          C<1,D> A = B ;                     # MOVE TO ASSEMBLY BUFFER #
          C<D+1> A = "," ;
          C = D + 2 ; 
          CALL CFG (W [1], 1, D, B) ;        # CONVERT IMAGINARY PART # 
          C<C,D> A = B ;
          C = C + D + 1 ;                    # MOVE TO ASSEMBLY BUFFER #
          C<C-1> A = ")" ;
          D = ((C + WC - 1) / WC) * WC - C ;
          IF  D NE 0                         # SPACE FILL LAST WORD # 
          THEN C<C,D> A = " " ; 
          LITCPLX = LIT (C, A, 2, V) ;       # MAKE LITERAL DESCRIPTOR #
          RETURN ;
  
          END 
  
  
  
  
#***      LITCR - GENERATE LITERAL DESCRIPTOR FOR *R* CHARACTER STRING. 
# 
          XDEF FUNC LITCR ; 
          FUNC LITCR ((L), V) I ; 
  
          ITEM L I ;               # STRING LENGTH IN CHARACTERS #
          ITEM V C (WC) ;          # CHARACTER STRING VALUE # 
  
#         LITCR CREATES A LITERAL OF THE FORM   =(L)R(V)   AND
*         RETURNS, AS FUNCTION VALUE, LOC OF LITERAL DESCRIPTOR.
*         (L) MUST NOT EXCEED 10. 
****
# 
          BEGIN 
  
          IF  L GT WC                        # IF MORE THAN 1 WORD #
          THEN PUNT (E$LITCR) ; 
          CALL XCDDL (L, A, C) ;             # CONVERT L TO DECIMAL # 
          C = C / CL ;                       # L LENGTH IN CHARACTERS # 
          C<C> A = "R" ;                     # INSERT *R* AFTER L # 
          C<C+1,L> A = C<0,L> V ;            # MOVE VALUE TO STRING # 
          W = 0 ;                            # STORE VALUE IN W, RIGHT #
          C<WC-L,L> W = C<0,L> V ;            # JUSTIFIED WITH 00 FILL #
          LITCR = LIT (C+1+L, A, 1, W) ;     # MAKE LITERAL DESCRIPTOR #
          RETURN ;
  
          END 
  
  
  
  
#***      LITCZ - GENERATE LITERAL DESCRIPTOR FOR *L* CHARACTER STRING. 
# 
          XDEF FUNC LITCZ ; 
          FUNC LITCZ ((L), V) I ; 
  
          ITEM L I ;               # STRING LENGTH IN CHARACTERS #
          ITEM V C (WC) ;          # CHARACTER STRING VALUE # 
  
#         LITCZ CREATES A LITERAL OF THE FORM   =(L)L(V)   AND
*         RETURNS, AS FUNCTION VALUE, LOC OF LITERAL DESCRIPTOR.
*         (L) MUST NOT EXCEED 10. 
****
# 
          BEGIN 
  
          IF  L GT WC                        # IF MORE THAN 1 WORD #
          THEN PUNT (E$LITCZ) ; 
          CALL XCDDL (L, A, C) ;             # CONVERT L TO DECIMAL # 
          C = C / CL ;                       # L LENGTH IN CHARACTERS # 
          C<C> A = "L" ;                     # INSERT *L* AFTER L # 
          C<C+1,L> A = C<0,L> V ;            # MOVE VALUE TO STRING # 
          W = 0 ;                            # STORE VALUE IN W, LEFT  #
          C<0,L> W = C<0,L> V ;               # JUSTIFIED WITH 00 FILL #
          LITCZ = LIT (C+1+L, A, 1, W) ;     # MAKE LITERAL DESCRIPTOR #
          RETURN ;
  
          END 
  
  
  
  
#***      LITDP - GENERATE LITERAL DESCRIPTOR FOR DOUBLE PRECISION. 
# 
          XDEF FUNC LITDP ; 
          FUNC LITDP (D) I ;
  
          ARRAY D [0:1] ;          # DOUBLE PRECISION VALUE # 
               ITEM E R (0,0,WL) ;      # EACH WORD # 
  
#         THE DOUBLE PRECISION VALUE IS CONVERTED TO A DISPLAY
*         FORMAT RESEMBLING A FORTRAN *G20.12* SPECIFICATION. 
*         FUNCTION VALUE IS LOC OF LITERAL DESCRIPTOR.
****
# 
          BEGIN 
  
          CALL CFG (E [0], 2, L, A) ;        # CONVERT FLOATING TO *G* #
          LITDP = LIT (L, A, 2, D) ;         # MAKE LITERAL DESCRIPTOR #
          RETURN ;
  
          END 
  
  
  
  
#***      LITEC - GENERATE LITERAL DESCRIPTOR FOR DBP ENTRY CODE. 
# 
          XDEF FUNC LITEC ; 
          FUNC LITEC ((EC)) I ; 
  
          ITEM EC S:DBPENT ;       # ENTRY CODE VALUE # 
  
#         LITEC CREATES A LITERAL OF THE FORM  =EC"MNEMONIC"  AND 
*         RETURNS, AS FUNCTION VALUE, LOC OF LITERAL DESCRIPTOR.
*         THE LITERAL VALUE IS A DATA BASE PROCEDURE ENTRY CODE 
*         FOR USE IN RUN-TIME DBP ARGUMENTS.  IT IS ACTUALLY A
*         SMALL INTEGER VALUE, BUT IS TREATED AS A SPECIAL LITERAL
*         TYPE TO IMPROVE OBJECT CODE READABILITY.  THE MNEMONICS 
*         AND VALUES ARE DEFINED IN COMMON DECK *COMDDBPE*. 
****
# 
          BEGIN 
  
          ARRAY [DBPENT"BIGET" : DBPENT"CHECK"] ; 
               ITEM ECSYM C (0, 0, 10)  = 
                  [ "EC""BIGET"" "     #    22    BEFORE ITEM GET      #
                  , "EC""EIGET"" "     #    23    ERROR  ITEM GET      #
                  , "EC""AIGET"" "     #    24    AFTER  ITEM GET      #
                  , "EC""BISTO"" "     #    25    BEFORE ITEM STORE    #
                  , "EC""EISTO"" "     #    26    ERROR  ITEM STORE    #
                  , "EC""AISTO"" "     #    27    AFTER  ITEM STORE    #
                  , "EC""BIMOD"" "     #    28    BEFORE ITEM MODIFY   #
                  , "EC""EIMOD"" "     #    29    ERROR  ITEM MODIFY   #
                  , "EC""AIMOD"" "     #    30    AFTER  ITEM MODIFY   #
                  , "EC""ENCODE"""     #    31    ENCODE               #
                  , "EC""DECODE"""     #    32    DECODE               #
                  , "EC""ACTUAL"""     #    33    ACTUAL  RESULT       #
                  , "EC""VIRTUL"""     #    34    VIRTUAL RESULT       #
                  , "EC""CHECK"" "     #    35    CHECK                #
                  ] ; 
  
          LITEC = LIT (10, ECSYM [EC], 1, EC) ; 
          RETURN ;
  
          END 
  
  
  
  
#***      LITFP - GENERATE LITERAL DESCRIPTOR FOR FLOATING POINT. 
# 
          XDEF FUNC LITFP ; 
          FUNC LITFP ((I)) I ;
  
          ITEM I R ;               # REAL VALUE # 
  
#         THE REAL VALUE IS CONVERTED TO A DISPLAY FORMAT 
*         RESEMBLING A FORTRAN *G20.12* SPECIFICATION.
*         FUNCTION VALUE IS LOC OF LITERAL DESCRIPTOR.
****
# 
          BEGIN 
  
          CALL CFG (I, 1, L, A) ;            # CONVERT FLOATING TO *G* #
          LITFP = LIT (L, A, 1, I) ;         # MAKE LITERAL DESCRIPTOR #
          RETURN ;
  
          END 
  
  
  
  
#***      LITINT - GENERATE LITERAL DESCRIPTOR FOR INTEGER NUMBER.
# 
          XDEF FUNC LITINT ;
          FUNC LITINT (I) I ; 
  
          ITEM I I ;               # INTEGER VALUE #
  
#         THE INTEGER VALUE IS CONVERTED TO A DISPLAY FORMAT
*         RESEMBLING AN *I20* SPECIFICATION IN FORTRAN. 
*         FUNCTION VALUE IS LOC OF LITERAL DESCRIPTOR.
****
# 
          BEGIN 
  
          ARRAY AB [0:1] ;         # ASSEMBLY BUFFER #
               ITEM AW C (0, 0, WC) ;   # ASSEMBLY WORD # 
  
          ARRAY  [13:17] ;         # LARGE POWERS OF TEN #
               ITEM TENS I = [    10000000000000,      # 10**13 # 
                                 100000000000000,      # 10**14 # 
                                1000000000000000,      # 10**15 # 
                               10000000000000000,      # 10**16 # 
                              100000000000000000 ] ;   # 10**17 # 
  
          ITEM N ;                 # ABS (I) #
          ITEM T ;                 # TEMPORARY #
  
          W = 0 ;                       # RESET ASSEMBLY WORDS #
          C = 0 ;                        # AND POINTERS # 
          AW [0] = " " ;
          AW [1] = " " ;
          N = ABS (I) ; 
          IF  I LT 0                    # IF NEGATIVE # 
          THEN BEGIN
               AW [0] = "-" ;                # INSERT MINUS SIGN #
               C = 1 ;
               END
          IF  N LT 10000000000          # IF SHORT INTEGER < 10**WC # 
          THEN BEGIN
               CALL XCDDL (N, W, D) ;        # CONVERT TO DECIMAL # 
               D = D / CL ;                  # DIGIT COUNT #
               T = WC - C ; 
               IF  T GT D                    # MOVE CHARACTERS TO 1ST # 
               THEN T = D ;                   # WORD OF ASSEMBLY AREA # 
               C<C,T> AW [0] = C<0,T> W ; 
               C = C + D ;
               D = D - T ;                   # MOVE CHARACTERS TO 2ND # 
               IF  D GT 0                     # WORD OF ASSEMBLY AREA # 
               THEN C<0,D> AW [1] = C<T,D> W ;
               LITINT = LIT (C, AB, 1, I) ;  # MAKE LITERAL DESCRIPTOR #
               RETURN ; 
               END
          IF  N GE TENS [14]            # IF TOO LARGE FOR DIVISION # 
          THEN BEGIN
               FOR  T = 17 STEP -1           # FIND LARGEST POWER OF #
                    WHILE  TENS [T] GT N      # TEN THAT IS .LE. N  # 
                    DO  BEGIN  END
               FOR  T = T STEP -1 UNTIL 14  DO         # CONVERT THESE #
                    BEGIN                              # DIGITS VIA    #
                    FOR  D = CHARACTER"ZERO" STEP 1    # ITERATIVE     #
                         WHILE  N GE TENS [T]  DO      # SUBTRACTION   #
                         N = N - TENS [T] ;            # RATHER THAN   #
                    C<C> AW [0] = D ;                  # DIVISION      #
                    C = C + 1 ; 
                    END 
               T = TENS [13] ;               # SET NEXT POWER OF TEN #
               END
          ELSE BEGIN
               FOR  T = TENS [13]       # SKIP LEADING ZEROS #
                    WHILE  T GT N  DO 
                    T = T / 10 ;
               END
          FOR  T = T                    # CONVERT REMAINING DIGITS BY # 
               WHILE  T NE 0  DO         # DIVISION, LEFT TO RIGHT #
               BEGIN
               D = N / T ;                             # GET DIGIT #
               N = N - D * T ;
               C<C> AW [W] = D + CHARACTER"ZERO" ;     # STORE DIGIT #
               T = T / 10 ; 
               C = C + 1 ;                             # ADVANCE #
               IF  C EQ WC
               THEN BEGIN                              # NEXT WORD #
                    C = 0 ;                            # OF DIGITS #
                    W = W + 1 ; 
               END  END 
          LITINT = LIT (W*WC+C, AB, 1, I) ;  # MAKE LITERAL DESCRIPTOR #
          RETURN ;
  
          END 
  
  
  
  
#***      LITOCT - GENERATE LITERAL DESCRIPTOR FOR OCTAL WORD.
# 
          XDEF FUNC LITOCT ;
          FUNC LITOCT ((W)) I ; 
  
          ITEM W U ;               # BINARY WORD VALUE #
  
#         LITOCT CREATES A LITERAL OF THE FORM   =NN...NNB   AND
*         RETURNS, AS FUNCTION VALUE, LOC OF LITERAL DESCRIPTOR.
****
# 
          BEGIN 
  
          L = W ; 
          C = 0 ; 
          IF  B<0,2> W EQ 3                  # IF 1ST DIGIT IS 6 OR 7 # 
          THEN BEGIN
               L = - W ;                     # COMPLEMENT WORD #
               C<0> A = "-" ;                # SET MINUS SIGN PREFIX #
               C = 1 ;
               END
          C<19> B = B<WL-3,3> L + CHARACTER"ZERO" ; 
          L = B<0,WL-3> L ; 
          FOR  D = 18 STEP -1 
               WHILE  L NE 0  DO             # CONVERT DIGITS # 
               BEGIN
               C<D> B = B<WL-3,3> L + CHARACTER"ZERO" ; 
               L = B<0,WL-3> L ;
               END
          C<C,19-D> A = C<D+1,19-D> B ;      # MOVE DIGITS #
          C = C + 19 - D ;
          IF  D NE 18 
          THEN BEGIN                         # IF MORE THAN ONE DIGIT # 
               C<C> A = "B" ;                 # APPEND POSTRADIX *B* #
               C = C + 1 ;
               END
          LITOCT = LIT (C, A, 1, W) ;        # MAKE LITERAL DESCRIPTOR #
          RETURN ;
  
          END 
  
  
  
  
#***      LITSI - GENERATE LITERAL DESCRIPTOR FOR SHORT INTEGER.
# 
          XDEF FUNC LITSI ; 
          FUNC LITSI ((N)) I ;
  
          ITEM N U ;               # UNSIGNED INTEGER VALUE < 10**WC #
  
#         LITSI CREATES A LITERAL OF THE FORM   =(N)   (DECIMAL 
*         INTEGER) AND RETURNS, AS FUNCTION VALUE, LOC OF LITERAL 
*         DESCRIPTOR.  (N) MUST BE A NON-NEGATIVE INTEGER LESS
*         THAN 10**10.  FOR INTEGERS OUTSIDE THIS RANGE, USE
*         LITINT INSTEAD. 
****
# 
          BEGIN 
  
          CALL XCDDL (N, A, L) ;             # CONVERT TO DECIMAL # 
          LITSI = LIT (L/CL, A, 1, N) ;      # MAKE LITERAL DESCRIPTOR #
          RETURN ;
  
          END 
  
     END  TERM
