IDENTIFICATION DIVISION.

PROGRAM-ID.		SHOWTAB.
AUTHOR.		BOB RIBOKAS.
INSTALLATION.	TERADYNE, INC.
DATE-WRITTEN.	SEPTEMBER 30, 1987.
DATE-COMPILED.	TODAY.
*REMARKS.		SHOW TABLE ENTRIES FOR A REMOTE TABLE.

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.
/
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 "*".
	   88 TABLE-COMMENT			VALUE "!", ";".
	02 TABLE-REST				PIC X(79).

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	WS-END-OF-FILE-FLAG			PIC 9(1), COMP.

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

01	WS-COMMAND-LINE				PIC X(500).

01	WS-TABLE-FILE-NAME			PIC X(80), VALUE
	"REMOTE$TABLES:REMTAB.DAT".

01	WS-CONTEXT				PIC 9(8), COMP.

01	RMS$__FNF				PIC S9(9), COMP, VALUE 98962.

01	STAT					PIC S9(9), COMP.

01	WS-TABLE-NAME				PIC X(5).

01	WS-PASS-NUMBER-FLAG			PIC 9(1), COMP, VALUE ZERO.

	88 WS-FIRST-PASS			VALUE 1.
	88 WS-SECOND-PASS			VALUE 2.

01	WS-TABLE-FILE				PIC X(40), VALUE SPACES.

01	WS-SWITCHES.

	02 WS-SWITCH				OCCURS 8 TIMES
						PIC X(100).

01	WS-SWITCH-ERROR-FLAG			PIC 9(1), COMP, VALUE ZERO.

	88 WS-SWITCH-ERRORS			VALUE 1.
	88 WS-NO-SWITCH-ERRORS			VALUE 0.

01	WS-SWITCH-HOLD				PIC X(100).

01	WS-SWITCH-NAME				PIC X(10).

01	WS-SWITCH-VALUE				PIC X(100).

01	WS-SELECT-HOLD.

	02 WS-HOLD-FIELD			PIC X(32).
	02 WS-HOLD-COMP				PIC X(2).
	02 WS-HOLD-VALUE			PIC X(40).

01	WS-SELECT-TABLE.

	02 WS-SELECT-ENTRY			OCCURS 25 TIMES
						INDEXED BY WS-SELECT-IDX.
	   03 WS-SELECT-FIELD			PIC X(32).
	   03 WS-SELECT-COMP			PIC X(2).
	   03 WS-SELECT-VALUE			PIC X(40).

01	WS-SELECT-MAX				PIC 9(2), COMP, VALUE ZERO.

01	WS-PASSED-SELECT-FLAG			PIC 9(1), COMP, VALUE ZERO.

	88 WS-PASSED-SELECT			VALUE 1.
	88 WS-FAILED-SELECT			VALUE 0.

01	WS-SELECT-COUNT				PIC 9(3), COMP, VALUE ZERO.

01	WS-FOUND-IT-FLAG			PIC 9(1), COMP, VALUE ZERO.

	88 WS-FOUND-IT				VALUE 1.
	88 WS-DIDNT-FIND-IT			VALUE 0.

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

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

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

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

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

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-NAME			PIC X(40).

01	WS-TABLE-DEF-CODE			PIC X(5).

01	WS-TABLE-DEF-FILE			PIC X(40).

01	WS-ELEMENT-DEF-TABLE			VALUE SPACES.

	02 WS-ELEMENT-DEF-ENTRY			OCCURS 50 TIMES
						INDEXED BY 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).

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

01	J					PIC 9(5), COMP.

01	WS-OUTPUT				PIC X(132), VALUE SPACES.

01	WS-SCROLL-START				PIC 9(2).

01	WS-TALLY				PIC 9(2).

01	WS-EQUAL				PIC 9(2).

01	WS-COLON				PIC 9(2).

01	WS-COLUMN				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-SHOWTAB SECTION.
001-INIT.

	CALL "LIB$GET_FOREIGN" USING BY DESCRIPTOR WS-COMMAND-LINE.
	PERFORM UNTIL WS-COMMAND-LINE NOT = SPACES
		DISPLAY "Table Name: " WITH NO ADVANCING
		ACCEPT WS-COMMAND-LINE
		 AT END
			STOP RUN
		END-ACCEPT
	END-PERFORM.

	CALL "STR$UPCASE" USING BY DESCRIPTOR WS-COMMAND-LINE, WS-COMMAND-LINE.

	MOVE SPACES TO WS-TABLE-NAME, WS-SWITCHES.
	UNSTRING WS-COMMAND-LINE DELIMITED BY "/"
	 INTO	WS-TABLE-NAME,	WS-SWITCH (1),	WS-SWITCH (2),
		WS-SWITCH (3),	WS-SWITCH (4),	WS-SWITCH (5),
		WS-SWITCH (6),	WS-SWITCH (7),	WS-SWITCH (8).

	IF WS-SWITCHES NOT = SPACES
		PERFORM 300-PARSE-SWITCHES
		IF WS-SWITCH-ERRORS
			STOP RUN.

	PERFORM 100-LOAD-DEFINITIONS.

	IF WS-DIDNT-FIND-IT
		DISPLAY "%SHOWTAB-E-NOTAB, No such table exists -- "
		 WS-TABLE-NAME
		STOP RUN.

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

	IF WS-SWITCHES NOT = SPACES
		PERFORM 300-PARSE-SWITCHES
		IF WS-SWITCH-ERRORS
			STOP RUN.

	IF WS-TABLE-FILE-NAME = "REMOTE$TABLES:REMTAB.DAT"
		CALL "LOADTABLE" USING	BY DESCRIPTOR	WS-TABLE-NAME,
					BY REFERENCE	WS-TABLE-DATA,
							WS-ENTRY-SIZE,
							WS-MAX-ENTRY,
							WS-ENTRY-COUNT
	ELSE
		CALL "LOADTABLE" USING	BY DESCRIPTOR	WS-TABLE-FILE-NAME,
							WS-TABLE-NAME,
					BY REFERENCE	WS-TABLE-DATA,
							WS-ENTRY-SIZE,
							WS-MAX-ENTRY,
							WS-ENTRY-COUNT.

	PERFORM 200-LIST-ENTRIES.

	DISPLAY " ".
	DISPLAY WS-ENTRY-COUNT WITH CONVERSION " entries"
	 WITH NO ADVANCING.
	IF WS-SELECT-MAX > ZERO
		DISPLAY ", " WS-SELECT-COUNT WITH CONVERSION " selected"
	ELSE
		DISPLAY " ".
	DISPLAY " ".

	DISPLAY "" "[1;24r" "" "[23;1H" WITH NO ADVANCING.

	STOP RUN.
/
100-LOAD-DEFINITIONS.

	MOVE ZERO TO I.

	SET TABLE-FILE-OK TO TRUE.
	OPEN INPUT TABLE-DEFINITIONS.
	IF TABLE-FILE-RETRY
		DISPLAY "%SHOWTAB-F-CANTOPENDEF,
-			" Could not OPEN Table Definition File"
		STOP RUN.

	SET WS-VALID-READ TO TRUE.

	PERFORM 105-READ-DEF.

	PERFORM 110-PROCESS-DEFINITIONS UNTIL WS-END-OF-FILE.

	CLOSE TABLE-DEFINITIONS.

	DISPLAY WS-OUTPUT ( 1 : I - WS-HOLD-LENGTH ).

105-READ-DEF.

	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 ).

110-PROCESS-DEFINITIONS.

	IF TABLE-DEF
		IF WS-FOUND-IT
			SET WS-END-OF-FILE TO TRUE
		ELSE
			PERFORM 120-DEFINE-TABLE
	ELSE IF NOT TABLE-COMMENT
		IF WS-FOUND-IT
		 AND TABLE-DEF-RECORD NOT = SPACES
			PERFORM 130-DEFINE-ELEMENT.	

	PERFORM 105-READ-DEF.
/
120-DEFINE-TABLE.

	MOVE SPACES TO WS-TABLE-DEF-NAME, WS-TABLE-DEF-CODE, WS-TABLE-DEF-FILE.

	UNSTRING TABLE-REST DELIMITED BY ","
	  INTO WS-TABLE-DEF-NAME, WS-TABLE-DEF-CODE, WS-TABLE-DEF-FILE.

	IF WS-TABLE-DEF-CODE = WS-TABLE-NAME
		IF WS-TABLE-FILE = SPACES
		 AND WS-TABLE-DEF-FILE NOT = SPACES
			MOVE WS-TABLE-DEF-FILE TO WS-SWITCH-VALUE, WS-TABLE-FILE
			PERFORM 360-TABLE-FILE-NAME
		END-IF
		SET WS-FOUND-IT TO TRUE
		DISPLAY "" "[H" "" "[J" WITH NO ADVANCING
		STRING	WS-TABLE-DEF-CODE	DELIMITED BY SPACES
			" - "			DELIMITED BY SIZE
			WS-TABLE-DEF-NAME	DELIMITED BY "  "
			" : "			DELIMITED BY SIZE
			WS-TABLE-FILE		DELIMITED BY SPACES
			";"			DELIMITED BY SIZE
		 INTO WS-OUTPUT
		MOVE ZERO TO WS-TALLY
		INSPECT WS-OUTPUT TALLYING WS-TALLY
		 FOR CHARACTERS BEFORE INITIAL ";"
		COMPUTE WS-COLUMN = 80 - WS-TALLY + 1
		DISPLAY "" "[1;" WS-COLUMN "H" "" "[1;7m"
			WS-OUTPUT ( 1 : WS-TALLY )
			"" "[0m" "" "[1;1H"
		 WITH NO ADVANCING
		MOVE SPACES TO WS-OUTPUT.

130-DEFINE-ELEMENT.

	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.

	CALL "STR$UPCASE" USING BY DESCRIPTOR WS-HOLD-OTHER, WS-HOLD-OTHER.
	CALL "STR$UPCASE" USING BY DESCRIPTOR WS-HOLD-KEY, WS-HOLD-KEY.

	IF WS-HOLD-OTHER = "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-ENTRY-SIZE.
	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 ZERO TO J.
	INSPECT WS-HOLD-NAME TALLYING J FOR CHARACTERS BEFORE INITIAL SPACE.
	DISPLAY WS-OUTPUT ( 1 : I ) WITH NO ADVANCING.
	IF WS-HOLD-KEY = "KEY"
		DISPLAY "" WITH NO ADVANCING.
	DISPLAY WS-HOLD-NAME ( 1 : J ).
	IF WS-HOLD-KEY = "KEY"
		DISPLAY "" WITH NO ADVANCING.
	ADD 1 TO I.
	MOVE "|" TO WS-OUTPUT (I : 1).
	COMPUTE I = I + WS-HOLD-LENGTH.
/
200-LIST-ENTRIES.

	IF WS-ELEMENT-INDEX < 16
		COMPUTE WS-SCROLL-START = WS-ELEMENT-INDEX + 2
		DISPLAY "" "[" WS-SCROLL-START ";24r"
			"" "[" WS-SCROLL-START ";1H" WITH NO ADVANCING.

	PERFORM 250-NEXT-ENTRY
		VARYING I FROM ZERO BY WS-ENTRY-SIZE
		UNTIL I = WS-ENTRY-COUNT * WS-ENTRY-SIZE.

250-NEXT-ENTRY.

	IF WS-SELECT-MAX > ZERO
		PERFORM 400-CHECK-ENTRY
		IF WS-PASSED-SELECT
			ADD 1 TO WS-SELECT-COUNT
			PERFORM 255-LIST-ENTRY
		ELSE
			CONTINUE
	ELSE
		PERFORM 255-LIST-ENTRY.

255-LIST-ENTRY.

	MOVE SPACES TO WS-OUTPUT.
	MOVE 1 TO J.

	PERFORM 260-LIST-FIELDS
		VARYING WS-ELEMENT-INDEX FROM 1 BY 1
		UNTIL WS-ELEMENT-DEF-NAME (WS-ELEMENT-INDEX) = SPACES.

	PERFORM VARYING J FROM 132 BY -1
	 UNTIL J = 1 OR WS-OUTPUT (J : 1) NOT = SPACE
		CONTINUE
	END-PERFORM.

	DISPLAY WS-OUTPUT ( 1 : J ).

260-LIST-FIELDS.

	IF J + WS-ELEMENT-DEF-LENGTH (WS-ELEMENT-INDEX) NOT > 133
	    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 WS-OUTPUT
			( 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 WS-OUTPUT
			( J : WS-ELEMENT-DEF-LENGTH (WS-ELEMENT-INDEX)
			    - WS-ELEMENT-DEF-DECIMAL (WS-ELEMENT-INDEX) - 1 )
		MOVE "." TO WS-OUTPUT
		 ( 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 WS-OUTPUT ( 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.

300-PARSE-SWITCHES.

	ADD 1 TO WS-PASS-NUMBER-FLAG.

	PERFORM 310-PARSE-SWITCH
		VARYING I FROM 1 BY 1
		UNTIL WS-SWITCH (I) = SPACES
		 OR I > 5.

310-PARSE-SWITCH.

	MOVE WS-SWITCH (I) TO WS-SWITCH-HOLD.

	MOVE ZERO TO WS-EQUAL, WS-COLON.
	INSPECT WS-SWITCH-HOLD TALLYING WS-EQUAL FOR ALL "=".
	INSPECT WS-SWITCH-HOLD TALLYING WS-COLON FOR ALL ":".
	IF WS-EQUAL = ZERO AND WS-COLON > ZERO
		INSPECT WS-SWITCH-HOLD REPLACING FIRST ":" BY "=".

	INSPECT WS-SWITCH-HOLD CONVERTING "=(,)" TO SPACES.

	MOVE SPACES TO WS-SWITCH-NAME, WS-SWITCH-VALUE.
	MOVE 1 TO J.
	UNSTRING WS-SWITCH-HOLD DELIMITED BY ALL SPACES
	 INTO WS-SWITCH-NAME, WITH POINTER J.

	PERFORM VARYING J FROM J BY 1 UNTIL J > 100
	 OR WS-SWITCH-HOLD (J : 1) NOT = SPACE
		CONTINUE
	END-PERFORM.

	IF J NOT > 100
		UNSTRING WS-SWITCH-HOLD INTO WS-SWITCH-VALUE
		 WITH POINTER J.

	IF WS-FIRST-PASS
		EVALUATE WS-SWITCH-NAME
		 WHEN "SELECT"		CONTINUE
		 WHEN "OR"		CONTINUE
		 WHEN "TABLE"		PERFORM 360-TABLE-FILE-NAME
		 WHEN "TABLE_FILE"	PERFORM 360-TABLE-FILE-NAME
		 WHEN OTHER
			DISPLAY "%SHOWTAB-E-BADSW, Unknown switch -- "
				WS-SWITCH-NAME
			SET WS-SWITCH-ERRORS TO TRUE
		END-EVALUATE
	ELSE
		EVALUATE WS-SWITCH-NAME
		 WHEN "SELECT"		PERFORM 320-SELECT-CHECK-FIELD
		 WHEN "OR"		PERFORM 350-SELECT-DO-OR.

320-SELECT-CHECK-FIELD.

	MOVE SPACES TO WS-SELECT-HOLD.
	MOVE 1 TO J.
	UNSTRING WS-SWITCH-VALUE DELIMITED BY ALL SPACES
	 INTO WS-HOLD-FIELD, WS-HOLD-COMP
	  WITH POINTER J.

	PERFORM VARYING J FROM J BY 1 UNTIL J > 100
	 OR WS-SWITCH-VALUE (J : 1) NOT = SPACE
		CONTINUE
	END-PERFORM.

	UNSTRING WS-SWITCH-VALUE
	 INTO WS-HOLD-VALUE
	  WITH POINTER J.

	SET ELEMENT-DEF-IDX TO 1.
	SEARCH WS-ELEMENT-DEF-ENTRY
	 AT END
		DISPLAY "%SHOWTAB-E-BADFIELD, Unknown field -- " WS-HOLD-FIELD
		SET WS-SWITCH-ERRORS TO TRUE
	 WHEN WS-ELEMENT-DEF-NAME (ELEMENT-DEF-IDX) = SPACES
		DISPLAY "%SHOWTAB-E-BADFIELD, Unknown field -- " WS-HOLD-FIELD
		SET WS-SWITCH-ERRORS TO TRUE
	 WHEN WS-ELEMENT-DEF-NAME (ELEMENT-DEF-IDX) = WS-HOLD-FIELD
		PERFORM 330-SELECT-CHECK-COMP.

330-SELECT-CHECK-COMP.

	IF WS-HOLD-COMP	   = "EQ" OR = "NE"
			OR = "LT" OR = "LE"
			OR = "GT" OR = "GE"
			OR = "ST" OR = "CT"
		PERFORM 340-SELECT-ADD-TO-TABLE
	ELSE
		DISPLAY "%SHOWTAB-E-BADCOMP, Invalid comparison -- "
			WS-HOLD-COMP
		SET WS-SWITCH-ERRORS TO TRUE.

340-SELECT-ADD-TO-TABLE.

	ADD 1 TO WS-SELECT-MAX.

	MOVE WS-SELECT-HOLD TO WS-SELECT-ENTRY (WS-SELECT-MAX).

350-SELECT-DO-OR.

	ADD 1 TO WS-SELECT-MAX.

	MOVE HIGH-VALUES TO WS-SELECT-ENTRY (WS-SELECT-MAX).

360-TABLE-FILE-NAME.

	MOVE WS-SWITCH-VALUE TO WS-TABLE-FILE.

	CALL "LIB$FIND_FILE" USING
		BY DESCRIPTOR	WS-SWITCH-VALUE
				WS-TABLE-FILE-NAME,
		BY REFERENCE	WS-CONTEXT,
		BY DESCRIPTOR	"REMOTE$TABLES:REMTAB.DAT"
	 GIVING STAT.

	IF STAT = RMS$__FNF
		DISPLAY "%SHOWTAB-E-NOFILE, No such file exists -- "
		 WS-TABLE-FILE
		SET WS-SWITCH-ERRORS TO TRUE
	ELSE IF STAT IS FAILURE
		CALL "LIB$STOP" USING BY VALUE STAT.

	CALL "LIB$FIND_FILE_END" USING
		BY REFERENCE	WS-CONTEXT
	 GIVING STAT.
	
	IF STAT IS FAILURE
		CALL "LIB$STOP" USING BY VALUE STAT.

400-CHECK-ENTRY.

	SET WS-SELECT-IDX TO 1.
	SET WS-PASSED-SELECT TO TRUE.

	PERFORM UNTIL WS-SELECT-IDX > WS-SELECT-MAX
	 OR WS-SELECT-ENTRY (WS-SELECT-IDX) = HIGH-VALUES
	  OR WS-FAILED-SELECT
		PERFORM 410-CHECK-SELECTS
			VARYING WS-SELECT-IDX FROM WS-SELECT-IDX BY 1
			UNTIL WS-SELECT-IDX > WS-SELECT-MAX
			 OR WS-SELECT-ENTRY (WS-SELECT-IDX) = HIGH-VALUES
			  OR WS-FAILED-SELECT
		IF WS-FAILED-SELECT
			PERFORM	WITH TEST AFTER
			 VARYING WS-SELECT-IDX FROM WS-SELECT-IDX BY 1
			  UNTIL WS-SELECT-ENTRY (WS-SELECT-IDX) = HIGH-VALUES
			   OR WS-SELECT-IDX > WS-SELECT-MAX
			 	IF WS-SELECT-ENTRY (WS-SELECT-IDX) = HIGH-VALUES
					SET WS-PASSED-SELECT TO TRUE
				END-IF
			END-PERFORM
			SET WS-SELECT-IDX UP BY 1
		END-IF
	END-PERFORM.

410-CHECK-SELECTS.

	SET ELEMENT-DEF-IDX TO 1.
	SEARCH WS-ELEMENT-DEF-ENTRY
	 AT END
		CONTINUE
	 WHEN WS-ELEMENT-DEF-NAME (ELEMENT-DEF-IDX) = SPACES
		CONTINUE
	 WHEN WS-ELEMENT-DEF-NAME (ELEMENT-DEF-IDX)
	    = WS-SELECT-FIELD (WS-SELECT-IDX)
		PERFORM 420-CHECK-FIELD.

420-CHECK-FIELD.

	COMPUTE WS-START-POS = I + WS-ELEMENT-DEF-START (ELEMENT-DEF-IDX).
	MOVE WS-ELEMENT-DEF-LENGTH (ELEMENT-DEF-IDX) TO WS-HOLD-LENGTH.

	MOVE WS-TABLE-DATA (WS-START-POS : WS-HOLD-LENGTH) TO WS-HOLD-VALUE.

	CALL "STR$UPCASE" USING BY DESCRIPTOR WS-HOLD-VALUE, WS-HOLD-VALUE.

	IF WS-SELECT-COMP (WS-SELECT-IDX) = "EQ"
	 AND WS-HOLD-VALUE NOT = WS-SELECT-VALUE (WS-SELECT-IDX)
		SET WS-FAILED-SELECT TO TRUE
	ELSE IF WS-SELECT-COMP (WS-SELECT-IDX) = "NE"
	 AND WS-HOLD-VALUE = WS-SELECT-VALUE (WS-SELECT-IDX)
		SET WS-FAILED-SELECT TO TRUE
	ELSE IF WS-SELECT-COMP (WS-SELECT-IDX) = "LT"
	 AND WS-HOLD-VALUE NOT < WS-SELECT-VALUE (WS-SELECT-IDX)
		SET WS-FAILED-SELECT TO TRUE
	ELSE IF WS-SELECT-COMP (WS-SELECT-IDX) = "LE"
	 AND WS-HOLD-VALUE > WS-SELECT-VALUE (WS-SELECT-IDX)
		SET WS-FAILED-SELECT TO TRUE
	ELSE IF WS-SELECT-COMP (WS-SELECT-IDX) = "GT"
	 AND WS-HOLD-VALUE NOT > WS-SELECT-VALUE (WS-SELECT-IDX)
		SET WS-FAILED-SELECT TO TRUE
	ELSE IF WS-SELECT-COMP (WS-SELECT-IDX) = "GE"
	 AND WS-HOLD-VALUE < WS-SELECT-VALUE (WS-SELECT-IDX)
		SET WS-FAILED-SELECT TO TRUE
	ELSE IF WS-SELECT-COMP (WS-SELECT-IDX) = "ST"
		MOVE ZERO TO WS-TALLY
		INSPECT WS-SELECT-VALUE (WS-SELECT-IDX) TALLYING WS-TALLY
		 FOR CHARACTERS BEFORE INITIAL SPACE
		IF WS-HOLD-VALUE ( 1 : WS-TALLY )
		 NOT = WS-SELECT-VALUE (WS-SELECT-IDX) ( 1 : WS-TALLY )
			SET WS-FAILED-SELECT TO TRUE
		END-IF
	ELSE IF WS-SELECT-COMP (WS-SELECT-IDX) = "CT"
		MOVE ZERO TO WS-TALLY
		INSPECT WS-SELECT-VALUE (WS-SELECT-IDX) TALLYING WS-TALLY
		 FOR CHARACTERS BEFORE INITIAL SPACE
		SET WS-FAILED-SELECT TO TRUE
		PERFORM VARYING J FROM 1 BY 1 UNTIL J > 40 - WS-TALLY + 1
			IF WS-HOLD-VALUE ( J : WS-TALLY )
			 = WS-SELECT-VALUE (WS-SELECT-IDX) ( 1 : WS-TALLY )
				SET WS-PASSED-SELECT TO TRUE
			END-IF
		END-PERFORM.