IDENTIFICATION DIVISION.

PROGRAM-ID.		LISTTAB.
AUTHOR.		BOB RIBOKAS.
INSTALLATION.	TERADYNE, INC.
DATE-WRITTEN.	MARCH 16, 1989.
DATE-COMPILED.	TODAY.
*REMARKS.		REMOTE TABLE FILE LISTING.

ENVIRONMENT DIVISION.

CONFIGURATION SECTION.

SOURCE-COMPUTER. VAX-11.
OBJECT-COMPUTER. VAX-11.

INPUT-OUTPUT SECTION.
FILE-CONTROL.

	SELECT TABLE-DEFINITIONS ASSIGN TO "REMOTE$TABLES:"
		ORGANIZATION IS SEQUENTIAL
		ACCESS MODE IS SEQUENTIAL
		FILE STATUS IS TABLE-FILE-STATUS.

	SELECT WORK-FILE ASSIGN TO "SYS$DISK:"
		ORGANIZATION IS SEQUENTIAL
		ACCESS MODE IS SEQUENTIAL.

	SELECT SORT-FILE ASSIGN TO "SYS$DISK:".

	SELECT RPT-FILE ASSIGN TO "SYS$DISK:"
		ORGANIZATION IS SEQUENTIAL
		ACCESS MODE IS SEQUENTIAL.

DATA DIVISION.

FILE SECTION.

FD	TABLE-DEFINITIONS

	LABEL RECORDS ARE STANDARD
	VALUE OF ID IS "REMTAB.DEF"
	DATA RECORD IS TABLE-DEF-RECORD.

01	TABLE-DEF-RECORD.

	02 TABLE-DEFINITION-CODE		PIC X(1).
	   88 TABLE-DEF				VALUE "*".
	02 TABLE-REST				PIC X(79).

FD	WORK-FILE

	LABEL RECORDS ARE STANDARD
	VALUE OF ID IS "LISTTAB.WRK"
	DATA RECORD IS WORK-RECORD.

01	WORK-RECORD.

	02 WORK-TABLE-FILE-ID			PIC X(20).
	02 WORK-TABLE-NAME			PIC X(5).

SD	SORT-FILE.

01	SORT-RECORD.

	02 SORT-TABLE-FILE-ID			PIC X(20).
	02 SORT-TABLE-NAME			PIC X(5).

FD	RPT-FILE

	LABEL RECORDS ARE STANDARD
	VALUE OF ID IS RPT-FILE-ID
	RECORD IS VARYING IN SIZE FROM 1 TO 400 CHARACTERS
	 DEPENDING ON RPT-LEN
	DATA RECORD IS RPT-RECORD.

01	RPT-RECORD				PIC X(400).

WORKING-STORAGE SECTION.

01	TABLE-FILE-STATUS			PIC X(2).

	88 TABLE-FILE-NOT-FOUND			VALUE "97".

01	TABLE-FILE-RETRY-FLAG			PIC 9(1), COMP.

	88 TABLE-FILE-OK			VALUE 0.
	88 TABLE-FILE-RETRY			VALUE 1.

01	RPT-FILE-ID				PIC X(20).

01	RPT-IDX					PIC 9(3), COMP.

01	RPT-LEN					PIC 9(3), COMP.

01	WS-LADV					PIC S9(1), COMP.

01	WS-END-OF-FILE-FLAG			PIC 9(1), COMP.

	88 WS-END-OF-FILE			VALUE 1.
	88 WS-VALID-READ			VALUE 0.

01	WS-LAST-TABLE-FILE-ID			PIC X(20).

01	WS-TABLE-INDEX				PIC 9(3), COMP.

01	WS-ELEMENT-INDEX			PIC 9(3), COMP.

01	WS-START-POS				PIC 9(3), COMP.

01	WS-ENTRY-SIZE				PIC 9(3), COMP, VALUE ZERO.

01	WS-MAX-ENTRY				PIC 9(3), COMP.

01	WS-ENTRY-COUNT				PIC S9(3), COMP.
	88 WS-LOAD-FAILED			VALUE -1.

01	WS-HOLD-AREA.

	02 WS-HOLD-NAME				PIC X(30).
	02 WS-HOLD-TYPE				PIC X(1).
	02 WS-HOLD-LENGTH			PIC 9(2).
	02 WS-HOLD-OTHER			PIC X(3).
	02 WS-HOLD-DECIMAL			PIC 9(2).
	02 WS-HOLD-KEY				PIC X(3).
	   88 WS-KEY-ELEMENT			VALUE "KEY".

01	WS-TABLE-DEF-TABLE			VALUE SPACES.

	02 WS-TABLE-DEF-ENTRY			OCCURS 200 TIMES
						INDEXED BY WS-TABLE-DEF-IDX.

	   03 WS-TABLE-DEF-DESC			PIC X(40).
	   03 WS-TABLE-DEF-NAME			PIC X(5).
	   03 WS-TABLE-DEF-KEYS			PIC 9(1).
	   03 WS-TABLE-DEF-ELEMENT-IDX		PIC 9(4).
	   03 WS-TABLE-DEF-ENTRY-SIZE		PIC 9(3).

01	WS-ELEMENT-DEF-TABLE			VALUE SPACES.

	02 WS-ELEMENT-DEF-ENTRY			OCCURS 2000 TIMES
						INDEXED BY WS-ELEMENT-DEF-IDX.

	   03 WS-ELEMENT-DEF-NAME		PIC X(30).
	   03 WS-ELEMENT-DEF-TYPE		PIC X(1).
	      88 WS-ELEMENT-DEF-CHARACTER	VALUE "C", "c".
	      88 WS-ELEMENT-DEF-NUMERIC		VALUE "N", "n".
	   03 WS-ELEMENT-DEF-START		PIC 9(3).
	   03 WS-ELEMENT-DEF-LENGTH		PIC 9(2).
	   03 WS-ELEMENT-DEF-DECIMAL		PIC 9(2).
	   03 WS-ELEMENT-DEF-TABLE-IDX		PIC 9(3).
	   03 WS-ELEMENT-DEF-KEY-FLAG		PIC X(1).
	      88 WS-ELEMENT-DEF-KEY		VALUE "*".

01	WS-HEADER-LINES.

	02 WS-HEADER-LINE			OCCURS 25 TIMES
						INDEXED BY WS-HEAD-IDX.
	   03 WS-HEADER-TEXT			PIC X(400).
	   03 WS-HEADER-KEY-FLAG		PIC X(1).
	      88 WS-HEADER-KEY			VALUE "*".

01	WS-PAGE-NO				PIC 9(5), COMP, VALUE ZERO.

01	WS-SUB-NO				PIC 9(5), COMP, VALUE ZERO.

01	WS-LINE-NO				PIC S9(2), COMP, VALUE ZERO.

	88 WS-END-OF-PAGE			VALUES -99 THRU ZERO.

01	WS-PAGE-OUT-X.
	02 WS-PAGE-OUT				PIC ZZZZ9.

01	WS-SUB-OUT-X.
	02 WS-SUB-OUT				PIC ZZZZ9.

01	WS-PAGE-TEXT				PIC X(16).

01	I					PIC 9(5), COMP, VALUE ZERO.

01	J					PIC 9(5), COMP.

01	K					PIC 9(5), COMP.

01	WS-TALLY				PIC 9(2).

01	WS-TABLE-DATA				PIC X(32000).

PROCEDURE DIVISION.

DECLARATIVES.

TABLE-DEFINTION-ERROR SECTION.
	USE AFTER STANDARD ERROR PROCEDURE ON TABLE-DEFINITIONS.
TABLE-DEFINITION-DECODE.
	IF TABLE-FILE-NOT-FOUND
		SET TABLE-FILE-RETRY TO TRUE.

END DECLARATIVES.

000-LISTTAB SECTION.
001-INIT.

	DISPLAY " ".
	DISPLAY "[LISTTAB] Remote Table Lister Program".
	DISPLAY " ".

	DISPLAY "[Building Work File]".

	PERFORM 1000-LOAD-DEFINITIONS.

	DISPLAY "[Sorting Work File]".

	SORT SORT-FILE
	 ON ASCENDING KEY	SORT-TABLE-FILE-ID
				SORT-TABLE-NAME
	 USING	WORK-FILE
	 GIVING	WORK-FILE.

	DISPLAY "[Processing Work File]".

	PERFORM 2000-PROCESS-WORK-FILE.

	CALL "LIB$DELETE_FILE" USING BY DESCRIPTOR "SYS$DISK:LISTTAB.WRK;*".

	STOP RUN.

1000-LOAD-DEFINITIONS SECTION.
1001-INIT.

	SET TABLE-FILE-OK TO TRUE.
	OPEN INPUT TABLE-DEFINITIONS.
	IF TABLE-FILE-RETRY
		DISPLAY "?Could not OPEN Table Definition File... Aborting..."
		STOP RUN.

	OPEN OUTPUT WORK-FILE.

	MOVE ZERO TO WS-TABLE-INDEX, WS-ELEMENT-INDEX.

	SET WS-VALID-READ TO TRUE.
	PERFORM 1100-READ-DEF.

	IF WS-VALID-READ
		PERFORM 1200-PROCESS-DEFINITIONS UNTIL WS-END-OF-FILE.

	ADD 1 TO WS-ELEMENT-INDEX.
	MOVE 9999 TO WS-ELEMENT-DEF-TABLE-IDX (WS-ELEMENT-INDEX).

	CLOSE TABLE-DEFINITIONS.
	CLOSE WORK-FILE.

1099-EXIT.

	EXIT.

1100-READ-DEF SECTION.
1101-INIT.

	MOVE SPACES TO TABLE-DEF-RECORD.
	READ TABLE-DEFINITIONS
	 AT END
		SET WS-END-OF-FILE TO TRUE.

	INSPECT TABLE-DEF-RECORD REPLACING ALL "	" BY " ".
	INSPECT TABLE-DEF-RECORD REPLACING ALL ";" BY "!".

	MOVE ZERO TO WS-TALLY.
	INSPECT TABLE-DEF-RECORD
		TALLYING WS-TALLY FOR CHARACTERS BEFORE INITIAL "!".
	MOVE SPACES TO TABLE-DEF-RECORD ( WS-TALLY + 1 : 80 - WS-TALLY ).

1199-EXIT.

	EXIT.

1200-PROCESS-DEFINITIONS SECTION.
1201-INIT.

	IF TABLE-DEF
		PERFORM 1300-DEFINE-TABLE
	ELSE
		IF TABLE-DEF-RECORD NOT = SPACES
		 AND WS-TABLE-INDEX > ZERO
			PERFORM 1400-DEFINE-ELEMENT.	

	PERFORM 1100-READ-DEF.

1299-EXIT.

	EXIT.

1300-DEFINE-TABLE SECTION.
1301-INIT.

	ADD 1 TO WS-TABLE-INDEX.

	UNSTRING TABLE-REST DELIMITED BY ","
	  INTO	WS-TABLE-DEF-DESC (WS-TABLE-INDEX),
		WORK-TABLE-NAME,
		WORK-TABLE-FILE-ID.

	MOVE WORK-TABLE-NAME TO WS-TABLE-DEF-NAME (WS-TABLE-INDEX).

	MOVE ZERO TO	WS-TABLE-DEF-KEYS	(WS-TABLE-INDEX),
			WS-TABLE-DEF-ENTRY-SIZE	(WS-TABLE-INDEX).

	COMPUTE WS-TABLE-DEF-ELEMENT-IDX (WS-TABLE-INDEX)
	 = WS-ELEMENT-INDEX + 1.

	MOVE 1 TO WS-START-POS.

	WRITE WORK-RECORD.

1399-EXIT.

	EXIT.

1400-DEFINE-ELEMENT SECTION.
1401-INIT.

	ADD 1 TO WS-ELEMENT-INDEX.

	MOVE SPACES TO WS-HOLD-AREA.
	UNSTRING TABLE-DEF-RECORD DELIMITED BY "," OR ALL SPACES
	 INTO	WS-HOLD-NAME,	WS-HOLD-TYPE,	WS-HOLD-LENGTH,
		WS-HOLD-OTHER,	WS-HOLD-KEY.

	IF WS-HOLD-OTHER = "KEY" OR "key" OR "Key"
		MOVE "0" TO WS-HOLD-OTHER
		MOVE "KEY" TO WS-HOLD-KEY.

	IF WS-HOLD-OTHER = SPACES
		MOVE "0" TO WS-HOLD-OTHER.

	UNSTRING WS-HOLD-OTHER DELIMITED BY ALL SPACES INTO WS-HOLD-DECIMAL.

	MOVE WS-START-POS	TO WS-ELEMENT-DEF-START     (WS-ELEMENT-INDEX).

	ADD WS-HOLD-LENGTH TO	WS-START-POS,
				WS-TABLE-DEF-ENTRY-SIZE (WS-TABLE-INDEX).

	IF WS-HOLD-DECIMAL > ZERO
		ADD 1 TO WS-HOLD-LENGTH.

	MOVE WS-HOLD-NAME	TO WS-ELEMENT-DEF-NAME      (WS-ELEMENT-INDEX).
	MOVE WS-HOLD-TYPE	TO WS-ELEMENT-DEF-TYPE	    (WS-ELEMENT-INDEX).
	MOVE WS-HOLD-LENGTH	TO WS-ELEMENT-DEF-LENGTH    (WS-ELEMENT-INDEX).
	MOVE WS-HOLD-DECIMAL	TO WS-ELEMENT-DEF-DECIMAL   (WS-ELEMENT-INDEX).
	MOVE WS-TABLE-INDEX	TO WS-ELEMENT-DEF-TABLE-IDX (WS-ELEMENT-INDEX).

	IF WS-KEY-ELEMENT
		ADD 1 TO WS-TABLE-DEF-KEYS (WS-TABLE-INDEX)
		SET WS-ELEMENT-DEF-KEY (WS-ELEMENT-INDEX) TO TRUE.


1499-EXIT.

	EXIT.

2000-PROCESS-WORK-FILE SECTION.
2001-INIT.

	OPEN INPUT WORK-FILE.

	SET WS-VALID-READ TO TRUE.
	READ WORK-FILE
	 AT END
		SET WS-END-OF-FILE TO TRUE.

	PERFORM 2100-NEW-TABLE-FILE.

	PERFORM 2200-WORK-LOOP UNTIL WS-END-OF-FILE.

	CLOSE WORK-FILE.

2099-EXIT.

	EXIT.

2100-NEW-TABLE-FILE SECTION.
2101-INIT.

	MOVE WORK-TABLE-FILE-ID TO WS-LAST-TABLE-FILE-ID, RPT-FILE-ID.

	MOVE ZERO TO WS-TALLY.
	INSPECT RPT-FILE-ID TALLYING WS-TALLY
	 FOR CHARACTERS BEFORE INITIAL ".".
	IF WS-TALLY = 20
		INSPECT RPT-FILE-ID TALLYING WS-TALLY
		 FOR CHARACTERS BEFORE INITIAL SPACE.
	MOVE ".RPT" TO RPT-FILE-ID (WS-TALLY + 1 : 4).

	OPEN OUTPUT RPT-FILE.

	MOVE ZERO TO WS-PAGE-NO, WS-SUB-NO.

	MOVE ZERO TO WS-TALLY.
	INSPECT WS-LAST-TABLE-FILE-ID
		TALLYING WS-TALLY FOR CHARACTERS
		BEFORE INITIAL SPACE.

	DISPLAY "[Processing Table File: "
		WS-LAST-TABLE-FILE-ID ( 1 : WS-TALLY ) "]".

2199-EXIT.

	EXIT.

2200-WORK-LOOP SECTION.
2201-INIT.

	IF WORK-TABLE-FILE-ID NOT = WS-LAST-TABLE-FILE-ID
		DISPLAY " "
		MOVE ZERO TO K
		CLOSE RPT-FILE
		PERFORM 2100-NEW-TABLE-FILE.

	ADD 1 TO K.
	IF K > 13
		DISPLAY " "
		MOVE 1 TO K.

	DISPLAY WORK-TABLE-NAME " " WITH NO ADVANCING.

	PERFORM 2300-LOAD-TABLE.

	PERFORM 3000-LIST-TABLE.

	READ WORK-FILE
	 AT END
		SET WS-END-OF-FILE TO TRUE
		CLOSE RPT-FILE.

2299-EXIT.

	EXIT.

2300-LOAD-TABLE SECTION.
2301-INIT.

	SET WS-TABLE-DEF-IDX TO 1.
	SEARCH WS-TABLE-DEF-ENTRY
	 AT END
		DISPLAY "?TABLE NOT FOUND IN INTERNAL TABLE -- "
			WORK-TABLE-NAME
		STOP RUN
	 WHEN WS-TABLE-DEF-NAME (WS-TABLE-DEF-IDX) = WORK-TABLE-NAME
		MOVE WS-TABLE-DEF-ENTRY-SIZE (WS-TABLE-DEF-IDX)
		 TO WS-ENTRY-SIZE.

	IF 32000 / WS-ENTRY-SIZE > 999
		MOVE 999 TO WS-MAX-ENTRY
	ELSE
		COMPUTE WS-MAX-ENTRY = 32000 / WS-ENTRY-SIZE.

	CALL "LOADTABLE" USING	BY DESCRIPTOR	WS-LAST-TABLE-FILE-ID,
						WORK-TABLE-NAME,
				BY REFERENCE	WS-TABLE-DATA,
						WS-ENTRY-SIZE,
						WS-MAX-ENTRY,
						WS-ENTRY-COUNT.

2399-EXIT.

	EXIT.

3000-LIST-TABLE SECTION.
3001-INIT.

	ADD 1 TO WS-PAGE-NO.
	MOVE 1 TO WS-SUB-NO.

	PERFORM 3500-MAKE-PAGE-NO.

	MOVE SPACES TO RPT-RECORD.
	STRING	WS-TABLE-DEF-NAME (WS-TABLE-DEF-IDX)	DELIMITED BY SPACES
		" - "					DELIMITED BY SIZE
		WS-TABLE-DEF-DESC (WS-TABLE-DEF-IDX)	DELIMITED BY "  "
	 INTO RPT-RECORD.

	MOVE WS-PAGE-TEXT TO RPT-RECORD (117 : 16).

	MOVE -1 TO WS-LADV.
	PERFORM 3400-WRITE-RPT.

	MOVE WS-TABLE-DEF-ELEMENT-IDX (WS-TABLE-DEF-IDX) TO WS-ELEMENT-INDEX.

	MOVE SPACES TO WS-HEADER-LINES.
	MOVE SPACES TO RPT-RECORD.
	MOVE 1 TO I, J.

	MOVE 2 TO WS-LADV.
	PERFORM 3100-DO-HEADER
		VARYING WS-ELEMENT-INDEX
		FROM WS-ELEMENT-INDEX BY 1
		UNTIL WS-ELEMENT-DEF-TABLE-IDX (WS-ELEMENT-INDEX)
		 NOT = WS-TABLE-DEF-IDX.

	MOVE RPT-RECORD TO WS-HEADER-TEXT (J).
	IF WS-ELEMENT-DEF-KEY (WS-ELEMENT-INDEX)
		SET WS-HEADER-KEY (J) TO TRUE.

	PERFORM 3400-WRITE-RPT.

	IF WS-LOAD-FAILED
	 OR WS-ENTRY-COUNT = ZERO
		MOVE 2 TO WS-LADV
		MOVE "No entries exist for this table." TO RPT-RECORD
		PERFORM 3400-WRITE-RPT
	ELSE
		PERFORM 3200-LIST-ENTRIES
			VARYING I FROM ZERO BY WS-ENTRY-SIZE
			UNTIL I = WS-ENTRY-COUNT * WS-ENTRY-SIZE.

3099-EXIT.

	EXIT.

3100-DO-HEADER SECTION.
3101-INIT.

	MOVE WS-ELEMENT-DEF-NAME (WS-ELEMENT-INDEX)
	 TO RPT-RECORD (I : 30).

	MOVE RPT-RECORD TO WS-HEADER-TEXT (J).
	IF WS-ELEMENT-DEF-KEY (WS-ELEMENT-INDEX)
		SET WS-HEADER-KEY (J) TO TRUE.
	ADD 1 TO J.

	PERFORM 3400-WRITE-RPT.

	IF WS-ELEMENT-DEF-KEY (WS-ELEMENT-INDEX)
		WRITE RPT-RECORD AFTER 0.

	MOVE "|" TO RPT-RECORD (I : 400 - I).

	COMPUTE I = I + WS-ELEMENT-DEF-LENGTH (WS-ELEMENT-INDEX) + 1.

3199-EXIT.

	EXIT.

3200-LIST-ENTRIES SECTION.
3201-INIT.

	IF WS-END-OF-PAGE
		PERFORM 3600-NEW-PAGE.

	MOVE SPACES TO RPT-RECORD.
	MOVE 1 TO J.

	MOVE WS-TABLE-DEF-ELEMENT-IDX (WS-TABLE-DEF-IDX) TO WS-ELEMENT-INDEX.

	PERFORM 3300-LIST-FIELDS
		VARYING WS-ELEMENT-INDEX
		FROM WS-ELEMENT-INDEX BY 1
		UNTIL WS-ELEMENT-DEF-TABLE-IDX (WS-ELEMENT-INDEX)
		 NOT = WS-TABLE-DEF-IDX.

	PERFORM 3400-WRITE-RPT.

3299-EXIT.

	EXIT.

3300-LIST-FIELDS SECTION.
3301-INIT.

	IF J + WS-ELEMENT-DEF-LENGTH (WS-ELEMENT-INDEX) NOT > 401
	    IF WS-ELEMENT-DEF-DECIMAL (WS-ELEMENT-INDEX) = ZERO
		MOVE WS-TABLE-DATA
			( I + WS-ELEMENT-DEF-START  (WS-ELEMENT-INDEX)
			    : WS-ELEMENT-DEF-LENGTH (WS-ELEMENT-INDEX) )
		  TO RPT-RECORD
			( J : WS-ELEMENT-DEF-LENGTH (WS-ELEMENT-INDEX) )
	    ELSE
		MOVE WS-TABLE-DATA
			( I + WS-ELEMENT-DEF-START   (WS-ELEMENT-INDEX)
			    : WS-ELEMENT-DEF-LENGTH  (WS-ELEMENT-INDEX)
			    - WS-ELEMENT-DEF-DECIMAL (WS-ELEMENT-INDEX) - 1 )
		  TO RPT-RECORD
			( J : WS-ELEMENT-DEF-LENGTH (WS-ELEMENT-INDEX)
			    - WS-ELEMENT-DEF-DECIMAL (WS-ELEMENT-INDEX) - 1 )
		MOVE "." TO RPT-RECORD
		 ( J + WS-ELEMENT-DEF-LENGTH  (WS-ELEMENT-INDEX)
		     - WS-ELEMENT-DEF-DECIMAL (WS-ELEMENT-INDEX) - 1 : 1 )
		MOVE WS-TABLE-DATA
		 ( I + WS-ELEMENT-DEF-START   (WS-ELEMENT-INDEX)
		     + WS-ELEMENT-DEF-LENGTH  (WS-ELEMENT-INDEX)
		     - WS-ELEMENT-DEF-DECIMAL (WS-ELEMENT-INDEX) - 1
		     : WS-ELEMENT-DEF-DECIMAL (WS-ELEMENT-INDEX) )
		  TO RPT-RECORD ( J + WS-ELEMENT-DEF-LENGTH (WS-ELEMENT-INDEX)
				- WS-ELEMENT-DEF-DECIMAL (WS-ELEMENT-INDEX)
		     : WS-ELEMENT-DEF-DECIMAL (WS-ELEMENT-INDEX) )
	    END-IF
	    COMPUTE J = J + WS-ELEMENT-DEF-LENGTH (WS-ELEMENT-INDEX) + 1.

3399-EXIT.

	EXIT.

3400-WRITE-RPT SECTION.
3401-INIT.

	PERFORM VARYING RPT-LEN FROM 400 BY -1
	 UNTIL RPT-LEN = 1 OR RPT-RECORD (RPT-LEN : 1) NOT = SPACE
		CONTINUE
	END-PERFORM.

	IF WS-LADV = -1
		WRITE RPT-RECORD AFTER PAGE
		MOVE 55 TO WS-LINE-NO
	ELSE
		WRITE RPT-RECORD AFTER WS-LADV
		SUBTRACT WS-LADV FROM WS-LINE-NO.

	MOVE 1 TO WS-LADV.

3499-EXIT.

	EXIT.

3500-MAKE-PAGE-NO SECTION.
3501-INIT.

	MOVE WS-PAGE-NO TO WS-PAGE-OUT.
	MOVE WS-SUB-NO TO WS-SUB-OUT.

	MOVE ZERO TO WS-TALLY.
	INSPECT WS-PAGE-OUT-X TALLYING WS-TALLY FOR LEADING SPACES.
	MOVE WS-PAGE-OUT-X (WS-TALLY + 1 : 5 - WS-TALLY) TO WS-PAGE-OUT-X.

	MOVE ZERO TO WS-TALLY.
	INSPECT WS-SUB-OUT-X TALLYING WS-TALLY FOR LEADING SPACES.
	MOVE WS-SUB-OUT-X (WS-TALLY + 1 : 5 - WS-TALLY) TO WS-SUB-OUT-X.

	MOVE SPACES TO WS-PAGE-TEXT.
	STRING	"PAGE "				DELIMITED BY SIZE
		WS-PAGE-OUT			DELIMITED BY SPACES
		"-"				DELIMITED BY SIZE
		WS-SUB-OUT			DELIMITED BY SPACES
	 INTO WS-PAGE-TEXT.

3599-EXIT.

	EXIT.

3600-NEW-PAGE SECTION.
3601-INIT.

	ADD 1 TO WS-SUB-NO.

	PERFORM 3500-MAKE-PAGE-NO.

	MOVE SPACES TO RPT-RECORD.
	STRING	WS-TABLE-DEF-NAME (WS-TABLE-DEF-IDX)	DELIMITED BY SPACES
		" - "					DELIMITED BY SIZE
		WS-TABLE-DEF-DESC (WS-TABLE-DEF-IDX)	DELIMITED BY "  "
	 INTO RPT-RECORD.

	MOVE WS-PAGE-TEXT TO RPT-RECORD (117 : 16).

	MOVE -1 TO WS-LADV.
	PERFORM 3400-WRITE-RPT.

	MOVE 2 TO WS-LADV.
	PERFORM VARYING WS-HEAD-IDX FROM 1 BY 1
	 UNTIL WS-HEAD-IDX = 25 OR WS-HEADER-LINE (WS-HEAD-IDX) = SPACES
		MOVE WS-HEADER-LINE (WS-HEAD-IDX) TO RPT-RECORD
		PERFORM 3400-WRITE-RPT
		IF WS-HEADER-KEY (WS-HEAD-IDX)
			WRITE RPT-RECORD AFTER 0
		END-IF
	END-PERFORM.

3699-EXIT.

	EXIT.