;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page   1
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (1)

;	0001	MODULE VALIDATE (MAIN = VALIDATE, LIST(SOURCE,COMMENTARY))=
;	0002	BEGIN
;	0003	
;	0004	!	Program Validate is designed to aid command procedure files by setting
;	0005	!	exit status according to whether or not the file named on the command
;	0006	!	line exists or not.  $SEVERITY is:
;	0007	!		WARNING if there was an error on the command line
;	0008	!		INFORMATIONAL if the file (or its directory) did not exist
;	0009	!		SUCCESS if the file did exist
;	0010	!
;	0011	!	Parameter:
;	0012	!		file-spec
;	0013	!
;	0014	!	Qualiflers:
;	0015	!		/[NO]LOG - write the name of the file to SYS$OUTPUT
;	0016	!		/[NO]BRIEF - for /LOG, delete the prefix " File found: "
;	0017	!			   from the message.
;	0018	!		/DEFAULT - provides any element that should be used as default
;	0019	!			   in the file spec, in file-spec format.
;	0020	
;	0021	!	Written by R.J. FitzPatrick 23-Jul-1980 at SAO
;	0022	
;	0023	LIBRARY 'SYS$LIBRARY:STARLET.L32';
;	0024	LIBRARY 'SYS$LIBRARY:CLIMAC.L32';
;	0025	LIBRARY 'SYS$LIBRARY:TPAMAC.L32';
;	0026	
;	0027	!	STRINGS is a macro package that allows easy definition of string
;	0028	!	literals, with optional descriptor.
;	0029	
;      R0031	
;      R0032	!	Macros for string handling.
;      R0033	
;      R0034	COMPILETIME
;      R0035	    %NAME('S\N') = 0;
;      R0036	
;      R0037	MACRO STRING_LENGTH(STRNAME) = %NAME(STRNAME, '\L') %;
;      R0038	
;      R0039	MACRO DESCRIPTOR(STRNAME) = %NAME(STRNAME, '\D') %;
;      R0040	
;     MR0041	MACRO %NAME('S\AUX')(SN, S, SNUM) =
;     MR0042	    MACRO SN = %NAME('S\', SNUM) %QUOTE % ;
;     MR0043	    LITERAL %NAME(SN, '\L') = %CHARCOUNT(S);
;     MR0044	    BIND
;      R0045		SN = UPLIT BYTE (S); %;
;      R0046	
;     MR0047	MACRO PSLIT(STRNAME, STR) = 
;     MR0048	    %ASSIGN (%NAME('S\N'), %NAME('S\N')+1);
;      R0049	    %NAME('S\AUX')(STRNAME, STR, %NUMBER(%NAME('S\N'))); %;
;      R0050	
;     MR0051	MACRO PDSLIT(STRNAMED, STRD) =
;     MR0052	    PSLIT(STRNAMED, STRD);
;     MR0053	    BIND %NAME(STRNAMED, '\D')
;      R0054		= UPLIT(STRING_LENGTH(STRNAMED), %NAME(STRNAMED)); %;
;	0054	REQUIRE 'STRINGS.REQ';
;	0055	

;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page   2
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (1)

;	0056	LITERAL
;	0057	
;	0058	    MAX_PARAMS	= 1,
;	0059	
;	0060	    DESCR_SIZE	= 2,
;	0061	    XDESCR_SIZE = 3,
;	0062	
;	0063	    TRUE	= 1,
;	0064	    FALSE	= 0,
;	0065	
;	0066	    ON		= 1,
;	0067	    OFF		= 0;
;	0068	
;	0069	LITERAL
;	0070	    VAL_NOWILD	= RMS$_SYN,
;	0071	    DCL_IVDELIM	= %X'38110',
;	0072	    DCL_DIRECT	= %X'38030',
;	0073	    DCL_NOLIST	= %X'380C0',
;	0074	    DCL_NOVALU	= %X'380D0',
;	0075	    DCL_NOKEYW	= %X'380B8',
;	0076	    DCL_IVKEYW	= %X'38060',
;	0077	    DCL_BADVAL	= %X'38060',	! Same as IVKEYW.
;	0078	    DCL_NOTNEG	= %X'380D8',
;	0079	    DCL_INSFPRM	= %X'38048',
;	0080	    DCL_NULFIL	= %X'380E0',
;	0081	    DCL_MAXPARM	= %X'38098';
;	0082	
;	0083	STRUCTURE
;	0084		BBLOCK [O, P, S, E; N] =
;	0085			[N]
;	0086			(BBLOCK+O)<P,S,E>;
;	0087	!
;	0088	! Macro to declare parameter list for TPARSE action routines.
;	0089	!
;	0090	MACRO
;     M 0091		TPARSE_ARGS (NAME) =
;     M 0092			BUILTIN AP;
;     M 0093			BIND NAME = AP : REF BBLOCK;
;	0094			%;
;	0095	
;	0096	FIELD
;	0097	    QUAL_FIELDS =
;	0098		SET
;	0099		SUCC	= [0,0,1,0],
;	0100		FAIL	= [0,1,1,0],
;	0101		ALL	= [0,0,2,0],
;	0102		BRIEF	= [0,2,1,0]
;	0103		TES,
;	0104	
;	0105	    XDESCR_FIELDS =
;	0106		SET
;	0107		COUNT	= [0,0,16,0],
;	0108		DTYPE	= [0,16,8,0],
;	0109		CLASS	= [0,24,8,0],
;	0110		ADDRESS	= [1,0,32,0],
;	0111		POINTER	= [2,0,32,0]

;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page   3
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (1)

;	0112		TES;
;	0113	
;	0114	MACRO
;	0115	    DESCR = BLOCK[DESCR_SIZE] FIELD(XDESCR_FIELDS) %;
;	0116	MACRO
;	0117	    XDESCR = BLOCK[XDESCR_SIZE] FIELD(XDESCR_FIELDS) %;
;	0118	MACRO
;	0119	    DYNAMIC = 2^24 OR DSC$K_DTYPE_T^16 %;
;	0120	
;	0121	FORWARD ROUTINE
;	0122	    TELL,
;	0123	    PROMPT;
;	0124	
;	0125	OWN
;	0126	    PARSE_ERROR,
;	0127	    QUAL_FLAGS	: BLOCK[1] FIELD(QUAL_FIELDS),
;	0128	    PARAM_COUNT,
;	0129	    RAWBUF	: VECTOR[NAM$C_MAXRSS, BYTE],
;	0130	    PARSED	: VECTOR[NAM$C_MAXRSS, BYTE],
;	0131	    NAMEBUF	: VECTOR[NAM$C_MAXRSS, BYTE],
;     P 0132	    ANAM	: $NAM(
;     P 0133				ESA=PARSED,
;     P 0134				ESS=NAM$C_MAXRSS,
;     P 0135				RSA=NAMEBUF,
;     P 0136				RSS=NAM$C_MAXRSS
;	0137				),
;     P 0138	    AFAB	: $FAB(    ! B_FNS is set in CNT_PARM
;     P 0139				FNA=NAMEBUF,
;     P 0140				NAM=ANAM
;	0141				), ! Fields B_DNS & L_DNA may be set in SET_DEF
;	0142	
;	0143	    TPARSE_BLOCK	: BBLOCK [TPA$K_LENGTH0]
;	0144				  INITIAL (TPA$K_COUNT0, 2^24);
;	0145	
;	0146	GLOBAL ROUTINE VALIDATE (START_ADD, CLI_CALLBACK) =
;	0147	BEGIN
;	0148	
;	0149	    OWN
;	0150		PUTMSGVEC	: VECTOR[3]
;	0151				  INITIAL(15^16 OR 2),
;	0152		GET_CMD		: $CLIREQDESC (RQTYPE = GETCMD);
;	0153	
;	0154	    PDSLIT (FACILITY, 'VALIDATE');
;	0155	    PSLIT (FOUND, ' File found: ');
;	0156	    PSLIT (NOT_FOUND, ' File not found: ');
;	0157	    PSLIT (SPEC_ERR, ' File specification error in: ');
;	0158	
;	0159	    EXTERNAL
;	0160		CLI_STB		: VECTOR [0],
;	0161		CLI_KTB		: VECTOR [0];
;	0162	
;	0163	    EXTERNAL ROUTINE
;	0164		LIB$TPARSE;
;	0165	
;	0166	    REGISTER
;	0167		STATUS;

;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page   4
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (1)

;	0168	
;	0169	    LOCAL
;	0170		TELL_FN,
;	0171		TELL_FNL;
;	0172	
;	0173	    (.CLI_CALLBACK) (GET_CMD);
;	0174	    TPARSE_BLOCK[TPA$L_STRINGCNT] = .GET_CMD[CLI$W_RQSIZE];
;	0175	    TPARSE_BLOCK[TPA$L_STRINGPTR] = .GET_CMD[CLI$A_RQADDR];
;	0176	    TPARSE_BLOCK[TPA$V_ABBREV] = ON;
;	0177	    STATUS = LIB$TPARSE (TPARSE_BLOCK, CLI_STB, CLI_KTB);
;	0178	    IF .PARSE_ERROR NEQ 0 THEN STATUS = .PARSE_ERROR;
;	0179	    IF .STATUS THEN IF .PARAM_COUNT EQL 0 THEN STATUS = PROMPT();
;	0180	    IF .STATUS	!  Else there was an error in parsing, or perhaps no file name
;	0181	!		!  (especially likely in batch mode).
;	0182	    THEN
;	0183		BEGIN
;	0184		STATUS = $PARSE(FAB=AFAB);
;	0185	
;	0186	!	Show the user the best version of the file name possible.
;	0187	!	The file name is put into Namebuf by Tparse, then into Parsed by
;	0188	!	$Parse (if it is successfull, and for some error conditions), then
;	0189	!	into Namebuf by $Search if it is successfull.  Note that that if the
;	0190	!	name is in Namebuf, the length may be in either the FAB or the NAM
;	0191	!	block.
;	0192	
;	0193		IF .ANAM[NAM$B_ESL] EQL 0
;	0194		THEN
;	0195		    BEGIN
;	0196		    TELL_FN = NAMEBUF;
;	0197		    TELL_FNL = .AFAB[FAB$B_FNS]
;	0198		    END
;	0199		ELSE
;	0200		    BEGIN
;	0201		    TELL_FN = PARSED;
;	0202		    TELL_FNL = .ANAM[NAM$B_ESL]
;	0203		    END;
;	0204		IF (   .STATUS EQL RMS$_NORMAL
;	0205		    OR .STATUS EQL RMS$_DNF	! These two errors result in severity
;	0206		    OR .STATUS EQL RMS$_DNR)	! of Informational, because they are
;	0207	!					! very close to file-not-found.
;	0208		THEN
;	0209		    BEGIN
;	0210		    IF .STATUS EQL RMS$_NORMAL THEN STATUS = $SEARCH(FAB=AFAB);
;	0211		    IF .STATUS	! Now we see if the caller wants the result logged.
;	0212		    THEN
;	0213			BEGIN
;	0214			STATUS = SS$_NORMAL;	! Instead of RMS$_SUCCESS
;	0215			IF .QUAL_FLAGS[SUCC]
;	0216			THEN TELL(NAMEBUF, .ANAM[NAM$B_RSL],
;	0217				  FOUND, STRING_LENGTH(FOUND),
;	0218				  .QUAL_FLAGS[BRIEF])
;	0219			END
;	0220		    ELSE   ! STATUS from $Search was bad, or we had DNF or DNR.
;	0221			BEGIN
;	0222			STATUS<0,3,0> = 3;	! Severity = Information
;	0223			IF .QUAL_FLAGS[FAIL]

;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page   5
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (1)

;	0224			THEN
;	0225			    BEGIN
;	0226			    TELL(.TELL_FN, .TELL_FNL,
;	0227				 NOT_FOUND, STRING_LENGTH(NOT_FOUND),
;	0228				 .QUAL_FLAGS[BRIEF]);
;	0229			    PUTMSGVEC[1] = .STATUS;
;	0230			    PUTMSGVEC[2] = .AFAB[FAB$L_STV];
;	0231			    $PUTMSG(MSGVEC=PUTMSGVEC, FACNAM=DESCRIPTOR(FACILITY))
;	0232			    END
;	0233			END
;	0234		    END
;	0235		ELSE
;	0236		    BEGIN
;	0237		    STATUS<0,3,0> = 0;	! Severity = Warn
;	0238		    TELL(.TELL_FN, .TELL_FNL,
;	0239			  SPEC_ERR, STRING_LENGTH(SPEC_ERR), OFF) ! i.e. BRIEF = OFF
;	0240		    END
;	0241		END;
;	0242	    RETURN .STATUS
;	0243	END;


	.TITLE  VALIDATE

	.PSECT  $PLIT$,NOWRT,NOEXE,2

P.AAA:	.ASCII  \VALIDATE\			     ;									      ;
P.AAB:	.LONG   8				     ;									      ;
	.ADDRESS S\1				     ;									      ;
P.AAC:	.ASCII  \ File found: \			     ;									      ;
P.AAD:	.ASCII  \ File not found: \		     ;									      ;
P.AAE:	.ASCII  \ File specification error in: \     ;									      ;

	.PSECT  $OWN$,NOEXE,2

PARSE_ERROR:
	.BLKB   4
QUAL_FLAGS:
	.BLKB   4
PARAM_COUNT:
	.BLKB   4
RAWBUF: .BLKB   128
PARSED: .BLKB   128
NAMEBUF:.BLKB   128
ANAM:	.BYTE   2				     ;									      ;
	.BYTE   56				     ;									      ;
	.BYTE   -128				     ;									      ;
	.BYTE   0				     ;									      ;
	.ADDRESS NAMEBUF			     ;									      ;
	.WORD   0				     ;									      ;
	.BYTE   -128				     ;									      ;
	.BYTE   0				     ;									      ;
	.ADDRESS PARSED				     ;									      ;
	.LONG   0				     ;									      ;
	.WORD   0[8]				     ;									      ;
	.WORD   0[3]				     ;									      ;

;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page   6
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (1)

	.WORD   0[3]				     ;									      ;
	.LONG   0				     ;									      ;
	.LONG   0				     ;									      ;
AFAB:	.BYTE   3				     ;									      ;
	.BYTE   80				     ;									      ;
	.WORD   0				     ;									      ;
	.LONG   0				     ;									      ;
	.LONG   0				     ;									      ;
	.LONG   0				     ;									      ;
	.LONG   0				     ;									      ;
	.WORD   0				     ;									      ;
	.BYTE   2				     ;									      ;
	.BYTE   0				     ;									      ;
	.LONG   0				     ;									      ;
	.BYTE   0				     ;									      ;
	.BYTE   0				     ;									      ;
	.BYTE   0				     ;									      ;
	.BYTE   2				     ;									      ;
	.LONG   0				     ;									      ;
	.LONG   0				     ;									      ;
	.ADDRESS ANAM				     ;									      ;
	.ADDRESS NAMEBUF			     ;									      ;
	.LONG   0				     ;									      ;
	.BYTE   0				     ;									      ;
	.BYTE   0				     ;									      ;
	.WORD   0				     ;									      ;
	.LONG   0				     ;									      ;
	.WORD   0				     ;									      ;
	.BYTE   0				     ;									      ;
	.BYTE   0				     ;									      ;
	.LONG   0				     ;									      ;
	.LONG   0				     ;									      ;
	.LONG   0[2]				     ;									      ;
TPARSE_BLOCK:
	.LONG   8, 33554432			     ;									      ;
	.BLKB   28
PUTMSGVEC:
	.LONG   983042				     ;									      ;
	.BLKB   8
GET_CMD:.BYTE   1				     ;									      ;
	.BYTE   0				     ;									      ;
	.BYTE   0				     ;									      ;
	.BYTE   0				     ;									      ;
	.LONG   0				     ;									      ;
	.LONG   0, 0				     ;									      ;
	.LONG   0				     ;									      ;
	.LONG   0				     ;									      ;
	.LONG   0				     ;									      ;

S\1=		    P.AAA
S\1\D=		    P.AAB
S\2=		    P.AAC
S\3=		    P.AAD
S\4=		    P.AAE
	.EXTRN  CLI_STB, CLI_KTB, LIB$TPARSE, SYS$PARSE, SYS$SEARCH, SYS$PUTMSG


;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page   7
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (1)

	.PSECT  $CODE$,NOWRT,2

	.ENTRY  VALIDATE, ^M<R2,R3,R4,R5>	     ;VALIDATE, Save R2,R3,R4,R5					      ; 0146
	MOVAB   W^QUAL_FLAGS, R5		     ;QUAL_FLAGS, R5							      ;
	PUSHAB  576(R5)				     ;GET_CMD								      ; 0173
	CALLS   #1, @8(AP)			     ;#1, @CLI_CALLBACK							      ;
	MOVZWL  584(R5), 536(R5)		     ;GET_CMD+8, TPARSE_BLOCK+8						      ; 0174
	MOVL    588(R5), 540(R5)		     ;GET_CMD+12, TPARSE_BLOCK+12					      ; 0175
	BISB2   #2, 532(R5)			     ;#2, TPARSE_BLOCK+4						      ; 0176
	PUSHAB  W^CLI_KTB			     ;CLI_KTB								      ; 0177
	PUSHAB  W^CLI_STB			     ;CLI_STB								      ;
	PUSHAB  528(R5)				     ;TPARSE_BLOCK							      ;
	CALLS   #3, W^LIB$TPARSE		     ;#3, LIB$TPARSE							      ;
	MOVL    R0, R2				     ;R0, STATUS							      ;
	MOVL    -4(R5), R0			     ;PARSE_ERROR, R0							      ; 0178
	BEQL    1$				     ;1$								      ;
	MOVL    R0, R2				     ;R0, STATUS							      ;
1$:	BLBC    R2, 2$				     ;STATUS, 2$							      ; 0179
	TSTL    4(R5)				     ;PARAM_COUNT							      ;
	BNEQ    2$				     ;2$								      ;
	CALLS   #0, W^PROMPT			     ;#0, PROMPT							      ;
	MOVL    R0, R2				     ;R0, STATUS							      ;
2$:	BLBS    R2, 3$				     ;STATUS, 3$							      ; 0180
	BRW     12$				     ;12$								      ;
3$:	PUSHAB  448(R5)				     ;AFAB								      ; 0184
	CALLS   #1, @#SYS$PARSE			     ;#1, @#SYS$PARSE							      ;
	MOVL    R0, R2				     ;R0, STATUS							      ;
	MOVZBL  403(R5), R0			     ;ANAM+11, R0							      ; 0193
	BNEQ    4$				     ;4$								      ;
	MOVAB   264(R5), R4			     ;NAMEBUF, TELL_FN							      ; 0196
	MOVZBL  500(R5), R3			     ;AFAB+52, TELL_FNL							      ; 0197
	BRB     5$				     ;5$								      ; 0193
4$:	MOVAB   136(R5), R4			     ;PARSED, TELL_FN							      ; 0201
	MOVL    R0, R3				     ;R0, TELL_FNL							      ; 0202
5$:	CLRL    R0				     ;R0								      ; 0204
	CMPL    R2, #65537			     ;STATUS, #65537							      ;
	BNEQ    6$				     ;6$								      ;
	INCL    R0				     ;R0								      ;
	BRB     7$				     ;7$								      ;
6$:	CMPL    R2, #114762			     ;STATUS, #114762							      ; 0205
	BEQL    7$				     ;7$								      ;
	CMPL    R2, #98930			     ;STATUS, #98930							      ; 0206
	BNEQ    10$				     ;10$								      ;
7$:	BLBC    R0, 8$				     ;R0, 8$								      ; 0210
	PUSHAB  448(R5)				     ;AFAB								      ;
	CALLS   #1, @#SYS$SEARCH		     ;#1, @#SYS$SEARCH							      ;
	MOVL    R0, R2				     ;R0, STATUS							      ;
8$:	BLBC    R2, 9$				     ;STATUS, 9$							      ; 0211
	MOVL    #1, R2				     ;#1, STATUS							      ; 0214
	BLBC    (R5), 12$			     ;QUAL_FLAGS, 12$							      ; 0215
	EXTZV   #2, #1, (R5), -(SP)		     ;#2, #1, QUAL_FLAGS, -(SP)						      ; 0216
	PUSHL   #13				     ;#13								      ;
	PUSHAB  W^S\2				     ;S\2								      ;
	MOVZBL  395(R5), -(SP)			     ;ANAM+3, -(SP)							      ;
	PUSHAB  264(R5)				     ;NAMEBUF								      ;
	BRB     11$				     ;11$								      ;

;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page   8
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (1)

9$:	INSV    #3, #0, #3, R2			     ;#3, #0, #3, STATUS						      ; 0222
	BBC     #1, (R5), 12$			     ;#1, QUAL_FLAGS, 12$						      ; 0223
	EXTZV   #2, #1, (R5), -(SP)		     ;#2, #1, QUAL_FLAGS, -(SP)						      ; 0226
	PUSHL   #17				     ;#17								      ;
	PUSHAB  W^S\3				     ;S\3								      ;
	PUSHL   R3				     ;TELL_FNL								      ;
	PUSHL   R4				     ;TELL_FN								      ;
	CALLS   #5, W^TELL			     ;#5, TELL								      ;
	MOVL    R2, 568(R5)			     ;STATUS, PUTMSGVEC+4						      ; 0229
	MOVL    460(R5), 572(R5)		     ;AFAB+12, PUTMSGVEC+8						      ; 0230
	PUSHAB  W^S\1\D				     ;S\1\D								      ; 0231
	CLRL    -(SP)				     ;-(SP)								      ;
	PUSHAB  564(R5)				     ;PUTMSGVEC								      ;
	CALLS   #3, @#SYS$PUTMSG		     ;#3, @#SYS$PUTMSG							      ;
	BRB     12$				     ;12$								      ; 0204
10$:	BICB2   #7, R2				     ;#7, STATUS							      ; 0237
	MOVQ    #30, -(SP)			     ;#30, -(SP)							      ; 0238
	PUSHAB  W^S\4				     ;S\4								      ;
	PUSHL   R3				     ;TELL_FNL								      ;
	PUSHL   R4				     ;TELL_FN								      ;
11$:	CALLS   #5, W^TELL			     ;#5, TELL								      ;
12$:	MOVL    R2, R0				     ;STATUS, R0							      ; 0242
	RET     				     ;									      ; 0146

; Routine Size:  290 bytes


;	0244	
;	0245	ROUTINE PROMPT =
;	0246	BEGIN
;	0247	
;	0248	    OWN
;	0249		RESULT : DESCR INITIAL(DYNAMIC);
;	0250	
;	0251	    REGISTER
;	0252		STATUS;
;	0253	
;	0254	    EXTERNAL
;	0255		CLI_STB		: VECTOR [0],
;	0256		CLI_KTB		: VECTOR [0];
;	0257	
;	0258	    EXTERNAL ROUTINE
;	0259		OTS$SFREE1_DD,
;	0260		LIB$TPARSE,
;	0261		LIB$GET_COMMAND;
;	0262	
;	0263	    PDSLIT (PROMPT_STR, ' File: ');
;	0264	
;	0265	    DO
;	0266		STATUS = LIB$GET_COMMAND(RESULT, DESCRIPTOR(PROMPT_STR))
;	0267	    UNTIL (IF .STATUS THEN  .RESULT[COUNT] GTR 0  ELSE TRUE);
;	0268	    IF .STATUS EQL RMS$_EOF THEN (STATUS = DCL_INSFPRM)
;	0269	    ELSE IF .STATUS
;	0270	    THEN
;	0271		BEGIN
;	0272		TPARSE_BLOCK[TPA$L_STRINGCNT] = .RESULT[COUNT];

;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page   9
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (1)

;	0273		TPARSE_BLOCK[TPA$L_STRINGPTR] = .RESULT[ADDRESS];
;	0274		STATUS = LIB$TPARSE (TPARSE_BLOCK, CLI_STB, CLI_KTB);
;	0275		OTS$SFREE1_DD(RESULT);
;	0276		IF .PARSE_ERROR NEQ 0 THEN STATUS = .PARSE_ERROR;
;	0277		IF .STATUS THEN IF .PARAM_COUNT EQL 0 THEN STATUS = DCL_NULFIL
;	0278		END;
;	0279	    RETURN .STATUS
;	0280	END;



	.PSECT  $PLIT$,NOWRT,NOEXE,2

P.AAF:	.ASCII  \ File: \			     ;									      ;
	.BLKB   1
P.AAG:	.LONG   7				     ;									      ;
	.ADDRESS S\5				     ;									      ;

	.PSECT  $OWN$,NOEXE,2

RESULT: .LONG   34471936			     ;									      ;
	.BLKB   4

S\5=		    P.AAF
S\5\D=		    P.AAG
	.EXTRN  OTS$SFREE1_DD, LIB$GET_COMMAND

	.PSECT  $CODE$,NOWRT,2

PROMPT: .WORD   ^M<R2,R3>			     ;Save R2,R3							      ; 0245
	MOVAB   W^RESULT, R3			     ;RESULT, R3							      ;
1$:	PUSHAB  W^S\5\D				     ;S\5\D								      ; 0266
	PUSHL   R3				     ;R3								      ;
	CALLS   #2, W^LIB$GET_COMMAND		     ;#2, LIB$GET_COMMAND						      ;
	MOVL    R0, R2				     ;R0, STATUS							      ;
	BLBC    R2, 2$				     ;STATUS, 2$							      ; 0267
	TSTW    (R3)				     ;RESULT								      ;
	BLEQU   1$				     ;1$								      ;
2$:	CMPL    R2, #98938			     ;STATUS, #98938							      ; 0268
	BNEQ    3$				     ;3$								      ;
	MOVL    #229448, R2			     ;#229448, STATUS							      ;
	BRB     5$				     ;5$								      ;
3$:	BLBC    R2, 5$				     ;STATUS, 5$							      ; 0269
	MOVZWL  (R3), -68(R3)			     ;RESULT, TPARSE_BLOCK+8						      ; 0272
	MOVL    4(R3), -64(R3)			     ;RESULT+4, TPARSE_BLOCK+12						      ; 0273
	PUSHAB  W^CLI_KTB			     ;CLI_KTB								      ; 0274
	PUSHAB  W^CLI_STB			     ;CLI_STB								      ;
	PUSHAB  -76(R3)				     ;TPARSE_BLOCK							      ;
	CALLS   #3, W^LIB$TPARSE		     ;#3, LIB$TPARSE							      ;
	MOVL    R0, R2				     ;R0, STATUS							      ;
	PUSHL   R3				     ;R3								      ; 0275
	CALLS   #1, W^OTS$SFREE1_DD		     ;#1, OTS$SFREE1_DD							      ;
	MOVL    -608(R3), R0			     ;PARSE_ERROR, R0							      ; 0276
	BEQL    4$				     ;4$								      ;
	MOVL    R0, R2				     ;R0, STATUS							      ;
4$:	BLBC    R2, 5$				     ;STATUS, 5$							      ; 0277

;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page  10
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (1)

	TSTL    -600(R3)			     ;PARAM_COUNT							      ;
	BNEQ    5$				     ;5$								      ;
	MOVL    #229600, R2			     ;#229600, STATUS							      ;
5$:	MOVL    R2, R0				     ;STATUS, R0							      ; 0279
	RET     				     ;									      ; 0245

; Routine Size:  114 bytes


;	0281	
;	0282	
;	0283	ROUTINE TELL (FNAM, FNAM_LEN, PREFIX, PREFIX_LEN, BRIEF_FLAG) =
;	0284	BEGIN
;	0285	
;	0286	    LOCAL
;	0287		MESSAGE : DESCR;
;	0288	
;	0289	    REGISTER
;	0290		RSZ;
;	0291	
;	0292	    EXTERNAL ROUTINE
;	0293		LIB$PUT_OUTPUT;
;	0294	
;	0295	    IF .BRIEF_FLAG
;	0296	    THEN	! Setup to send only file name as message.
;	0297		BEGIN
;	0298		MESSAGE[COUNT] = .FNAM_LEN;
;	0299		MESSAGE[ADDRESS] = .FNAM
;	0300		END
;	0301	    ELSE	! Put label and file name into message.
;	0302		BEGIN
;	0303		RSZ = .PREFIX_LEN + .FNAM_LEN;
;	0304		CH$COPY( .PREFIX_LEN, CH$PTR(.PREFIX),
;	0305			 .FNAM_LEN, CH$PTR(.FNAM),
;	0306			 %C' ', .RSZ, CH$PTR(RAWBUF));
;	0307		MESSAGE[COUNT] = .RSZ;
;	0308		MESSAGE[ADDRESS] = RAWBUF
;	0309		END;
;	0310	
;	0311	!	Now send the message.
;	0312	
;	0313	    LIB$PUT_OUTPUT(MESSAGE)
;	0314	END;



	.EXTRN  LIB$PUT_OUTPUT

TELL:	.WORD   ^M<R2,R3,R4,R5,R6,R7,R8>	     ;Save R2,R3,R4,R5,R6,R7,R8						      ; 0283
	SUBL2   #8, SP				     ;#8, SP								      ;
	BLBC    20(AP), 1$			     ;BRIEF_FLAG, 1$							      ; 0295
	MOVW    8(AP), (SP)			     ;FNAM_LEN, MESSAGE							      ; 0298
	MOVL    4(AP), 4(SP)			     ;FNAM, MESSAGE+4							      ; 0299
	BRB     3$				     ;3$								      ; 0295
1$:	ADDL3   8(AP), 16(AP), R6		     ;FNAM_LEN, PREFIX_LEN, RSZ						      ; 0303
	MOVL    R6, R8				     ;RSZ, R8								      ; 0306

;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page  11
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (1)

	MOVAB   W^RAWBUF, R7			     ;RAWBUF, R7							      ;
	MOVC5   16(AP), @12(AP), #32, R8, (R7)	     ;PREFIX_LEN, @PREFIX, #32, R8, (R7)				      ; 0304
	BGEQ    2$				     ;2$								      ;
	ADDL2   16(AP), R7			     ;PREFIX_LEN, R7							      ;
	SUBL2   16(AP), R8			     ;PREFIX_LEN, R8							      ;
	MOVC5   8(AP), @4(AP), #32, R8, (R7)	     ;FNAM_LEN, @FNAM, #32, R8, (R7)					      ;
2$:	MOVW    R6, (SP)			     ;RSZ, MESSAGE							      ; 0307
	MOVAB   W^RAWBUF, 4(SP)			     ;RAWBUF, MESSAGE+4							      ; 0308
3$:	PUSHL   SP				     ;SP								      ; 0313
	CALLS   #1, W^LIB$PUT_OUTPUT		     ;#1, LIB$PUT_OUTPUT						      ;
	RET     				     ;									      ; 0283

; Routine Size:  77 bytes



;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page  12
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (2)

;	0315	!		LIB$TPARSE SECTION
;	0316	!		********** *******
;	0317	
;	0318	!	There are two sets of LIB$TPARSE states, i.e. two $INIT_STATE macro
;	0319	!	calls.  The first is for the scan of the command line and/or the
;	0320	!	response to prompting.  The second is called from the action routines
;	0321	!	of the first, and is for parsing a file name, which may be the (only)
;	0322	!	parameter or a /DEFAULT= spec.
;	0323	
;	0324	!	Action routines used by both parsers --
;	0325	
;	0326	ROUTINE SAVEPUNC =
;	0327	BEGIN
;	0328	
;	0329	    TPARSE_ARGS(TPA);
;	0330	
;	0331	    BIND
;	0332		TARGET = TPA[TPA$L_PARAM] : REF XDESCR;
;	0333	
;	0334	    TARGET[POINTER] = CH$MOVE(1, CH$PTR(TPA[TPA$L_CHAR]), .TARGET[POINTER]);
;	0335	    TARGET[COUNT] = .TARGET[COUNT] + 1;
;	0336	    RETURN SS$_NORMAL
;	0337	END;





SAVEPUNC:
	.WORD   ^M<R2,R3,R4,R5,R6>		     ;Save R2,R3,R4,R5,R6						      ; 0326
	MOVAB   32(AP), R0			     ;32(AP), R0							      ; 0332
	MOVL    (R0), R6			     ;(R0), R6								      ; 0334
	MOVC3   #1, 24(AP), @8(R6)		     ;#1, 24(TPA), @8(R6)						      ;
	MOVL    R3, 8(R6)			     ;R3, 8(R6)								      ;
	INCW    (R6)				     ;(R6)								      ; 0335
	MOVL    #1, R0				     ;#1, R0								      ; 0336
	RET     				     ;									      ; 0326

; Routine Size:  25 bytes


;	0338	
;	0339	ROUTINE SAVESYM =
;	0340	BEGIN
;	0341	
;	0342	    TPARSE_ARGS(TPA);
;	0343	
;	0344	    BIND
;	0345		TARGET = TPA[TPA$L_PARAM] : REF XDESCR;
;	0346	
;	0347	    TARGET[COUNT] = .TARGET[COUNT] + .TPA[TPA$L_TOKENCNT];
;	0348	    TARGET[POINTER] = CH$MOVE(.TPA[TPA$L_TOKENCNT],
;	0349			      CH$PTR(.TPA[TPA$L_TOKENPTR]),
;	0350			    .TARGET[POINTER]);
;	0351	    RETURN SS$_NORMAL

;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page  13
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (2)

;	0352	END;





SAVESYM:.WORD   ^M<R2,R3,R4,R5,R6>		     ;Save R2,R3,R4,R5,R6						      ; 0339
	MOVAB   32(AP), R0			     ;32(AP), R0							      ; 0345
	MOVL    (R0), R6			     ;(R0), R6								      ; 0347
	ADDW2   16(AP), (R6)			     ;16(TPA), (R6)							      ;
	MOVC3   16(AP), @20(AP), @8(R6)		     ;16(TPA), @20(TPA), @8(R6)						      ; 0348
	MOVL    R3, 8(R6)			     ;R3, 8(R6)								      ;
	MOVL    #1, R0				     ;#1, R0								      ; 0351
	RET     				     ;									      ; 0339

; Routine Size:  28 bytes


;	0353	
;	0354	!	Action routines for initial scan only --
;	0355	
;	0356	ROUTINE BLANKS_ON: NOVALUE =
;	0357	BEGIN
;	0358	
;	0359	    TPARSE_ARGS(TPA);
;	0360	
;	0361	    TPA[TPA$V_BLANKS] = ON
;	0362	END;





BLANKS_ON:
	.WORD   ^M<>				     ;Save nothing							      ; 0356
	BISB2   #1, 4(AP)			     ;#1, 4(TPA)							      ; 0361
	RET     				     ;									      ; 0356

; Routine Size:  7 bytes


;	0363	
;	0364	ROUTINE BLANKS_OFF: NOVALUE =
;	0365	BEGIN
;	0366	
;	0367	    TPARSE_ARGS(TPA);
;	0368	
;	0369	    TPA[TPA$V_BLANKS] = OFF
;	0370	END;





BLANKS_OFF:
	.WORD   ^M<>				     ;Save nothing							      ; 0364

;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page  14
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (2)

	BICB2   #1, 4(AP)			     ;#1, 4(TPA)							      ; 0369
	RET     				     ;									      ; 0364

; Routine Size:  7 bytes


;	0371	
;	0372	!		Routines called to clear bits set by TPARSE maskaddr/mask
;	0373	
;	0374	ROUTINE NO_LOG: NOVALUE =
;	0375	    QUAL_FLAGS[ALL] = 0;





NO_LOG: .WORD   ^M<>				     ;Save nothing							      ; 0374
	BICB2   #3, W^QUAL_FLAGS		     ;#3, QUAL_FLAGS							      ; 0375
	RET     				     ;									      ; 0374

; Routine Size:  8 bytes


;	0376	
;	0377	ROUTINE NO_BR: NOVALUE =
;	0378	    QUAL_FLAGS[BRIEF] = 0;





NO_BR:	.WORD   ^M<>				     ;Save nothing							      ; 0377
	BICB2   #4, W^QUAL_FLAGS		     ;#4, QUAL_FLAGS							      ; 0378
	RET     				     ;									      ; 0377

; Routine Size:  8 bytes


;	0379	
;	0380	ROUTINE IVDELIM: NOVALUE =	! Last gasp error message.
;	0381	    IF .PARSE_ERROR EQL 0 THEN PARSE_ERROR = DCL_IVDELIM;





IVDELIM:.WORD   ^M<>				     ;Save nothing							      ; 0380
	TSTL    W^PARSE_ERROR			     ;PARSE_ERROR							      ; 0381
	BNEQ    1$				     ;1$								      ;
	MOVL    #229648, W^PARSE_ERROR		     ;#229648, PARSE_ERROR						      ;
1$:	RET     				     ;									      ; 0380

; Routine Size:  18 bytes


;	0382	    

;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page  15
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (2)

;	0383	
;	0384	!	Variables declared in the outer-most block, but not needed until
;	0385	!	this point (i. e. used only while parsing).
;	0386	OWN
;	0387	    COLON_FLAG,
;	0388	    DEFAULTBUF	: VECTOR[NAM$C_MAXRSS, BYTE],
;	0389	    RAWDESCR	: XDESCR
;	0390			  INITIAL(0, RAWBUF, CH$PTR(RAWBUF)),
;	0391	    NAME	: XDESCR,	! Descriptor of name string found by LIB$TPARSE
;	0392	    NAME_TMP	: XDESCR;
;	0393	
;	0394	
;	0395	
;	0396	!	TPARSE action routine to parse a string to check for legitimate file
;	0397	!	name.  LIB$TPARSE is called again to do the parsing.  Any logical name
;	0398	!	translations necessary will be done by TRNLOG, called as an action
;	0399	!	routine by LIB$TPARSE.
;	0400	!
;	0401	!	The string to be parsed may be a parameter or follow /DEF=
;	0402	!
;	0403	!	Arguments:
;	0404	!	    Standard calling sequence from LIB$TPARSE, with the "parameter"
;	0405	!	    of the transition macro set to the address of a vector specific
;	0406	!	    to the source of the string.  This value is passed into CHECK as
;	0407	!	    .TPA[TPA$L_PARAM].  The vector pointed to contains:
;	0408	!		- The address of the buffer in which to place the successfully
;	0409	!		  parsed/expanded string.
;	0410	!		- The address of a routine for CHECK to call to record that the
;	0411	!		  string has been successfully parsed, and in the case of a
;	0412	!		  parameter, to check that the maximum parameter count is not
;	0413	!		  exceeded.
;	0414	!	    Implicitly, the string to be parsed is described by RAWDESCR.
;	0415	!
;	0416	ROUTINE CHECK =
;	0417	BEGIN
;	0418	
;	0419	    TPARSE_ARGS(TPA);
;	0420	
;	0421	    BIND
;	0422		ARGS	= TPA[TPA$L_PARAM] : REF VECTOR[2];
;	0423	
;	0424	    OWN
;	0425		TPARSE_BLOCK	: BBLOCK [TPA$K_LENGTH0]
;	0426				  INITIAL (TPA$K_COUNT0, 2^24);
;	0427	
;	0428	    EXTERNAL
;	0429		FSPEC_STB	: VECTOR [0],
;	0430		FSPEC_KTB	: VECTOR [0];
;	0431	
;	0432	    EXTERNAL ROUTINE
;	0433		LIB$TPARSE;
;	0434	
;	0435	    REGISTER
;	0436		STATUS;
;	0437	
;	0438	!	NAME is an extended descriptor of the resultant string of LIB$TPARSE

;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page  16
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (2)

;	0439	!	Its address is passed to various action routines by the TPARSE 
;	0440	!	transitions.  It is also known to Routine TRNLOG.
;	0441	    NAME[COUNT] = 0;
;	0442	    NAME[ADDRESS] = .ARGS[0];
;	0443	    NAME[POINTER] = CH$PTR(.NAME[ADDRESS]);
;	0444	!	NAME_TMP is an auxiliary extended descriptor of the resultant string,
;	0445	!	used as in sub-states which may need to be unwound.
;	0446	    NAME_TMP[COUNT] = 0;
;	0447	    NAME_TMP[ADDRESS] = .ARGS[0];
;	0448	    NAME_TMP[POINTER] = .NAME[POINTER];
;	0449	    TPARSE_BLOCK[TPA$L_STRINGCNT] = .RAWDESCR[COUNT];
;	0450	    TPARSE_BLOCK[TPA$L_STRINGPTR] = .RAWDESCR[ADDRESS];
;	0451	    STATUS = LIB$TPARSE (TPARSE_BLOCK, FSPEC_STB, FSPEC_KTB);
;	0452	    IF .PARSE_ERROR NEQ 0 THEN STATUS = .PARSE_ERROR;
;	0453	!	If successfull to this point, call the auxiliary (completion)
;	0454	!	routine whose address was passed in the argument vector of the
;	0455	!	transition which called CHECK.
;	0456	    IF .STATUS THEN STATUS = (.ARGS[1]) ();
;	0457	!	Empty RAWDESCR
;	0458	    RAWDESCR[COUNT] = 0;
;	0459	    RAWDESCR[POINTER] = CH$PTR(.RAWDESCR[ADDRESS]);
;	0460	    RETURN .STATUS
;	0461	END;



	.PSECT  $OWN$,NOEXE,2

COLON_FLAG:
	.BLKB   4
DEFAULTBUF:
	.BLKB   128
RAWDESCR:
	.LONG   0				     ;									      ;
	.ADDRESS RAWBUF, RAWBUF			     ;									      ;
NAME:	.BLKB   12
NAME_TMP:
	.BLKB   12
TPARSE_BLOCK:
; INFO#192
; Multiple declaration of name in assembly source:  TPARSE_BLOCK
	.LONG   8, 33554432			     ;									      ;
	.BLKB   28

	.EXTRN  FSPEC_STB, FSPEC_KTB

	.PSECT  $CODE$,NOWRT,2

CHECK:	.WORD   ^M<R2,R3,R4>			     ;Save R2,R3,R4							      ; 0416
	MOVAB   W^NAME+4, R4			     ;NAME+4, R4							      ;
	MOVAB   32(AP), R0			     ;32(AP), R0							      ; 0422
	CLRW    -4(R4)				     ;NAME								      ; 0441
	MOVL    (R0), R3			     ;(R0), R3								      ; 0442
	MOVL    (R3), (R4)			     ;(R3), NAME+4							      ;
	MOVL    (R4), 4(R4)			     ;NAME+4, NAME+8							      ; 0443
	CLRW    8(R4)				     ;NAME_TMP								      ; 0446

;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page  17
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (2)

	MOVL    (R3), 12(R4)			     ;(R3), NAME_TMP+4							      ; 0447
	MOVL    4(R4), 16(R4)			     ;NAME+8, NAME_TMP+8						      ; 0448
	MOVZWL  -16(R4), 28(R4)			     ;RAWDESCR, TPARSE_BLOCK+8						      ; 0449
	MOVL    -12(R4), 32(R4)			     ;RAWDESCR+4, TPARSE_BLOCK+12					      ; 0450
	PUSHAB  W^FSPEC_KTB			     ;FSPEC_KTB								      ; 0451
	PUSHAB  W^FSPEC_STB			     ;FSPEC_STB								      ;
	PUSHAB  20(R4)				     ;TPARSE_BLOCK							      ;
	CALLS   #3, W^LIB$TPARSE		     ;#3, LIB$TPARSE							      ;
	MOVL    R0, R2				     ;R0, STATUS							      ;
	MOVL    -764(R4), R0			     ;PARSE_ERROR, R0							      ; 0452
	BEQL    1$				     ;1$								      ;
	MOVL    R0, R2				     ;R0, STATUS							      ;
1$:	BLBC    R2, 2$				     ;STATUS, 2$							      ; 0456
	CALLS   #0, @4(R3)			     ;#0, @4(R3)							      ;
	MOVL    R0, R2				     ;R0, STATUS							      ;
2$:	CLRW    -16(R4)				     ;RAWDESCR								      ; 0458
	MOVL    -12(R4), -8(R4)			     ;RAWDESCR+4, RAWDESCR+8						      ; 0459
	MOVL    R2, R0				     ;STATUS, R0							      ; 0460
	RET     				     ;									      ; 0416

; Routine Size:  97 bytes


;	0462	
;	0463	!	Completion routines for CHECK --
;	0464	
;	0465	ROUTINE CNT_PARM =	! For parameter
;	0466	BEGIN
;	0467	    AFAB[FAB$B_FNS] = .NAME[COUNT];
;	0468	    PARAM_COUNT = .PARAM_COUNT+1;
;	0469	    IF (.PARAM_COUNT GTR MAX_PARAMS)
;	0470	    THEN PARSE_ERROR = DCL_MAXPARM
;	0471	    ELSE SS$_NORMAL
;	0472	END;





CNT_PARM:
	.WORD   ^M<>				     ;Save nothing							      ; 0465
	MOVB    W^NAME, W^AFAB+52		     ;NAME, AFAB+52							      ; 0467
	INCL    W^PARAM_COUNT			     ;PARAM_COUNT							      ; 0468
	CMPL    W^PARAM_COUNT, #1		     ;PARAM_COUNT, #1							      ; 0469
	BLEQ    1$				     ;1$								      ;
	MOVL    #229528, W^PARSE_ERROR		     ;#229528, PARSE_ERROR						      ; 0470
	MOVL    #229528, R0			     ;#229528, R0							      ; 0469
	RET     				     ;									      ;
1$:	MOVL    #1, R0				     ;#1, R0								      ;
	RET     				     ;									      ; 0465

; Routine Size:  41 bytes


;	0473	
;	0474	ROUTINE SET_DEF =	! For default string

;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page  18
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (2)

;	0475	BEGIN
;	0476	    AFAB[FAB$B_DNS] = .NAME[COUNT];
;	0477	    AFAB[FAB$L_DNA] = DEFAULTBUF;
;	0478	    RETURN SS$_NORMAL
;	0479	END;





SET_DEF:.WORD   ^M<>				     ;Save nothing							      ; 0474
	MOVB    W^NAME, W^AFAB+53		     ;NAME, AFAB+53							      ; 0476
	MOVAB   W^DEFAULTBUF, W^AFAB+48		     ;DEFAULTBUF, AFAB+48						      ; 0477
	MOVL    #1, R0				     ;#1, R0								      ; 0478
	RET     				     ;									      ; 0474

; Routine Size:  20 bytes


;	0480	
;	0481	!	Argument lists for CHECK
;	0482	
;	0483	OWN
;	0484	    PARAMVEC	: VECTOR[2]
;	0485			  INITIAL(NAMEBUF, CNT_PARM),
;	0486	    DEFVEC	: VECTOR[2]
;	0487			  INITIAL(DEFAULTBUF, SET_DEF);
;	0488	
;	0489	!	Routines for file-spec scan only --
;	0490	
;	0491	ROUTINE MOVPART: NOVALUE =
;	0492	BEGIN
;	0493	
;	0494	    NAME[COUNT] = .NAME[COUNT] + .NAME_TMP[COUNT];
;	0495	    NAME_TMP[COUNT] = 0;
;	0496	    NAME[POINTER] = .NAME_TMP[POINTER]
;	0497	
;	0498	END;



	.PSECT  $OWN$,NOEXE,2

PARAMVEC:
	.ADDRESS NAMEBUF, CNT_PARM		     ;									      ;
DEFVEC: .ADDRESS DEFAULTBUF, SET_DEF		     ;									      ;



	.PSECT  $CODE$,NOWRT,2

MOVPART:.WORD   ^M<R2>				     ;Save R2								      ; 0491
	MOVAB   W^NAME_TMP, R2			     ;NAME_TMP, R2							      ;
	ADDW2   (R2), -12(R2)			     ;NAME_TMP, NAME							      ; 0494
	CLRW    (R2)				     ;NAME_TMP								      ; 0495
	MOVL    8(R2), -4(R2)			     ;NAME_TMP+8, NAME+8						      ; 0496

;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page  19
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (2)

	RET     				     ;									      ; 0491

; Routine Size:  19 bytes


;	0499	
;	0500	ROUTINE CLEAN: NOVALUE =
;	0501	BEGIN
;	0502	
;	0503	    NAME_TMP[COUNT] = 0;
;	0504	    NAME_TMP[POINTER] = .NAME[POINTER]
;	0505	
;	0506	END;





CLEAN:	.WORD   ^M<>				     ;Save nothing							      ; 0500
	CLRW    W^NAME_TMP			     ;NAME_TMP								      ; 0503
	MOVL    W^NAME+8, W^NAME_TMP+8		     ;NAME+8, NAME_TMP+8						      ; 0504
	RET     				     ;									      ; 0500

; Routine Size:  14 bytes


;	0507	
;	0508	
;	0509	ROUTINE TRNLOG =
;	0510	BEGIN
;	0511	
;      R0513	!
;      R0514	! TRANSLATE LOGICAL NAME RECURSIVELY
;      R0515	!
;      R0516	!	LOGNAM	- ADDRESS OF LOGICAL NAME STRING DESCRIPTOR
;      R0517	!	RSLLEN	- ADDRESS OF WORD TO RECEIVE LENGTH OF RESULTANT
;      R0518	!		  NAME STRING
;      R0519	!	RSLBUF	- ADDRESS OF RESULT STRING BUFFER DESCRIPTOR
;      R0520	!	TABLE	- ADDRESS OF BYTE TO STORE TRANSLATION TABLE NUMBER
;      R0521	!	ACMODE	- ADDRESS OF BYTE TO STORE ASSIGNMENT ACCESS MODE
;      R0522	!	DSBMSK  - TABLE SEARCH DISABLE MASK
;      R0523	!
;      R0524	
;      R0525	
;      R0526	
;      R0527	
;     MR0528	KEYWORDMACRO $TRNLOGR(LOGNAM=0,RSLLEN=0,RSLBUF=0,TABLE=0,ACMODE=0,DSBMSK=0)=
;     MR0529	    (
;     MR0530	    EXTERNAL ROUTINE SYS_TRNLOG;
;     MR0531	    SYS_TRNLOG(LOGNAM,RSLLEN,RSLBUF,TABLE,ACMODE,DSBMSK)
;      R0532	    ) %;
;      R0533	
;	0533	    REQUIRE 'HANDY.REQ';
;	0534	
;	0535	!	Does a logical name translation on the current string.
;	0536	!	The translation is recursive on two levels:

;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page  20
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (2)

;	0537	!	    a) Subroutine SYS_TRNLOG does a recursive translation on the
;	0538	!		entire string.
;	0539	!	    b) If the returned string contains a :, then the portion before
;	0540	!		the : is translated by another call to SYS_TRNLOG.
;	0541	!	Finally, if the original string was terminated by a : and the result
;	0542	!	string contains no punctuation, then terminate the result with a : .
;	0543	
;	0544	    REGISTER
;	0545		STATUS;
;	0546	
;	0547	    LOCAL
;	0548		RLEN;
;	0549	
;	0550	    OWN
;	0551		PIECE	: XDESCR,
;	0552		SDESCR	: DESCR,
;	0553		RDESCR	: DESCR,
;	0554		TRN_BUF	: VECTOR[NAM$C_MAXRSS, BYTE];
;	0555	
;	0556	    PIECE[COUNT]	= 0;
;	0557	    SDESCR[COUNT]	= .NAME[COUNT];
;	0558	    RDESCR[COUNT]	= NAM$C_MAXRSS;
;	0559	    SDESCR[ADDRESS]	= .NAME[ADDRESS];
;	0560	    RDESCR[ADDRESS]	= TRN_BUF;
;	0561	    DO  BEGIN
;	0562	!	Call SYS_TRNLOG ---
;	0563		STATUS = $TRNLOGR(LOGNAM=SDESCR, RSLLEN=RLEN, RSLBUF=RDESCR);
;	0564		IF .STATUS EQL SS$_NORMAL
;	0565		THEN
;	0566		    IF (INCR I FROM 1 TO .RLEN-1
;	0567			DO
;	0568			    IF CH$RCHAR(CH$PTR(.RDESCR[ADDRESS], .I)) EQL %C':'
;	0569			    THEN
;	0570				BEGIN
;	0571	
;	0572				REGISTER
;	0573				    TEMP;
;	0574				COLON_FLAG = FALSE;
;	0575				SDESCR[COUNT] = .I;
;	0576				TEMP = .SDESCR[ADDRESS];
;	0577				SDESCR[ADDRESS] = .RDESCR[ADDRESS];
;	0578				RDESCR[ADDRESS] = .TEMP;
;	0579				IF .PIECE[COUNT] NEQ 0 THEN	    ! Add old piece.
;	0580				    CH$MOVE(.PIECE[COUNT], .PIECE[POINTER],
;	0581					    CH$PTR(.SDESCR[ADDRESS], .RLEN));
;	0582				PIECE[POINTER] = CH$PTR(.SDESCR[ADDRESS], .SDESCR[COUNT]);
;	0583				PIECE[COUNT] = .PIECE[COUNT] + .RLEN - .SDESCR[COUNT];
;	0584				EXITLOOP 0
;	0585				END)
;	0586			EQL -1
;	0587		    THEN EXITLOOP
;	0588		END
;	0589	    WHILE (.STATUS EQL SS$_NORMAL);
;	0590	
;	0591	    IF .STATUS
;	0592	    THEN

;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page  21
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (2)

;	0593		BEGIN
;	0594		IF .STATUS EQL SS$_NOTRAN THEN STATUS = SS$_NORMAL;
;	0595		IF .COLON_FLAG
;	0596		THEN
;	0597		    BEGIN
;	0598	
;	0599		    REGISTER
;	0600		        NEXT_PUNC;
;	0601	
;	0602		    PSLIT(PUNC_LIST, '.;[]<>');
;	0603	
;	0604		    COLON_FLAG = FALSE;
;	0605		    IF (INCR NEXT_PUNC FROM 0 TO STRING_LENGTH(PUNC_LIST) - 1
;	0606			DO IF NOT CH$FAIL(CH$FIND_CH(.RDESCR[COUNT], CH$PTR(.RDESCR[ADDRESS]),
;	0607					     CH$RCHAR(CH$PTR(PUNC_LIST, .NEXT_PUNC))))
;	0608			   THEN EXITLOOP 0)
;	0609		    THEN
;	0610		        BEGIN
;	0611		        CH$WCHAR(%C':', CH$PTR(.RDESCR[ADDRESS], .RLEN));
;	0612		        RLEN = .RLEN + 1
;	0613		        END
;	0614		    END;
;	0615	
;	0616		NAME[COUNT] = .RLEN + .PIECE[COUNT];
;	0617		NAME[POINTER] = CH$COPY(.RLEN, CH$PTR(.RDESCR[ADDRESS]),
;	0618				.PIECE[COUNT], .PIECE[POINTER],
;	0619				%C' ',		! Effectively ignored.
;	0620				.NAME[COUNT], CH$PTR(.NAME[ADDRESS]));
;	0621		NAME_TMP[POINTER] = .NAME[POINTER]
;	0622		END;
;	0623	
;	0624	    RETURN .STATUS
;	0625	END;	! TRNLOG



	.PSECT  $PLIT$,NOWRT,NOEXE,2

P.AAH:	.ASCII  \.;[]<>\			     ;									      ;

	.PSECT  $OWN$,NOEXE,2

PIECE:	.BLKB   12
SDESCR: .BLKB   8
RDESCR: .BLKB   8
TRN_BUF:.BLKB   128

S\6=		    P.AAH
	.EXTRN  SYS_TRNLOG

	.PSECT  $CODE$,NOWRT,2

TRNLOG: .WORD   ^M<R2,R3,R4,R5,R6,R7,R8,R9,R10>      ;Save R2,R3,R4,R5,R6,R7,R8,R9,R10					      ; 0509
	MOVAB   W^RDESCR+4, R10			     ;RDESCR+4, R10							      ;
	SUBL2   #4, SP				     ;#4, SP								      ;
	CLRW    -24(R10)			     ;PIECE								      ; 0556

;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page  22
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (2)

	MOVW    -100(R10), -12(R10)		     ;NAME, SDESCR							      ; 0557
	MOVZBW  #128, -4(R10)			     ;#128, RDESCR							      ; 0558
	MOVL    -96(R10), -8(R10)		     ;NAME+4, SDESCR+4							      ; 0559
	MOVAB   4(R10), (R10)			     ;TRN_BUF, RDESCR+4							      ; 0560
1$:	CLRQ    -(SP)				     ;-(SP)								      ; 0563
	CLRL    -(SP)				     ;-(SP)								      ;
	PUSHAB  -4(R10)				     ;RDESCR								      ;
	PUSHAB  16(SP)				     ;RLEN								      ;
	PUSHAB  -12(R10)			     ;SDESCR								      ;
	CALLS   #6, W^SYS_TRNLOG		     ;#6, SYS_TRNLOG							      ;
	MOVL    R0, R6				     ;R0, STATUS							      ;
	CLRL    R8				     ;R8								      ; 0564
	CMPL    R6, #1				     ;STATUS, #1							      ;
	BNEQ    6$				     ;6$								      ;
	INCL    R8				     ;R8								      ;
	CLRL    R7				     ;I									      ; 0566
	BRB     4$				     ;4$								      ;
2$:	CMPB    @0(R10)[R7], #58		     ;@RDESCR+4[I], #58							      ; 0568
	BNEQ    4$				     ;4$								      ;
	CLRL    -244(R10)			     ;COLON_FLAG							      ; 0574
	MOVW    R7, -12(R10)			     ;I, SDESCR								      ; 0575
	MOVL    -8(R10), R0			     ;SDESCR+4, TEMP							      ; 0576
	MOVL    (R10), -8(R10)			     ;RDESCR+4, SDESCR+4						      ; 0577
	MOVL    R0, (R10)			     ;TEMP, RDESCR+4							      ; 0578
	MOVZWL  -24(R10), R1			     ;PIECE, R1								      ; 0579
	BEQL    3$				     ;3$								      ;
	ADDL3   (SP), -8(R10), R0		     ;RLEN, SDESCR+4, R0						      ; 0581
	MOVC3   R1, @-16(R10), (R0)		     ;R1, @PIECE+8, (R0)						      ; 0580
3$:	MOVZWL  -12(R10), R0			     ;SDESCR, R0							      ; 0582
	MOVAB   @-8(R10)[R0], -16(R10)		     ;@SDESCR+4[R0], PIECE+8						      ;
	MOVZWL  -24(R10), R0			     ;PIECE, R0								      ; 0583
	ADDL2   (SP), R0			     ;RLEN, R0								      ;
	SUBW3   -12(R10), R0, -24(R10)		     ;SDESCR, R0, PIECE							      ;
	CLRL    R0				     ;R0								      ; 0584
	BRB     5$				     ;5$								      ;
4$:	AOBLSS  (SP), R7, 2$			     ;RLEN, I, 2$							      ; 0566
	MNEGL   #1, R0				     ;#1, R0								      ;
5$:	CMPL    R0, #-1				     ;R0, #-1								      ; 0586
	BEQL    7$				     ;7$								      ;
6$:	BLBS    R8, 1$				     ;R8, 1$								      ; 0589
7$:	BLBC    R6, 13$				     ;STATUS, 13$							      ; 0591
	CMPL    R6, #1577			     ;STATUS, #1577							      ; 0594
	BNEQ    8$				     ;8$								      ;
	MOVL    #1, R6				     ;#1, STATUS							      ;
8$:	BLBC    -244(R10), 11$			     ;COLON_FLAG, 11$							      ; 0595
	CLRL    -244(R10)			     ;COLON_FLAG							      ; 0604
	CLRL    R2				     ;NEXT_PUNC								      ; 0605
9$:	LOCC    W^S\6[R2], -4(R10), @0(R10)	     ;S\6[NEXT_PUNC], RDESCR, @RDESCR+4					      ; 0606
	BNEQ    10$				     ;10$								      ;
	CLRL    R1				     ;R1								      ;
10$:	TSTL    R1				     ;R1								      ; 0607
	BNEQ    11$				     ;11$								      ;
	AOBLEQ  #5, R2, 9$			     ;#5, NEXT_PUNC, 9$							      ; 0605
	ADDL3   (SP), (R10), R0			     ;RLEN, RDESCR+4, R0						      ; 0611
	MOVB    #58, (R0)			     ;#58, (R0)								      ;
	INCL    (SP)				     ;RLEN								      ; 0612

;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page  23
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (2)

11$:	ADDW3   -24(R10), (SP), -100(R10)	     ;PIECE, RLEN, NAME							      ; 0616
	MOVZWL  -24(R10), R9			     ;PIECE, R9								      ; 0618
	MOVZWL  -100(R10), R8			     ;NAME, R8								      ; 0620
	MOVL    -96(R10), R7			     ;NAME+4, R7							      ;
	MOVC5   (SP), @0(R10), #32, R8, (R7)	     ;RLEN, @RDESCR+4, #32, R8, (R7)					      ; 0617
	BGEQ    12$				     ;12$								      ;
	ADDL2   (SP), R7			     ;RLEN, R7								      ;
	SUBL2   (SP), R8			     ;RLEN, R8								      ;
	MOVC5   R9, @-16(R10), #32, R8, (R7)	     ;R9, @PIECE+8, #32, R8, (R7)					      ;
12$:	MOVL    R3, -92(R10)			     ;R3, NAME+8							      ;
	MOVL    -92(R10), -80(R10)		     ;NAME+8, NAME_TMP+8						      ; 0621
13$:	MOVL    R6, R0				     ;STATUS, R0							      ; 0624
	RET     				     ;									      ; 0509

; Routine Size:  263 bytes



;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page  24
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (3)

;	0626	!	TPARSE state tables for initial scan.
;	0627	
;	0628	BEGIN
;	0629	SWITCHES LIST(NOOBJECT);
;	0630	
;	0631	$INIT_STATE	(CLI_STB, CLI_KTB);
;	0632	
;	0633	
;	0634	!	MASTER state -- finds qualifiers and parameters.
;	0635	!			exits on EOS or parsing error.
;	0636	
;     P 0637	$STATE	(MASTER,
;     P 0638		( (QUAL),MASTER),
;     P 0639		( (PARAM),MASTER,CHECK,,,PARAMVEC),
;     P 0640		(TPA$_EOS,TPA$_EXIT),
;     P 0641		(TPA$_LAMBDA,TPA$_FAIL,IVDELIM)
;	0642		);
;	0643	
;	0644	!	States needed to identify qualifiers, and their values.
;	0645	
;     P 0646	$STATE	(QUAL,
;     P 0647		('/')
;	0648		);
;     P 0649	$STATE	(QUAL0,
;     P 0650		('NOLOG',NEG_QUAL,NO_LOG),
;     P 0651		('LOG'),
;     P 0652		('NOBRIEF',NEG_QUAL,NO_BR),
;     P 0653		('BRIEF',NEG_QUAL,,4,QUAL_FLAGS),
;     P 0654		('DEFAULT',DEF),
;     P 0655		('NODEFAULT',TPA$_FAIL,,DCL_NOTNEG,PARSE_ERROR),
;     P 0656		(TPA$_SYMBOL,TPA$_FAIL,,DCL_IVKEYW,PARSE_ERROR),
;     P 0657		(TPA$_LAMBDA,TPA$_FAIL,,DCL_NOKEYW,PARSE_ERROR)
;	0658		);
;     P 0659	$STATE	(,
;     P 0660		('='),
;     P 0661		(TPA$_LAMBDA,TPA$_EXIT,,3,QUAL_FLAGS)
;	0662		);
;     P 0663	$STATE	(,
;     P 0664		('ALL',TPA$_EXIT,,3,QUAL_FLAGS),
;     P 0665		('FAILURE',TPA$_EXIT,,2,QUAL_FLAGS),
;     P 0666		('SUCCESS',TPA$_EXIT,,1,QUAL_FLAGS),
;     P 0667		(TPA$_LAMBDA,TPA$_FAIL,,DCL_BADVAL,PARSE_ERROR)
;	0668		);
;     P 0669	$STATE	(DEF,
;     P 0670		('='),
;     P 0671		(TPA$_LAMBDA,TPA$_EXIT)
;	0672		);
;     P 0673	$STATE	(,
;     P 0674		( (PARAM),TPA$_EXIT,CHECK,,,DEFVEC),
;     P 0675		(TPA$_EOS,TPA$_FAIL,,DCL_NULFIL,PARSE_ERROR),
;     P 0676		(TPA$_LAMBDA,TPA$_FAIL,IVDELIM)
;	0677		);
;     P 0678	$STATE	(NEG_QUAL,
;     P 0679		('=',TPA$_FAIL,,DCL_NOVALU,PARSE_ERROR),
;     P 0680		(TPA$_LAMBDA,TPA$_EXIT)

;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page  25
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (3)

;	0681		);
;	0682	
;	0683	
;	0684	!	States needed to get parameters, without checking their content.
;	0685	
;     P 0686	$STATE	(PARAM,
;     P 0687		('/',TPA$_FAIL),	! In case QUAL foun an error.
;     P 0688		(TPA$_SYMBOL,,SAVESYM,,,RAWDESCR),
;     P 0689		('*',,SAVEPUNC,,,RAWDESCR),
;     P 0690		('[',,SAVEPUNC,,,RAWDESCR),
;     P 0691		('<',,SAVEPUNC,,,RAWDESCR),
;     P 0692		('.',,SAVEPUNC,,,RAWDESCR)
;	0693		);
;     P 0694	$STATE	(,
;     P 0695		(TPA$_LAMBDA,,BLANKS_ON)
;	0696		);
;     P 0697	$STATE	(PLOOP,
;     P 0698		('/',,BLANKS_OFF),
;     P 0699		(TPA$_SYMBOL,PLOOP,SAVESYM,,,RAWDESCR),
;     P 0700		('.',PLOOP,SAVEPUNC,,,RAWDESCR),
;     P 0701		(';',PLOOP,SAVEPUNC,,,RAWDESCR),
;     P 0702		(':',PLOOP,SAVEPUNC,,,RAWDESCR),
;     P 0703		('[',PLOOP,SAVEPUNC,,,RAWDESCR),
;     P 0704		(']',PLOOP,SAVEPUNC,,,RAWDESCR),
;     P 0705		('<',PLOOP,SAVEPUNC,,,RAWDESCR),
;     P 0706		('>',PLOOP,SAVEPUNC,,,RAWDESCR),
;     P 0707		(',',PLOOP,SAVEPUNC,,,RAWDESCR),
;     P 0708		('*',PLOOP,SAVEPUNC,,,RAWDESCR),
;     P 0709		(TPA$_BLANK,TPA$_EXIT,BLANKS_OFF),
;     P 0710		(TPA$_EOS,TPA$_EXIT),
;     P 0711		(TPA$_LAMBDA,TPA$_FAIL,,DCL_IVDELIM,PARSE_ERROR)
;	0712		);
;     P 0713	$STATE	(,
;     P 0714		( (QUAL0),TPA$_EXIT),
;     P 0715		(TPA$_LAMBDA,TPA$_FAIL)
;	0716		);
;	0717	
;	0718	
;	0719	!	States needed to parse a parameter, which must be a single file-spec.
;	0720	
;	0721	$INIT_STATE	(FSPEC_STB, FSPEC_KTB);
;	0722	
;     P 0723	$STATE	(,
;     P 0724		( (UIC),FNAME,MOVPART),
;     P 0725		( (DIRNAM),FNAME,MOVPART),
;     P 0726		( (LOGNAM),NAME_OR_DIR,TRNLOG),
;     P 0727		(TPA$_SYMBOL,PART2,SAVESYM,,,NAME),	! File name.
;     P 0728		('.',PART3,SAVEPUNC,,,NAME),
;     P 0729		(';',PART3,SAVEPUNC,,,NAME),
;     P 0730		('*',TPA$_FAIL,,VAL_NOWILD,PARSE_ERROR),
;     P 0731		(TPA$_LAMBDA,TPA$_FAIL,IVDELIM)
;	0732		);
;     P 0733	$STATE	(NAME_OR_DIR,
;     P 0734		( (UIC),,MOVPART),
;     P 0735		( (DIRNAM),,MOVPART),
;     P 0736		(TPA$_LAMBDA)

;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page  26
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (3)

;	0737		);
;     P 0738	$STATE	(FNAME,
;     P 0739		('*',TPA$_FAIL,,VAL_NOWILD,PARSE_ERROR),
;     P 0740		(TPA$_SYMBOL,,SAVESYM,,,NAME),
;     P 0741		(TPA$_EOS,TPA$_EXIT),
;     P 0742		(TPA$_LAMBDA,TPA$_FAIL,,DCL_IVDELIM,PARSE_ERROR)
;	0743		);
;     P 0744	$STATE	(PART2,
;     P 0745		('.',,SAVEPUNC,,,NAME),
;     P 0746		(';',FNAME,SAVEPUNC,,,NAME),
;     P 0747		(TPA$_EOS,TPA$_EXIT),
;     P 0748		(',',TPA$_FAIL,,DCL_NOLIST,PARSE_ERROR),
;     P 0749		(TPA$_LAMBDA,TPA$_FAIL,,DCL_IVDELIM,PARSE_ERROR)
;	0750		);
;     P 0751	$STATE	(PART3,	! This state is needed for the syntax NAME.;
;     P 0752		('.',FNAME,SAVEPUNC,,,NAME),	! [with the variant NAME.. or NAME..1]
;     P 0753		(';',FNAME,SAVEPUNC,,,NAME),
;     P 0754		(',',TPA$_FAIL,,DCL_NOLIST,PARSE_ERROR),
;     P 0755		(TPA$_SYMBOL,PART2,SAVESYM,,,NAME),
;     P 0756		('*',TPA$_FAIL,,VAL_NOWILD,PARSE_ERROR),
;     P 0757		(TPA$_EOS,TPA$_EXIT),
;     P 0758		(TPA$_LAMBDA,TPA$_FAIL,,DCL_IVDELIM,PARSE_ERROR)
;	0759		);
;	0760	
;	0761	!	Sub-states for file name parts.
;	0762	
;     P 0763	$STATE	(LOGNAM,
;     P 0764		(TPA$_SYMBOL,,SAVESYM,,,NAME_TMP)
;	0765		);
;     P 0766	$STATE	(,
;     P 0767		(':',TPA$_EXIT,MOVPART,TRUE,COLON_FLAG),
;     P 0768		(TPA$_EOS,TPA$_EXIT,MOVPART),
;     P 0769		(TPA$_LAMBDA,TPA$_FAIL)
;	0770		);
;	0771	
;     P 0772	$STATE	(UIC,
;     P 0773		(TPA$_LAMBDA,,CLEAN)
;	0774		);
;     P 0775	$STATE	(,
;     P 0776		('[',,SAVEPUNC,,,NAME_TMP),
;     P 0777		('<',,SAVEPUNC,,,NAME_TMP)
;	0778		);
;     P 0779	$STATE	(,
;     P 0780		(TPA$_OCTAL,,SAVESYM,,,NAME_TMP)
;	0781		);
;     P 0782	$STATE	(,
;     P 0783		(',',,SAVEPUNC,,,NAME_TMP),
;	0784		);
;     P 0785	$STATE	(,
;     P 0786		(TPA$_OCTAL,,SAVESYM,,,NAME_TMP)
;	0787		);
;     P 0788	$STATE	(,
;     P 0789		(']',TPA$_EXIT,SAVEPUNC,,,NAME_TMP),
;     P 0790		('>',TPA$_EXIT,SAVEPUNC,,,NAME_TMP)
;	0791		);
;	0792	

;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page  27
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (3)

;     P 0793	$STATE	(DIRNAM,
;     P 0794		(TPA$_LAMBDA,,CLEAN)
;	0795		);
;     P 0796	$STATE	(,
;     P 0797		('[',,SAVEPUNC,,,NAME_TMP),
;     P 0798		('<',,SAVEPUNC,,,NAME_TMP)
;	0799		);
;     P 0800	$STATE	(SUBDIR,
;     P 0801		(TPA$_STRING,SUBDIR,SAVESYM,,,NAME_TMP),
;     P 0802		('.',SUBDIR,SAVEPUNC,,,NAME_TMP),
;     P 0803		(']',TPA$_EXIT,SAVEPUNC,,,NAME_TMP),
;     P 0804		('>',TPA$_EXIT,SAVEPUNC,,,NAME_TMP),
;     P 0805		(TPA$_LAMBDA,TPA$_FAIL,,DCL_DIRECT,PARSE_ERROR)
;	0806		);
;	0807	END
;	0808	
;	0809	END
;	0810	ELUDOM



	.PSECT  LIB$KEY1$,NOWRT,NOEXE,  SHR,0

;TPA$KEYST0
U.19:	.BLKB   0
U.21:	.ASCII  \NOLOG\				     ;									      ;
	.BYTE   -1				     ;									      ;
;TPA$KEYST0
U.26:	.BLKB   0
U.28:	.ASCII  \LOG\				     ;									      ;
	.BYTE   -1				     ;									      ;
;TPA$KEYST0
U.30:	.BLKB   0
U.32:	.ASCII  \NOBRIEF\			     ;									      ;
	.BYTE   -1				     ;									      ;
;TPA$KEYST0
U.36:	.BLKB   0
U.38:	.ASCII  \BRIEF\				     ;									      ;
	.BYTE   -1				     ;									      ;
;TPA$KEYST0
U.43:	.BLKB   0
U.45:	.ASCII  \DEFAULT\			     ;									      ;
	.BYTE   -1				     ;									      ;
;TPA$KEYST0
U.49:	.BLKB   0
U.51:	.ASCII  \NODEFAULT\			     ;									      ;
	.BYTE   -1				     ;									      ;
U.64:	.BYTE   -1				     ;									      ;
;TPA$KEYST0
U.70:	.BLKB   0
U.72:	.ASCII  \ALL\				     ;									      ;
	.BYTE   -1				     ;									      ;
;TPA$KEYST0
U.77:	.BLKB   0
U.79:	.ASCII  \FAILURE\			     ;									      ;
	.BYTE   -1				     ;									      ;

;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page  28
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (3)

;TPA$KEYST0
U.84:	.BLKB   0
U.86:	.ASCII  \SUCCESS\			     ;									      ;
	.BYTE   -1				     ;									      ;
U.95:	.BYTE   -1				     ;									      ;

	.PSECT  LIB$STATE$,NOWRT,NOEXE,  SHR,0

CLI_STB::
	.BLKB   0
MASTER: .BLKB   0
U.2:	.WORD   6648				     ;									      ;
U.4:	.WORD   <<U.3-U.4>-2>			     ;									      ;
U.5:	.WORD   <<MASTER-U.5>-2>		     ;									      ;
U.6:	.WORD   -25608				     ;									      ;
U.7:	.BYTE   1				     ;									      ;
U.9:	.WORD   <<U.8-U.9>-2>			     ;									      ;
U.10:	.ADDRESS PARAMVEC			     ;									      ;
U.11:	.LONG   <<CHECK-U.11>-4>		     ;									      ;
U.12:	.WORD   <<MASTER-U.12>-2>		     ;									      ;
U.13:	.WORD   4599				     ;									      ;
U.14:	.WORD   -1				     ;									      ;
U.15:	.WORD   -27146				     ;									      ;
U.16:	.LONG   <<IVDELIM-U.16>-4>		     ;									      ;
U.17:	.WORD   -2				     ;									      ;
;QUAL
U.3:	.BLKB   0
U.18:	.WORD   1071				     ;									      ;
QUAL0:	.BLKB   0
U.22:	.WORD   -28416				     ;									      ;
U.23:	.LONG   <<NO_LOG-U.23>-4>		     ;									      ;
U.25:	.WORD   <<U.24-U.25>-2>			     ;									      ;
U.29:	.WORD   257				     ;									      ;
U.33:	.WORD   -28414				     ;									      ;
U.34:	.LONG   <<NO_BR-U.34>-4>		     ;									      ;
U.35:	.WORD   <<U.24-U.35>-2>			     ;									      ;
U.39:	.WORD   28931				     ;									      ;
U.40:	.LONG   <<QUAL_FLAGS-U.40>-4>		     ;									      ;
U.41:	.LONG   4				     ;									      ;
U.42:	.WORD   <<U.24-U.42>-2>			     ;									      ;
U.46:	.WORD   4356				     ;									      ;
U.48:	.WORD   <<U.47-U.48>-2>			     ;									      ;
U.52:	.WORD   28933				     ;									      ;
U.53:	.LONG   <<PARSE_ERROR-U.53>-4>		     ;									      ;
U.54:	.LONG   229592				     ;									      ;
U.55:	.WORD   -2				     ;									      ;
U.56:	.WORD   29169				     ;									      ;
U.57:	.LONG   <<PARSE_ERROR-U.57>-4>		     ;									      ;
U.58:	.LONG   229472				     ;									      ;
U.59:	.WORD   -2				     ;									      ;
U.60:	.WORD   30198				     ;									      ;
U.61:	.LONG   <<PARSE_ERROR-U.61>-4>		     ;									      ;
U.62:	.LONG   229560				     ;									      ;
U.63:	.WORD   -2				     ;									      ;
U.65:	.WORD   61				     ;									      ;
U.66:	.WORD   30198				     ;									      ;

;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page  29
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (3)

U.67:	.LONG   <<QUAL_FLAGS-U.67>-4>		     ;									      ;
U.68:	.LONG   3				     ;									      ;
U.69:	.WORD   -1				     ;									      ;
U.73:	.WORD   28934				     ;									      ;
U.74:	.LONG   <<QUAL_FLAGS-U.74>-4>		     ;									      ;
U.75:	.LONG   3				     ;									      ;
U.76:	.WORD   -1				     ;									      ;
U.80:	.WORD   28935				     ;									      ;
U.81:	.LONG   <<QUAL_FLAGS-U.81>-4>		     ;									      ;
U.82:	.LONG   2				     ;									      ;
U.83:	.WORD   -1				     ;									      ;
U.87:	.WORD   28936				     ;									      ;
U.88:	.LONG   <<QUAL_FLAGS-U.88>-4>		     ;									      ;
U.89:	.LONG   1				     ;									      ;
U.90:	.WORD   -1				     ;									      ;
U.91:	.WORD   30198				     ;									      ;
U.92:	.LONG   <<PARSE_ERROR-U.92>-4>		     ;									      ;
U.93:	.LONG   229472				     ;									      ;
U.94:	.WORD   -2				     ;									      ;
;DEF
U.47:	.BLKB   0
U.96:	.WORD   61				     ;									      ;
U.97:	.WORD   5622				     ;									      ;
U.98:	.WORD   -1				     ;									      ;
U.99:	.WORD   -25608				     ;									      ;
U.100:	.BYTE   1				     ;									      ;
U.101:	.WORD   <<U.8-U.101>-2>			     ;									      ;
U.102:	.ADDRESS DEFVEC				     ;									      ;
U.103:	.LONG   <<CHECK-U.103>-4>		     ;									      ;
U.104:	.WORD   -1				     ;									      ;
U.105:	.WORD   29175				     ;									      ;
U.106:	.LONG   <<PARSE_ERROR-U.106>-4>		     ;									      ;
U.107:	.LONG   229600				     ;									      ;
U.108:	.WORD   -2				     ;									      ;
U.109:	.WORD   -27146				     ;									      ;
U.110:	.LONG   <<IVDELIM-U.110>-4>		     ;									      ;
U.111:	.WORD   -2				     ;									      ;
;NEG_QUAL
U.24:	.BLKB   0
U.112:	.WORD   28733				     ;									      ;
U.113:	.LONG   <<PARSE_ERROR-U.113>-4>		     ;									      ;
U.114:	.LONG   229584				     ;									      ;
U.115:	.WORD   -2				     ;									      ;
U.116:	.WORD   5622				     ;									      ;
U.117:	.WORD   -1				     ;									      ;
;PARAM
U.8:	.BLKB   0
U.118:	.WORD   4143				     ;									      ;
U.119:	.WORD   -2				     ;									      ;
U.120:	.WORD   -31759				     ;									      ;
U.121:	.BYTE   1				     ;									      ;
U.122:	.ADDRESS RAWDESCR			     ;									      ;
U.123:	.LONG   <<SAVESYM-U.123>-4>		     ;									      ;
U.124:	.WORD   -32214				     ;									      ;
U.125:	.BYTE   1				     ;									      ;
U.126:	.ADDRESS RAWDESCR			     ;									      ;

;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page  30
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (3)

U.127:	.LONG   <<SAVEPUNC-U.127>-4>		     ;									      ;
U.128:	.WORD   -32165				     ;									      ;
U.129:	.BYTE   1				     ;									      ;
U.130:	.ADDRESS RAWDESCR			     ;									      ;
U.131:	.LONG   <<SAVEPUNC-U.131>-4>		     ;									      ;
U.132:	.WORD   -32196				     ;									      ;
U.133:	.BYTE   1				     ;									      ;
U.134:	.ADDRESS RAWDESCR			     ;									      ;
U.135:	.LONG   <<SAVEPUNC-U.135>-4>		     ;									      ;
U.136:	.WORD   -31186				     ;									      ;
U.137:	.BYTE   1				     ;									      ;
U.138:	.ADDRESS RAWDESCR			     ;									      ;
U.139:	.LONG   <<SAVEPUNC-U.139>-4>		     ;									      ;
U.140:	.WORD   -31242				     ;									      ;
U.141:	.LONG   <<BLANKS_ON-U.141>-4>		     ;									      ;
PLOOP:	.BLKB   0
U.142:	.WORD   -32721				     ;									      ;
U.143:	.LONG   <<BLANKS_OFF-U.143>-4>		     ;									      ;
U.144:	.WORD   -27663				     ;									      ;
U.145:	.BYTE   1				     ;									      ;
U.146:	.ADDRESS RAWDESCR			     ;									      ;
U.147:	.LONG   <<SAVESYM-U.147>-4>		     ;									      ;
U.148:	.WORD   <<PLOOP-U.148>-2>		     ;									      ;
U.149:	.WORD   -28114				     ;									      ;
U.150:	.BYTE   1				     ;									      ;
U.151:	.ADDRESS RAWDESCR			     ;									      ;
U.152:	.LONG   <<SAVEPUNC-U.152>-4>		     ;									      ;
U.153:	.WORD   <<PLOOP-U.153>-2>		     ;									      ;
U.154:	.WORD   -28101				     ;									      ;
U.155:	.BYTE   1				     ;									      ;
U.156:	.ADDRESS RAWDESCR			     ;									      ;
U.157:	.LONG   <<SAVEPUNC-U.157>-4>		     ;									      ;
U.158:	.WORD   <<PLOOP-U.158>-2>		     ;									      ;
U.159:	.WORD   -28102				     ;									      ;
U.160:	.BYTE   1				     ;									      ;
U.161:	.ADDRESS RAWDESCR			     ;									      ;
U.162:	.LONG   <<SAVEPUNC-U.162>-4>		     ;									      ;
U.163:	.WORD   <<PLOOP-U.163>-2>		     ;									      ;
U.164:	.WORD   -28069				     ;									      ;
U.165:	.BYTE   1				     ;									      ;
U.166:	.ADDRESS RAWDESCR			     ;									      ;
U.167:	.LONG   <<SAVEPUNC-U.167>-4>		     ;									      ;
U.168:	.WORD   <<PLOOP-U.168>-2>		     ;									      ;
U.169:	.WORD   -28067				     ;									      ;
U.170:	.BYTE   1				     ;									      ;
U.171:	.ADDRESS RAWDESCR			     ;									      ;
U.172:	.LONG   <<SAVEPUNC-U.172>-4>		     ;									      ;
U.173:	.WORD   <<PLOOP-U.173>-2>		     ;									      ;
U.174:	.WORD   -28100				     ;									      ;
U.175:	.BYTE   1				     ;									      ;
U.176:	.ADDRESS RAWDESCR			     ;									      ;
U.177:	.LONG   <<SAVEPUNC-U.177>-4>		     ;									      ;
U.178:	.WORD   <<PLOOP-U.178>-2>		     ;									      ;
U.179:	.WORD   -28098				     ;									      ;
U.180:	.BYTE   1				     ;									      ;
U.181:	.ADDRESS RAWDESCR			     ;									      ;

;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page  31
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (3)

U.182:	.LONG   <<SAVEPUNC-U.182>-4>		     ;									      ;
U.183:	.WORD   <<PLOOP-U.183>-2>		     ;									      ;
U.184:	.WORD   -28116				     ;									      ;
U.185:	.BYTE   1				     ;									      ;
U.186:	.ADDRESS RAWDESCR			     ;									      ;
U.187:	.LONG   <<SAVEPUNC-U.187>-4>		     ;									      ;
U.188:	.WORD   <<PLOOP-U.188>-2>		     ;									      ;
U.189:	.WORD   -28118				     ;									      ;
U.190:	.BYTE   1				     ;									      ;
U.191:	.ADDRESS RAWDESCR			     ;									      ;
U.192:	.LONG   <<SAVEPUNC-U.192>-4>		     ;									      ;
U.193:	.WORD   <<PLOOP-U.193>-2>		     ;									      ;
U.194:	.WORD   -28174				     ;									      ;
U.195:	.LONG   <<BLANKS_OFF-U.195>-4>		     ;									      ;
U.196:	.WORD   -1				     ;									      ;
U.197:	.WORD   4599				     ;									      ;
U.198:	.WORD   -1				     ;									      ;
U.199:	.WORD   30198				     ;									      ;
U.200:	.LONG   <<PARSE_ERROR-U.200>-4>		     ;									      ;
U.201:	.LONG   229648				     ;									      ;
U.202:	.WORD   -2				     ;									      ;
U.203:	.WORD   6648				     ;									      ;
U.204:	.WORD   <<QUAL0-U.204>-2>		     ;									      ;
U.205:	.WORD   -1				     ;									      ;
U.206:	.WORD   5622				     ;									      ;
U.207:	.WORD   -2				     ;									      ;
	.BLKB   1
FSPEC_STB::
	.BLKB   0
U.209:	.WORD   -26120				     ;									      ;
U.211:	.WORD   <<U.210-U.211>-2>		     ;									      ;
U.212:	.LONG   <<MOVPART-U.212>-4>		     ;									      ;
U.214:	.WORD   <<U.213-U.214>-2>		     ;									      ;
U.215:	.WORD   -26120				     ;									      ;
U.217:	.WORD   <<U.216-U.217>-2>		     ;									      ;
U.218:	.LONG   <<MOVPART-U.218>-4>		     ;									      ;
U.219:	.WORD   <<U.213-U.219>-2>		     ;									      ;
U.220:	.WORD   -26120				     ;									      ;
U.222:	.WORD   <<U.221-U.222>-2>		     ;									      ;
U.223:	.LONG   <<TRNLOG-U.223>-4>		     ;									      ;
U.225:	.WORD   <<U.224-U.225>-2>		     ;									      ;
U.226:	.WORD   -27663				     ;									      ;
U.227:	.BYTE   1				     ;									      ;
U.228:	.ADDRESS NAME				     ;									      ;
U.229:	.LONG   <<SAVESYM-U.229>-4>		     ;									      ;
U.231:	.WORD   <<U.230-U.231>-2>		     ;									      ;
U.232:	.WORD   -28114				     ;									      ;
U.233:	.BYTE   1				     ;									      ;
U.234:	.ADDRESS NAME				     ;									      ;
U.235:	.LONG   <<SAVEPUNC-U.235>-4>		     ;									      ;
U.237:	.WORD   <<U.236-U.237>-2>		     ;									      ;
U.238:	.WORD   -28101				     ;									      ;
U.239:	.BYTE   1				     ;									      ;
U.240:	.ADDRESS NAME				     ;									      ;
U.241:	.LONG   <<SAVEPUNC-U.241>-4>		     ;									      ;
U.242:	.WORD   <<U.236-U.242>-2>		     ;									      ;

;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page  32
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (3)

U.243:	.WORD   28714				     ;									      ;
U.244:	.LONG   <<PARSE_ERROR-U.244>-4>		     ;									      ;
U.245:	.LONG   100052				     ;									      ;
U.246:	.WORD   -2				     ;									      ;
U.247:	.WORD   -27146				     ;									      ;
U.248:	.LONG   <<IVDELIM-U.248>-4>		     ;									      ;
U.249:	.WORD   -2				     ;									      ;
;NAME_OR_DIR
U.224:	.BLKB   0
U.250:	.WORD   -30216				     ;									      ;
U.251:	.WORD   <<U.210-U.251>-2>		     ;									      ;
U.252:	.LONG   <<MOVPART-U.252>-4>		     ;									      ;
U.253:	.WORD   -30216				     ;									      ;
U.254:	.WORD   <<U.216-U.254>-2>		     ;									      ;
U.255:	.LONG   <<MOVPART-U.255>-4>		     ;									      ;
U.256:	.WORD   1526				     ;									      ;
;FNAME
U.213:	.BLKB   0
U.257:	.WORD   28714				     ;									      ;
U.258:	.LONG   <<PARSE_ERROR-U.258>-4>		     ;									      ;
U.259:	.LONG   100052				     ;									      ;
U.260:	.WORD   -2				     ;									      ;
U.261:	.WORD   -31759				     ;									      ;
U.262:	.BYTE   1				     ;									      ;
U.263:	.ADDRESS NAME				     ;									      ;
U.264:	.LONG   <<SAVESYM-U.264>-4>		     ;									      ;
U.265:	.WORD   4599				     ;									      ;
U.266:	.WORD   -1				     ;									      ;
U.267:	.WORD   30198				     ;									      ;
U.268:	.LONG   <<PARSE_ERROR-U.268>-4>		     ;									      ;
U.269:	.LONG   229648				     ;									      ;
U.270:	.WORD   -2				     ;									      ;
;PART2
U.230:	.BLKB   0
U.271:	.WORD   -32210				     ;									      ;
U.272:	.BYTE   1				     ;									      ;
U.273:	.ADDRESS NAME				     ;									      ;
U.274:	.LONG   <<SAVEPUNC-U.274>-4>		     ;									      ;
U.275:	.WORD   -28101				     ;									      ;
U.276:	.BYTE   1				     ;									      ;
U.277:	.ADDRESS NAME				     ;									      ;
U.278:	.LONG   <<SAVEPUNC-U.278>-4>		     ;									      ;
U.279:	.WORD   <<U.213-U.279>-2>		     ;									      ;
U.280:	.WORD   4599				     ;									      ;
U.281:	.WORD   -1				     ;									      ;
U.282:	.WORD   28716				     ;									      ;
U.283:	.LONG   <<PARSE_ERROR-U.283>-4>		     ;									      ;
U.284:	.LONG   229568				     ;									      ;
U.285:	.WORD   -2				     ;									      ;
U.286:	.WORD   30198				     ;									      ;
U.287:	.LONG   <<PARSE_ERROR-U.287>-4>		     ;									      ;
U.288:	.LONG   229648				     ;									      ;
U.289:	.WORD   -2				     ;									      ;
;PART3
U.236:	.BLKB   0
U.290:	.WORD   -28114				     ;									      ;

;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page  33
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (3)

U.291:	.BYTE   1				     ;									      ;
U.292:	.ADDRESS NAME				     ;									      ;
U.293:	.LONG   <<SAVEPUNC-U.293>-4>		     ;									      ;
U.294:	.WORD   <<U.213-U.294>-2>		     ;									      ;
U.295:	.WORD   -28101				     ;									      ;
U.296:	.BYTE   1				     ;									      ;
U.297:	.ADDRESS NAME				     ;									      ;
U.298:	.LONG   <<SAVEPUNC-U.298>-4>		     ;									      ;
U.299:	.WORD   <<U.213-U.299>-2>		     ;									      ;
U.300:	.WORD   28716				     ;									      ;
U.301:	.LONG   <<PARSE_ERROR-U.301>-4>		     ;									      ;
U.302:	.LONG   229568				     ;									      ;
U.303:	.WORD   -2				     ;									      ;
U.304:	.WORD   -27663				     ;									      ;
U.305:	.BYTE   1				     ;									      ;
U.306:	.ADDRESS NAME				     ;									      ;
U.307:	.LONG   <<SAVESYM-U.307>-4>		     ;									      ;
U.308:	.WORD   <<U.230-U.308>-2>		     ;									      ;
U.309:	.WORD   28714				     ;									      ;
U.310:	.LONG   <<PARSE_ERROR-U.310>-4>		     ;									      ;
U.311:	.LONG   100052				     ;									      ;
U.312:	.WORD   -2				     ;									      ;
U.313:	.WORD   4599				     ;									      ;
U.314:	.WORD   -1				     ;									      ;
U.315:	.WORD   30198				     ;									      ;
U.316:	.LONG   <<PARSE_ERROR-U.316>-4>		     ;									      ;
U.317:	.LONG   229648				     ;									      ;
U.318:	.WORD   -2				     ;									      ;
;LOGNAM
U.221:	.BLKB   0
U.319:	.WORD   -30735				     ;									      ;
U.320:	.BYTE   1				     ;									      ;
U.321:	.ADDRESS NAME_TMP			     ;									      ;
U.322:	.LONG   <<SAVESYM-U.322>-4>		     ;									      ;
U.323:	.WORD   -4038				     ;									      ;
U.324:	.LONG   <<MOVPART-U.324>-4>		     ;									      ;
U.325:	.LONG   <<COLON_FLAG-U.325>-4>		     ;									      ;
U.326:	.LONG   1				     ;									      ;
U.327:	.WORD   -1				     ;									      ;
U.328:	.WORD   -28169				     ;									      ;
U.329:	.LONG   <<MOVPART-U.329>-4>		     ;									      ;
U.330:	.WORD   -1				     ;									      ;
U.331:	.WORD   5622				     ;									      ;
U.332:	.WORD   -2				     ;									      ;
;UIC
U.210:	.BLKB   0
U.333:	.WORD   -31242				     ;									      ;
U.334:	.LONG   <<CLEAN-U.334>-4>		     ;									      ;
U.335:	.WORD   -32165				     ;									      ;
U.336:	.BYTE   1				     ;									      ;
U.337:	.ADDRESS NAME_TMP			     ;									      ;
U.338:	.LONG   <<SAVEPUNC-U.338>-4>		     ;									      ;
U.339:	.WORD   -31172				     ;									      ;
U.340:	.BYTE   1				     ;									      ;
U.341:	.ADDRESS NAME_TMP			     ;									      ;
U.342:	.LONG   <<SAVEPUNC-U.342>-4>		     ;									      ;

;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page  34
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (3)

U.343:	.WORD   -30732				     ;									      ;
U.344:	.BYTE   1				     ;									      ;
U.345:	.ADDRESS NAME_TMP			     ;									      ;
U.346:	.LONG   <<SAVESYM-U.346>-4>		     ;									      ;
U.347:	.WORD   -31188				     ;									      ;
U.348:	.BYTE   1				     ;									      ;
U.349:	.ADDRESS NAME_TMP			     ;									      ;
U.350:	.LONG   <<SAVEPUNC-U.350>-4>		     ;									      ;
U.351:	.WORD   -30732				     ;									      ;
U.352:	.BYTE   1				     ;									      ;
U.353:	.ADDRESS NAME_TMP			     ;									      ;
U.354:	.LONG   <<SAVESYM-U.354>-4>		     ;									      ;
U.355:	.WORD   -28067				     ;									      ;
U.356:	.BYTE   1				     ;									      ;
U.357:	.ADDRESS NAME_TMP			     ;									      ;
U.358:	.LONG   <<SAVEPUNC-U.358>-4>		     ;									      ;
U.359:	.WORD   -1				     ;									      ;
U.360:	.WORD   -27074				     ;									      ;
U.361:	.BYTE   1				     ;									      ;
U.362:	.ADDRESS NAME_TMP			     ;									      ;
U.363:	.LONG   <<SAVEPUNC-U.363>-4>		     ;									      ;
U.364:	.WORD   -1				     ;									      ;
;DIRNAM
U.216:	.BLKB   0
U.365:	.WORD   -31242				     ;									      ;
U.366:	.LONG   <<CLEAN-U.366>-4>		     ;									      ;
U.367:	.WORD   -32165				     ;									      ;
U.368:	.BYTE   1				     ;									      ;
U.369:	.ADDRESS NAME_TMP			     ;									      ;
U.370:	.LONG   <<SAVEPUNC-U.370>-4>		     ;									      ;
U.371:	.WORD   -31172				     ;									      ;
U.372:	.BYTE   1				     ;									      ;
U.373:	.ADDRESS NAME_TMP			     ;									      ;
U.374:	.LONG   <<SAVEPUNC-U.374>-4>		     ;									      ;
SUBDIR: .BLKB   0
U.375:	.WORD   -27664				     ;									      ;
U.376:	.BYTE   1				     ;									      ;
U.377:	.ADDRESS NAME_TMP			     ;									      ;
U.378:	.LONG   <<SAVESYM-U.378>-4>		     ;									      ;
U.379:	.WORD   <<SUBDIR-U.379>-2>		     ;									      ;
U.380:	.WORD   -28114				     ;									      ;
U.381:	.BYTE   1				     ;									      ;
U.382:	.ADDRESS NAME_TMP			     ;									      ;
U.383:	.LONG   <<SAVEPUNC-U.383>-4>		     ;									      ;
U.384:	.WORD   <<SUBDIR-U.384>-2>		     ;									      ;
U.385:	.WORD   -28067				     ;									      ;
U.386:	.BYTE   1				     ;									      ;
U.387:	.ADDRESS NAME_TMP			     ;									      ;
U.388:	.LONG   <<SAVEPUNC-U.388>-4>		     ;									      ;
U.389:	.WORD   -1				     ;									      ;
U.390:	.WORD   -28098				     ;									      ;
U.391:	.BYTE   1				     ;									      ;
U.392:	.ADDRESS NAME_TMP			     ;									      ;
U.393:	.LONG   <<SAVEPUNC-U.393>-4>		     ;									      ;
U.394:	.WORD   -1				     ;									      ;
U.395:	.WORD   30198				     ;									      ;

;VALIDATE							13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page  35
;								20-AUG-1980 10:48	DBD0:[FITZ.DECUS]VALIDATE.BLI;1 (3)

U.396:	.LONG   <<PARSE_ERROR-U.396>-4>		     ;									      ;
U.397:	.LONG   229424				     ;									      ;
U.398:	.WORD   -2				     ;									      ;

	.PSECT  LIB$KEY0$,NOWRT,NOEXE,  SHR,1

CLI_KTB::
	.BLKB   0
;TPA$KEY0
U.1:	.BLKB   0
U.20:	.WORD   <U.19-U.1>			     ;									      ;
U.27:	.WORD   <U.26-U.1>			     ;									      ;
U.31:	.WORD   <U.30-U.1>			     ;									      ;
U.37:	.WORD   <U.36-U.1>			     ;									      ;
U.44:	.WORD   <U.43-U.1>			     ;									      ;
U.50:	.WORD   <U.49-U.1>			     ;									      ;
U.71:	.WORD   <U.70-U.1>			     ;									      ;
U.78:	.WORD   <U.77-U.1>			     ;									      ;
U.85:	.WORD   <U.84-U.1>			     ;									      ;
	.BLKB   2
FSPEC_KTB::
	.BLKB   0
;TPA$KEY0
U.208:	.BLKB   0




;				       PSECT SUMMARY
;
;	Name		 Bytes			       Attributes
;
;  $OWN$          	   992    WRT,  RD ,NOEXE,NOSHR,  LCL,  REL,  CON,NOPIC,ALIGN(2)
;  $PLIT$         	    98  NOWRT,  RD ,NOEXE,NOSHR,  LCL,  REL,  CON,NOPIC,ALIGN(2)
;  $CODE$         	  1036  NOWRT,  RD ,  EXE,NOSHR,  LCL,  REL,  CON,NOPIC,ALIGN(2)
;  LIB$KEY0$      	    20  NOWRT,  RD ,NOEXE,  SHR,  LCL,  REL,  CON,NOPIC,ALIGN(1)
;  LIB$STATE$     	   955  NOWRT,  RD ,NOEXE,  SHR,  LCL,  REL,  CON,NOPIC,ALIGN(0)
;  LIB$KEY1$      	    64  NOWRT,  RD ,NOEXE,  SHR,  LCL,  REL,  CON,NOPIC,ALIGN(0)




;				LIBRARY STATISTICS
;
;					     -------- Symbols --------    Blocks
;	File				     Total    Loaded   Percent      Read
;
;  DBA0:[SYSLIB]STARLET.L32;2		      2688        49         1       153
;  DBA0:[SYSLIB]CLIMAC.L32;1		        14         2        14         5
;  DBA0:[SYSLIB]TPAMAC.L32;1		        39        32        82        24





; Size:		1036 code + 2129 data bytes

;								13-NOV-1980 17:46:45	Bliss-32 V0.9-567		    Page  36
;											 (3)

; Run Time:	01:35.5
; Elapsed Time:	03:17.0
; Memory Used:	320 pages
; Compilation Complete

	.END	VALIDATE