*DECK DB$UPRT                                                            UPRT 
      PROC DB$UPRT (STRING,LENGTH);                                      UPRT 
 #                                                                       UPRT 
  *   DB$UPRT - PRINT A STRING ROUTINE           PAGE  1                 UPRT 
  *   ALTERNATE ENTRY POINT DB$EPRT                                      JJJ1223
  *   J. JAN JANIK                               DATE  10/16/75          UPRT 
                                                                         UPRT 
  DC  PURPOSE                                                            UPRT 
                                                                         UPRT 
      THIS ROUTINE OUTPUTS A STRING TO THE OUTPUT FILE, KEEPING TRACK OF UPRT 
      THE NUMBER OF LINES ON THE PAGE.                                   UPRT 
                                                                         UPRT 
  DC  ENTRY CONDITIONS                                                   UPRT 
                                                                         UPRT 
      STRING = THE NAME OF THE STRING TO BE PRINTED, 1ST CHAR IS         UPRT 
               CARRIAGE CONTROL CHARACTER.                               UPRT 
      LENGTH - LENGTH OF STRING IN CHARACTERS                            UPRT 
      OUTPUT FILE MUST HAVE BEEN OPENED PRIOR TO CALLING DB$UPRT         UPRT 
      DB$LNLF = NUMBER OF LINES LEFT ON THE PAGE                         UPRT 
                                                                         UPRT 
  DC  EXIT CONDITIONS                                                    UPRT 
                                                                         UPRT 
      STRING IS PUT ON THE OUTPUT FILE, DB$LNLF REFLECTS THE NEW LINE    UPRT 
      COUNT, AND A NEW PAGE HAS BEEN STARTED IF NECESSARY.               UPRT 
                                                                         UPRT 
  DC  CALLING ROUTINES                                                   UPRT 
                                                                         UPRT 
      CTLSTD - SYNTAX TABLE DRIVER, CALLS ALTERNATE ENTRY POINT DDLPRNT  UPRT 
      DBMSTRD - MAIN ROUTINE FOR MASTER DIRECTORY BUILD UTILITY          UPRT 
      DB$MABT - ABORT MODULE FOR DBMSTRD.                                UPRT 
      DB$RUPD - CALLS FOR RECOVERY MESSAGES IN DBRCN/DBRST
                                                                         UPRT 
  DC  CALLED ROUTINES                                                    UPRT 
                                                                         JJJ1223
      DB$UPHD - CALLED TO PRINT THE HEADER, BUMP PAGE NUM, AND SET       UPRT 
                DB$LNLF TO 58                                            UPRT 
      DB$UPTL - CALLED TO PRINT THE LINE.                                UPRT 
                                                                         UPRT 
  DC  NON-LOCAL VARIABLE                                                 UPRT 
                                                                         UPRT 
      DB$LNLF - CONTAINS LINES LEFT ON THE PAGE                          UPRT 
      DB$MOUT - LFN OF OUTPUT FILE. IF EQUAL TO 0, SUPPRESS LIST.        JJJ1107
                                                                         UPRT 
  DC  DESCRIPTION                                                        UPRT 
                                                                         UPRT 
      DB$MOUT IS CHECKED AND IF ZERO NO PRINTING IS DONE.  ENTRY POINT   JJJ1107
      DB$EPRT DOES NOT CHECK DB$MOUT AND IS USED TO FORCE ERRORS TO BE   JJJ1107
      PRINTED ON THE FILE OUTPUT.                                        JJJ1107
                                                                         JJJ1107
      THE LENGTH OF THE STRING IS CHECKED AND IF LONGER THAN 137 CHARS,  UPRT 
      IS TRUNCATED TO 137 WITHOUT A DIAGNOSTIC.  THE 1ST CHAR IS THEN    UPRT 
      CHECKED TO DETERMINE HOW MANY LINES ARE NEEDED TO HANDLE THE SPAC- UPRT 
      ING REQUESTED.  DB$UPRT WILL HANDLE THE FOLLOWING CARRIAGE CONTROL UPRT 
      CHARACTERS AND ADJUST DB$LNLF ACCORDINGLY.                         UPRT 
                  " " - SINGLE SPACE                                     UPRT 
                  "1" - NEW PAGE, PRINT HEADER, BLANK LINE AND STRING    UPRT 
                        ON THIRD LINE OF PAGE                            UPRT 
                  "0" - DOUBLE SPACE                                     UPRT 
                  "-" - TRIPLE SPACE                                     UPRT 
      ANY OTHER CHARACTER IS CHANGED TO A BLANK WITHOUT ISSUEING A MSG.  UPRT 
      IF ANY STRING"S SPACING WOULD NOT FIT ON A LINE, A PAGE EJECT IS   UPRT 
      ISSUED BY CALLING DB$UPHD, AND THE 1ST CHAR OF THE STRING IS       UPRT 
      CHANGED TO A " " PRIOR TO PRINTING THE LINE. THE STRING IS PRINTED UPRT 
      BY CALLING DB$UPTL AND ON RETURN, DB$LNLF IS CHECKED.  IF IT IS 0, UPRT 
      DB$UPHD IS CALLED.  THIS PREPARES THE PAGE FOR THE NEXT STRING.  A UPRT 
      RETURN TO THE CALLER IS THEN MADE.                                 UPRT 
 #                                                                       UPRT 
        BEGIN                                                            UPRT 
                                                                         UPRT 
# FOLLOWING DEFS ARE FOR CODE READABILITY#                               UPRT 
                                                                         UPRT 
        DEF DFBLANK #O"55"#;  # OCTAL EQUIVALENT OF BLANK              # UPRT 
        DEF DFMINUS #O"46"#;  # OCTAL EQUIVALENT OF -                  # UPRT 
        DEF DFONE   #O"34"#;  # OCTAL EQUIVALENT OF 1                  # UPRT 
        DEF DFZERO  #O"33"#;  # OCTAL EQUIVALENT OF 0                  # UPRT 
                                                                         UPRT 
                                                                         UPRT 
        XREF PROC DB$UPHD;   #PRINT HEADER AND ADJUST LINES LEFT#        UPRT 
        XREF PROC DB$UPTL;   #PRINT LINE #                               UPRT 
                                                                         JJJ1107
        XREF ITEM DB$LNLF I;  # CONTAINS COUNT OF LINES LEFT ON PAGE   # UPRT 
      XREF ITEM DB$MOUT U;   # IF 0, SUPPRESS PRINTING                 # JJJ1107
                                                                         UPRT 
# FORMAL PARAMETERS                                                    # UPRT 
                                                                         UPRT 
        ITEM STRING C(140);  #STRING TO BE PRINTED#                      UPRT 
        ITEM LENGTH U;       #LENGTH OF STRING#                          UPRT 
                                                                         UPRT 
#     LOCAL ITEMS       #                                                JJJ1223
                                                                         JJJ1223
        ITEM FIRSTCHAR U;    #USED TO STORE FIRST CHAR OF STRING FOR #   UPRT 
                             #TESTS#                                     UPRT 
        ITEM LINEREQ I;      # LINES REQUIRED FOR CONTROL CHARACTER    # UPRT 
        ITEM PLEN I;         # LENGTH OF STRING TO BE PRINTED          # JJJ1223
        ITEM PSTRING C(140);  # STRING TO BE PRINTED            #        JJJ1223
      CONTROL EJECT;                    #        DB$RUPT               #
                                                                         JJJ1223
                                                                         UPRT 
                                                                         UPRT 
# START OF EXECUTABLE CODE                                             # UPRT 
                                                                         UPRT 
        IF DB$MOUT EQ 0 THEN RETURN;  # SUPPRESS LIST                  # JJJ1107
                                                                         JJJ1107
                                                                         JJJ1107
                                                                         JJJ1107
      ENTRY PROC DB$EPRT (STRING,LENGTH);  #USED TO FORCE PRINTING     # JJJ1107
                                                                         JJJ1107
        IF LENGTH GR 137     #IS STRING TOO LONG?#                       UPRT 
          THEN PLEN = 137;   # YES, TRUNCATE WITHOUT A MESSAGE         # JJJ1223
                                                                         UPRT 
          ELSE PLEN = LENGTH;  # NO, MOVE TO PLEN                      # JJJ1223
                                                                         JJJ1223
        C<0,PLEN>PSTRING = C<0,PLEN>STRING;                              JJJ1223
        FIRSTCHAR = C<0,1> STRING;  #GET FIRST CHAR FOR TESTING#         UPRT 
                                                                         UPRT 
# SET LINEREQ TO NUMBER OF LINES REQUIRED FOR CONTROL CHARACTER        # UPRT 
                                                                         UPRT 
        IF FIRSTCHAR EQ DFBLANK                                          UPRT 
          THEN LINEREQ = 1;                                              UPRT 
          ELSE                                                           UPRT 
          IF FIRSTCHAR EQ DFONE                                          UPRT 
            THEN LINEREQ = 60;                                           UPRT 
            ELSE                                                         UPRT 
            IF FIRSTCHAR EQ DFZERO                                       UPRT 
              THEN LINEREQ = 2;                                          UPRT 
              ELSE                                                       UPRT 
              IF FIRSTCHAR EQ DFMINUS                                    UPRT 
                THEN LINEREQ = 3;                                        UPRT 
                ELSE                                                     UPRT 
                BEGIN                                                    UPRT 
                C<0,1>PSTRING = DFBLANK;  # CHANGE UNSUPPORTED CHAR    # JJJ1223
                LINEREQ = 1;              # TO A BLANK                 # UPRT 
                END                                                      UPRT 
                                                                         UPRT 
# CHECK FOR ROOM ON PAGE FOR LINE                                      # UPRT 
                                                                         UPRT 
        IF LINEREQ GR DB$LNLF                                            UPRT 
          THEN               # NOT ENOUGH ROOM FOR LINE                # UPRT 
          BEGIN                                                          UPRT 
          DB$UPHD;           # PRINT HEADER AND BLANK LINE             # UPRT 
          C<0,1>PSTRING = DFBLANK;  # PRINT STRING ON THIRD LINE       # JJJ1223
          LINEREQ = 1;                                                   UPRT 
          END                                                            UPRT 
                                                                         UPRT 
# PRINT THE LINE AND ADJUST LINES LEFT                                 # UPRT 
                                                                         UPRT 
        DB$UPTL (PSTRING,PLEN);                                          JJJ1223
                                                                         UPRT 
        DB$LNLF = DB$LNLF - LINEREQ;                                     UPRT 
                                                                         UPRT 
        RETURN;                                                          UPRT 
                                                                         UPRT 
        END                                                              UPRT 
      TERM                                                               UPRT 
