Google
 

Trailing-Edge - PDP-10 Archives - BB-JF18A-BM - sources/rms/debcmd.mac
There are 7 other files named debcmd.mac in the archive. Click here to see a list.
;
;	COPYRIGHT (C) DIGITAL EQUIPMENT CORPORATION 1986.
;	ALL RIGHTS RESERVED.
;
;	THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY  BE  USED  AND
;	COPIED ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH
;	THE INCLUSION OF THE ABOVE COPYRIGHT NOTICE.   THIS  SOFTWARE  OR
;	ANY  OTHER  COPIES  THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE
;	AVAILABLE TO ANY OTHER PERSON.  NO TITLE TO AND OWNERSHIP OF  THE
;	SOFTWARE IS HEREBY TRANSFERRED.
;
;	THE INFORMATION IN THIS SOFTWARE IS  SUBJECT  TO  CHANGE  WITHOUT
;	NOTICE  AND  SHOULD  NOT  BE CONSTRUED AS A COMMITMENT BY DIGITAL
;	EQUIPMENT CORPORATION.
;
;	DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR  RELIABILITY  OF
;	ITS SOFTWARE ON EQUIPMENT THAT IS NOT SUPPLIED BY DIGITAL.
;

TITLE	DEBCMD - SYNTAX TABLES FOR RMSDEB
SUBTTL S. COHEN
; 
; 510 - Add new fields and commands and support wildcarding
; 527 - Add NDA & NDL to field name command tables
; 554 - Make the Config XAB known to RMSDEB
; 600 - Add TRACE, NOTRACE, and $FREE
; 10/3/85 asp - cleanup search libraries
; 634 - 6/17/86 asp, re-order TYP class values
;
SEARCH RMSMAC,RMSINT,CMDPAR
$PROLOG(DEB)

P$COLON==0				;;INIT DEF OF IT
					;;USED TO APP COLON TO TOK NAME

C$MAXB==^D17				; Highest legal block type	;AAAA
C$XABS==C$MAXB+1			; Offset in dispatch for XABs	;AAAA


; AK$TAB - DEFINES KYWD TABLE IN WHICH EACH ENTRY IS AN RMS ARG BLK FIELD
;
DEFINE AK$TAB(NEXT$,TYP$,FLD$,KOPT$)<
	DEFINE $$CODE(X$)<RF.'X$'##>	;;ADDRESS OF FLD DESCRIPTOR
	$KEY(NEXT$,TYP$'TB,<KOPT$>)	;;KEY TABLE
	TB$KEY(TYP$,<FLD$>)		;;DO THE REAL WORK
>

; AO$TAB - DEFINES DISPATCH TABLE IN WHICH EACH ENTRY IS RMS SYMBOLIC VAL
;
DEFINE AO$TAB(T$,FLD$,KOPT$)<
	DEFINE $$CODE(X$)<RF.'X$'##>	;;ADDRESS OF FLD DESCRIPTOR
	DEFINE $$LABL(X$)<T$''X$>	;;DISPATCH BASED ON FLD NAME
	$KEYDSP(T$'TB,<KOPT$>)		;;KEY TABLE
	TB$DSP(T$,<FLD$>)		;;DO THE REAL WORK
>

; AS$TAB - DEFINES SWITCH DISPATCH TABLE FOR RMS ARGBLK FIELDS
; DISPATCH LABEL IS LOCAL -- SO VALUE CAN BE PICKED UP
; PARSE CODE IS ADDRESS -- SO APPROP $STORE CAN BE DONE
;
DEFINE AS$TAB(T$,FLD$,KDOPT$)<
	DEFINE $$CODE(X$)<RF.'X$'##>	;;ADDRESS OF FLD DESCRIPTOR
	DEFINE $$LABL(X$)<T$''X$>	;;DISPATCH BASED ON FLD NAME
	P$COLON==1			;;APPEND COLONS
	$SWITCH	(0,T$'TB,<KDOPT$>)	;;DISPATCH TO KYWD TABLE
	TB$DSP(T$,<FLD$>)		;;DO THE REAL WORK
	P$COLON==0			;;TURN OFF
>

; AV$TAB - DEFINES TABLE IN WHICH EACH ENTRY IS RMS SYMBOLIC VAL
;
DEFINE AV$TAB(NEXT$,TYP$,P$,FLD$,KOPT$)<
	DEFINE $$CODE(X$)<P$'$'X$>	;;SYMBOL IN RMSINT
	$KEY(NEXT$,TYP$'TB,<KOPT$>)	;;KEY TABLE
	TB$KEY(TYP$,<FLD$>)		;;DO THE REAL WORK
>

; $FILEF - ALLOW SYMBOLS THAT INCLUDE . < > : [ ] ; $ % *
;
DEFINE $FILEF (NXT$,HELP$,ARGS$) <$FNAME(NXT$,<HELP$>,<$BREAK(MSKFIL),ARGS$>)>

; $MACF - ALLOW SYMBOLS THAT INCLUDE . $ OR %
;
DEFINE $MACF (NXT$,HELP$,ARGS$) <$FNAME(NXT$,<HELP$>,<$BREAK(MSKMAC),ARGS$>)>

; SO$TAB - DEFINES DISPATCH TABLE IN WHICH EACH ENTRY IS RMS SYMBOLIC VAL
;
DEFINE SO$TAB(T$,P$,FLD$,KOPT$)<
	DEFINE $$CODE(X$)<P$'$'X$>	;;SYMBOL IN RMSINT
	DEFINE $$LABL(X$)<T$''X$>	;;DISPATCH BASED ON FLD NAME
	$KEYDSP(T$'TB,KOPT$)		;;KEY TABLE
	TB$DSP(T$,<FLD$>)		;;DO THE REAL WORK
>
SUBTTL	SPECIAL STUFF FOR CMDPAR INTERFACE

BASE10==^D10				;FOR $NUMGE MACRO

$IMPURE

CHABTO:	$NOISE	(0,TO)			;FOR NOISE AFTER ARGBLK TABLE
DEFNMI:	$NOISE	(0,NAMING IT)		;FOR NOISE AFT DEF TYPE 	;m510
XABCOM:	0				;SPACE FOR PDB AFTER CMA IN XAB
PDBPAG:	BLOCK	200			;SPACE FOR PARSED DATA

$PURE


MSKFIL:	; bits specified are bits that are not break characters.
	FLDB0.				;WORD-N OF MASK
	FLDB1.&<^-<1B0!1B2!1B4!1B5!1B10!1B12!1B13!1B14!1B26!1B27!1B28!1B30>> 
;	         SPACE  "   $   %   *     ,    -    .    :    ;    <    >
	FLDB2.&<^-<1B27!1B29!1B31>>
;	             [    ]   _					     
	FLDB3.
; Include " for access info in nodename, and ; so attributes can be given ;m501
; Include * and % for wildcarding					  ;m510

MSKMAC:
	FLDB0.				;WORD-N OF MASK
	FLDB1.&<^-<1B4!1B5!1B14>>!1B13	;B4=$ B5=% B14=. AND EXCL B13=-
	FLDB2.
	FLDB3.

CHANXT:
	SZ%BID==C$XABS+XB$MAX+1		;NUMBER OF ARGBLK TYPES  	;M554
	$INIT	(BID)
	 $SET	(DA$TYP,CHADAT)
	 $SET	(FA$TYP,CHAFAB)
	 $SET	(RA$TYP,CHARAB)
	 $SET	(FS$TYP,CHAFST)
	 $SET	(RS$TYP,CHARST)
	 $SET	(KD$TYP,CHAKDB)
	 $SET	(NA$TYP,CHANAM)
	 $SET	(TY$TYP,CHATYP)
	 $SET	(C$XABS+XB$AREA,CHAXA)
	 $SET	(C$XABS+XB$CFG,CHAXC)					;A554
	 $SET	(C$XABS+XB$KEY,CHAXK)
	 $SET	(C$XABS+XB$DAT,CHAXD)
	 $SET	(C$XABS+XB$SUM,CHAXS)
	$ENDINIT

CHDNXT:				;CHANGE datafield (dispatch by datatype) ;A411
	SZ%TYP==XB$UN4+1	;Size of table
	$INIT	(TYP)
	 $SET (DFT%ASC,CHDTTX)		; STRING DATA-TYPE
;;	 $SET (DFT%ASC,CHDTTX)		; EBCDIC DATA-TYPE
	 $SET (DFT%SIX,CHDTTX)		; SIXBIT DATA-TYPE
	 $SET (DFT%PAC,CHDTPA)		; PACKED DECIMAL DATA-TYPE	;A411
	 $SET (DFT%DEC,CHDTDE)		; INTEGER DATA-TYPE		;A411
	 $SET (DFT%FLO,CHDTFL)		; FLOAT (1 word) DATA-TYPE	;A411
	 $SET (DFT%DOU,CHDTGF)		; DOUBLE FLOAT DATA-TYPE	;A411
	 $SET (DFT%GFL,CHDTGF)		; G-FLOAT DATA-TYPE		;A411
	 $SET (DFT%LON,CHDTPA)		; INTEGER (2 word) DATA-TYPE   	;A411
;;	 $SET (DFT%ASC,CHDTTX)		; 8-bit ASCII (in 9-bit bytes)	;A411
	 $SET (DFT%UNS,CHDTPA)		; Unsigned Integer (1 word)	;A411
	$ENDINIT

DISNXT:
	$INIT	(BID)
	 $SET	(DA$TYP,DIDCMA)		;COMPLETE CMD COULD BE D D1 [,D2,...]
	 $SET	(FA$TYP,DISFAB)
	 $SET	(RA$TYP,DISRAB)
	 $SET	(FS$TYP,DISFST)
	 $SET	(RS$TYP,DISRST)
	 $SET	(KD$TYP,DISKDB)
	 $SET	(NA$TYP,DISNAM)
	 $SET	(TY$TYP,DISTYP)
	 $SET	(C$XABS+XB$AREA,DISXA)
	 $SET	(C$XABS+XB$CFG,DISXC) 				;A554
	 $SET	(C$XABS+XB$KEY,DISXK)
	 $SET	(C$XABS+XB$DAT,DISXD)
	 $SET	(C$XABS+XB$SUM,DISXS)
	$ENDINIT
SUBTTL	ACTION ROUTINES

CXXNXT:					;SETS PLACE TO GO AFTER COMMA IN XAB
	MOVE	T1,XABCOM
	MOVEM	T1,.NEXT
	POPJ	P,

;Action routine for CHANGE

CHACAS:	$CALL	FLDTYP			;SETUP BID TO DRIVE SETTING OF .NEXT
	JUMPF	[POPJ P,]		;TRANSIT RET FAILURE
	IFE DA$TYP,<							;A411
	JUMPE	T2,CHADAT		;				
	>
	IFN DA$TYP,<
	CAIN	T2,DA$TYP
	 JRST	CHADAT
	>								;A411
	MOVE	T1,CHANXT(T2)		;SET GLOBAL "NEXT PDB" FLD
CHACA1:	MOVEM	T1,.NEXT
	MOVEM	T1,XABCOM		;SAVE WHERE TO GO AFTER COMMA
	POPJ	P,			;TRANSIT RET TRUE

CHADAT:	LDB	T3,[UF.TYP(T1)]		;Get data type of field
	MOVE	T1,CHDNXT(T3)		;Get next state
	JRST	CHACA1			;Merge with common code

;Action routine for DISPLAY

DISCAS:	$CALL	FLDTYP			;SETUP BID TO DRIVE SETTING OF .NEXT
	JUMPF	[POPJ P,]		;TRANSIT RET FAILURE
	MOVE	T1,DISNXT(T2)		;SET GLOBAL "NEXT PDB" FLD
	MOVEM	T1,.NEXT
	MOVEM	T1,XABCOM		;SAVE WHERE TO GO AFTER COMMA
	POPJ	P,			;TRANSIT RET TRUE

; FLDTYP - ACTION ROUTINE TO DETERMINE NEXT PDB OF A FIELD
; ARGUMENTS:
;	T1 = LENGTH OF CMDRET BLK
;	T2 = ADDR OF CMDRET BLK

FLDTYP:	MOVE	T5,CR.SAV(T2)		;GET ADDRESS OF PARSE DATA
	MOVEI	T1,TK.VAL(T5)		;PASS THE FIELD VALUE
	$CALL	SY.FIND
	JUMPT	FLDTY1			;A MATCH?
	MOVEI	T2,[ASCIZ/Name not known/] ;NO, TELL CALLER
FLDFAI:	SETZ	TF,			;FAILURE RET
	POPJ	P,

FLDTY1:	$FETCH	T2,BID,<(T1)>		;GET TYPE OF FLD
	CAILE	T2,C$MAXB		;Range check			;A554
	 JRST	[MOVEI T2,[ASCIZ /Not an RMS block/]	;Out of range	;A554
		 JRST FLDFAI]						;A554
IFE <XA$TYP-FS$TYP>,<			; FST and XAB have same BID	;A554
	$FETCH	T3,BLN,(T1)		; Get length of field		;A554
	CAIN	T3,FS$LNG		; Is is same as an FST?		;A554
	 JRST	FLDTY2			; Yes. It is an FST		;A554
	>								;A554
	CAIE	T2,XA$TYP		;XAB?
	 JRST	FLDTY2			;NO
	$FETCH	T3,COD,(T1)		;GET TYPE OF XAB
	MOVEI	T2,C$XABS(T3)		;SEP PDB FOR EACH TYPE OF XAB  ;MAAA
FLDTY2:	SETO	TF,			;SUCC RET
	POPJ	P,
SUBTTL	TOP-LEVEL SYNTAX OF RMSDEB

; THE MAIN PARSER DESCRIPTOR BLOCK, THIS IS WHAT IS PASSED DIRECTLY TO COMND
;
DB.CMD::
	CMDINI				;PT TO CMD TABLE
	[ASCIZ/RMSDEB>/]		;PROMPT
	PDBPAG				;PAGE FOR PARSED DATA
	0				;USE TTY

CMDINI:	$INITC(CMDS)			;THE INIT BLK

CMDS:	CM$TAB	(<$CLOSE,$CONNECT,$CREATE,$DELETE,$DISCONNECT,$DISPLAY,$ERASE,$FIND,$FLUSH,$FREE,$GET,$MESSAGE,$NOMESSAGE,$OPEN,$PARSE,$PUT,$READ,$RENAME,$SEARCH,$TRUNCATE,$UPDATE,$WRITE,ASSIGN,CHANGE,DDT,DEFINE,DISPLAY,EXIT,HELP,INFORMATION,NOTRACE,TAKE,TRACE,UNDEFINE>,$BREAK(MSKMAC))


CFM:	$CRLF				;CRLF IS COMMON TERMINATOR OF COMMANDS

; THESE COMMANDS ARE QUITE SIMPLE: CMD [FAB-NAME ! RAB-NAME]
;
DEFINE $LABEL(V$)<IRP V$,<.'V$:>>	;;VERBS HAVE SIMPLE SYNTAX, SO GROUP THEM

$LABEL	<$CONNECT,$DELETE,$DISCONNECT,$FIND,$FLUSH,$FREE,$GET,$PUT,$READ,$WRITE,$TRUNCATE,$UPDATE>
	$NOISE	(RABNAM,<USING RAB>)
RABNAM:	$MACF	(CFM,<RAB name>)

$LABEL	<$CLOSE,$CREATE,$DISPLAY,$ERASE,$OPEN,$PARSE,$SEARCH>
	$NOISE	(FABNAM,<USING FAB>)
FABNAM:	$MACF	(CFM,<FAB name>)

$LABEL	<$MESSAGE,$NOMESSAGE,DDT,EXIT,HELP,TRACE,NOTRACE>
	$NOISE	(CFM,PLEASE)

$LABEL	<$RENAME>
	$NOISE	(OLDFAB,<Using Old FAB>)
OLDFAB: $MACF	(NEWNOI,<FAB describing existing file>)
NEWNOI:	$NOISE	(NEWFAB,<And New Fab>)
NEWFAB:	$MACF	(CFM,<FAB with new file name>)
SUBTTL	SYNTAX FOR ASSIGN CMD

; ASSIGN name = addres

.ASSIG:	$NOISE	(ASSNAM,NAME)
ASSNAM:	$MACF	(ASSEQL,<block name>)
ASSEQL:	$NOISE	(ASSOLD,<TO ADDRESS>)
ASSOLD:	$NUMGE	(CFM,8,<octal number>)
SUBTTL	SYNTAX FOR CHANGE CMD

; CHANGE ARGBLK-NAME FIELD-KYWD (TO) FLD-DEP-VALUE, ...
; CHANGE [RAB-NAME] FLD-NAME (TO) FLD-DEP-VALUE, ...
;		KEY-BUFFER (TO) STRING OR NUMBER   (IDX OR REL)

.CHANG:	$NOISE	(CHATP,VALUE IDENTIFIED BY)				;m510
CHATP:	OP$TAB	(CHA,<<KEY,KEY-BUFFER>>,$ALTERN(CHAFNM))		;m510
CHAFNM:	$MACF	(0,<argblk or datafield name>,$ACTION(CHACAS))

CHAKEY:	$NOISE	(CHKDEC,TO)
CHKDEC:	$NUMBER	(CFM,BASE10,relative record number,<$ALTERN(CHKTEX)>)
CHKTEX:	$QUOTE	(CFM,<quoted key value>)

CHAFAB:	$NOISE	(CHAFF,AND)
CHAFF:	AO$TAB	(CHF,<ALQ,BKS,BSZ,FAC,FOP,FSZ,MRN,MRS,NAM,ORG,RAT,RFM,SHR,TYP,XAB>,AC$NOI(CHABTO))	;[2]
CHFBKS:	$NUMGE	(CHFCOM,BASE10,<number of pages per bucket>)
CHFBSZ:	$NUMGE	(CHFCOM,BASE10,<bits in byte>)
CHFMRN:	$NUMGE	(CHFCOM,BASE10,<maximum record number>)
CHFMRS:	$NUMGE	(CHFCOM,BASE10,<maximum bytes in record>)
CHFORG:	AV$TAB	(CHFCOM,CRG,FB,<IDX,REL,SEQ>)
CHFXAB:	$MACF	(CHFCOM,<XAB name>)
;
; SYMBOLIC BITS
;
CHFSHR:
CHFFAC:	AV$TAB	(CACPLU,CAC,FB,<ALL,APP,BIO,BRO,DEL,GET,NIL,PUT,TRN,UPD>) ;[2]
CACPLU:	$TOKEN	(CHFFAC,+,<$ALTERN(CHFCOM)>)
CHFFOP:	AV$TAB	(COPPLU,COP,FB,<CIF,CTG,DFW,DLT,DRJ,LKO,MKD,NAM,NIL,OFP,SCF,SPL,SUP,TMP,WAT>) ;[572]
COPPLU:	$TOKEN	(CHFFOP,+,<$ALTERN(CHFCOM)>)
CHFRAT:	AV$TAB	(CHFCOM,CRT,FB,<BLK>)
CHFRFM:	AV$TAB	(CRFPLU,CRF,FB,<FIX,LSA,SCR,SLF,STM,UDF,VAR,VFC>)	;m572
CHFALQ: $NUMGE  (CHRCOM,BASE10,<size of file>) ;[2]
CHFNAM: $MACF	(CHFCOM,<NAM block name>) ;[2]
CHFTYP:	$MACF	(CHFCOM,<TYP block name>) ;[2]
CHFFSZ: $NUMBE  (CHRCOM,BASE10,<size of fixed header>) ;[2]
CRFPLU:	$TOKEN	(CHFRFM,+,<$ALTERN(CHFCOM)>)
CHFCOM:	$COMMA	(CHAFF,<$ALTERN(CFM)>)

CHARAB:	$NOISE	(CHRFLD,AND)
CHRFLD:	AO$TAB	(CHR,<BKT,ELS,FAB,KRF,LSN,MBF,PAD,RAC,RFA,ROP,RSZ,USZ>,<$ALTERN(CHRKEY),AC$NOI(CHABTO)>)
CHRKEY:	$KEYDSP	(CHATB,<$ALTERN(CHDFLD)>)
CHRFAB:	$MACF	(CHRCOM,name of FAB)
CHRBKT: $NUMGE  (CHRCOM,8,<bucket number>)
CHRELS: $NUMGE  (CHRCOM,8,<address of end-of-line sequence>)
CHRRAC:	AV$TAB	(CRCPLU,CRAC,RB,<BFT,BLK,KEY,RFA,SEQ,TRA>)
CRCPLU:	$TOKEN	(CHRRAC,+,<$ALTERN(CHRCOM)>)
CHRROP:	AV$TAB	(CRPPLU,CROP,RB,<EOF,FDL,KGE,KGT,LOA,LOC,NIL,NRP,PAD,RAH,WAA,WBA,WBH>)
CRPPLU:	$TOKEN	(CHRROP,+,<$ALTERN(CHRCOM)>)
CHRKRF:	$NUMGE	(CHRCOM,BASE10,<key number>)
CHRLSN:	$NUMGE	(CHRCOM,BASE10,<line-sequence-number>)
CHRMBF:	$NUMGE	(CHRCOM,BASE10,<number of buffers to allocate>)
CHRPAD:	$NUMGE	(CHRCOM,8,<octal code of pad byte>)
CHRRFA: $NUMGE  (DEFRF,8,<RFA of record>)
CHRRSZ:	$NUMGE	(CHRCOM,BASE10,<bytes in record>)
CHRUSZ:	$NUMGE	(CHRCOM,BASE10,<words in record buffer>)
CHRCOM:	$COMMA	(CHARF,<$ALTERN(CFM)>)
CHARF:	$KEYDSP	(CHRTB,AC$NOI(CHABTO))

CHANAM: $NOISE	(CHANF,AND)
CHANF:	AO$TAB	(CHN,<CHA,DRA,DRL,DVA,DVL,ESA,ESL,ESS,FNB,NDA,NDL,NMA,NML,NOP,RLF,RSA,RSL,RSS,TPA,TPL,VRA,VRL,WCT,WNX>)
CHANFC:	$COMMA	(CHANF,<$ALTERN(CFM)>)
CHNCHA: AV$TAB	(CHNCOM,CNC,NA,<CEX,CNA,CDI,CDE,NIL>)			;m600
CHNDRA:	$NUMGE	(CHNCOM,8,<Byte pointer to Directory within filespec>)
CHNDRL:	$NUMGE	(CHNCOM,BASE10,<Length of Directory>)
CHNDVA:	$NUMGE	(CHNCOM,8,<Byte pointer to Device within filespec>)
CHNDVL:	$NUMGE	(CHNCOM,BASE10,<Length of Device>)
CHNESA:	$MACF	(CHNCOM,<Byte pointer to Expanded String>)
CHNESL:	$NUMGE	(CHNCOM,BASE10,<Length of Expanded String>)
CHNESS:	$NUMGE	(CHNCOM,BASE10,<Size of Expanded String buffer>)

;AV$TAB only wants 18-bit quantities
;CHNFNB:	AV$TAB	(CHNCOM,CNF,NA,<ACT,DEV,DIR,EDE,EDI,ENA,ETY,EVE,EXT,GND,INV,MUL,NAM,NIL,NOD,NHV,PRO,QUO,TFS,UHV,ULV,UNT,VER,WLD>) ; NAME OPTION BITS

CHNFNB:	$NUMGE	(CHNCOM,8,<Wildcarding Bits returned by $PARSE or $SEARCH>)
CHNNOP:	AV$TAB	(CHNPLU,CNN,NA,<NIL,PWD,SYN>)				;m600
CHNPLU:	$TOKEN	(CHNNOP,+,<$ALTERN(CHNCOM)>)
CHNNDA:	$NUMGE	(CHNCOM,8,<Byte pointer to Node Name within filespec>)
CHNNDL:	$NUMGE	(CHNCOM,BASE10,<Length of Node name>)
CHNNMA:	$NUMGE	(CHNCOM,8,<Byte pointer to File Name within filespec>)
CHNNML:	$NUMGE	(CHNCOM,BASE10,<Length of File name>)
CHNRLF:	$MACF	(CHNCOM,<NAM block name for Related File>)
CHNRSA:	$MACF	(CHNCOM,<Byte pointer to Related String>)
CHNRSL:	$NUMGE	(CHNCOM,BASE10,<Length of Related String>)
CHNRSS:	$NUMGE	(CHNCOM,BASE10,<Size of Related String buffer>)
CHNTPA:	$NUMGE	(CHNCOM,8,<Byte pointer to File Type within filespec>)
CHNTPL:	$NUMGE	(CHNCOM,BASE10,<Length of File Type>)
CHNVRA:	$NUMGE	(CHNCOM,8,<Byte pointer to Version Number within filespec>)
CHNVRL:	$NUMGE	(CHNCOM,BASE10,<Length of Version Number>)
CHNWCT:	$NUMGE	(CHNCOM,BASE10,<Number of files processed on this wildcard>)
CHNWNX:	$NUMGE	(CHNCOM,BASE10,<Length of filespec already processed>)
CHNCOM: $COMMA	(CHANF,<$ALTERN(CFM)>)

CHATYP: $NOISE	(CHATF,AND)
CHATF:	AO$TAB	(CHT,<CLA,FDT,FLN,FSC,MOR,NEX>)
CHTCLA:	AV$TAB	(CHTCOM,CTC,TY,<ASC,BYT,IMA,M11>,$ALTERN(CHTCLV))
CHTCLV: $NUMBE	(CHTCOM,8,<Value of File Class>)
CHTFDT:	AV$TAB	(CHTCOM,CTD,TY,<ASC,BYT,IMA,M11>,$ALTERN(CHTFDV))
CHTFDV: $NUMBE	(CHTCOM,8,<Value of Field Data Type>)
CHTFLN:	$NUMGE	(CHTCOM,BASE10,<Length of Field>)
CHTFSC:	$NUMGE	(CHTCOM,BASE10,<Scale Factor>)
CHTMOR:	$MACF	(CHTCOM,<TYP block name for variant record>)
CHTNEX:	$MACF	(CHTCOM,<TYP block name for next field>)
CHTCOM: $COMMA	(CHATF,<$ALTERN(CFM)>)

CHAXA:	$NOISE	(CHAXAF,AND)
CHAXC:	$NOISE	(CHAXCF,AND)
CHAXD:	$NOISE	(CHAXDF,AND)
CHAXK:	$NOISE	(CHAXKF,AND)
CHAXS:	$NOISE	(CHAXSF,AND)
CXANXT:
CXCNXT:
CXDNXT:
CXKNXT:
CXSNXT:
	$MACF	(CHXCOM,name of next XAB)

CHAXAF:	AO$TAB	(CXA,<AID,BKZ,NXT>,AC$NOI(CHABTO))
CXAAID:	$NUMGE	(CHXCOM,BASE10,<area ID>)
CXABKZ:	$NUMGE	(CHXCOM,BASE10,<words in bucket>)

CHAXDF:
CHAXSF:
CHAXCF:
	AO$TAB	(CXD,<NXT>,AC$NOI(CHABTO))

CHAXKF:	AO$TAB	(CXK,<DAN,DFL,DTP,FLG,IAN,IFL,KNM,NXT,PS0,PS1,PS2,PS3,REF,SZ0,SZ1,SZ2,SZ3>,AC$NOI(CHABTO))
CXKDTP:	AV$TAB	(CHXCOM,CXKD,XB,<AS8,EBC,FL1,FL2,GFL,IN4,IN8,PAC,SIX,STG,UN4>)
CXKFLG:	AV$TAB	(CXKFPL,CXKF,XB,<CHG,DUP,NIL>)
CXKFPL:	$TOKEN	(CXKFLG,+,<$ALTERN(CHXCOM)>)
CXKKNM:	$FILEF	(CHXCOM,<name of key>)
CXKDAN:	$NUMGE	(CHXCOM,BASE10,<area ID of data bucket>)
CXKDFL:	$NUMGE	(CHXCOM,BASE10,<data fill word count>)
CXKIAN:	$NUMGE	(CHXCOM,BASE10,<area ID of index bucket>)
CXKIFL:	$NUMGE	(CHXCOM,BASE10,<index fill word count>)
CXKPOS:
CXKPS0:
CXKPS1:
CXKPS2:
CXKPS3:	$NUMGE	(CHXCOM,BASE10,<starting byte number of key segment>)
CXKREF:	$NUMGE	(CHXCOM,BASE10,<key number>)
CXKSIZ:
CXKSZ0:
CXKSZ1:
CXKSZ2:
CXKSZ3:	$NUMGE	(CHXCOM,BASE10,<number of bytes in key segment>)
CHXCOM:	$COMMA	(0,<$ACTION(CXXNXT),$ALTERN(CFM)>)

CHDTDE:	$NOISE	(CHDDEC,TO)
CHDDEC:	$NUMBER	(CHDCOM,BASE10)

CHDTTX:	$NOISE	(CHDTEX,TO)
CHDTEX:	$QUOTE	(CHDCOM,<quoted text>)

CHDTFL:	$NOISE	(CHDFLT,TO)
CHDFLT: $FLOAT	(CHDCOM,<Floating-Point number>)			;A411

CHDTGF:	$NOISE	(CHDGFL,TO)
CHDGFL: $UQSTR	(CHDCOM,FLTMSK,<Floating-Point number>)			;A411

CHDTPA:	$NOISE	(CHDPAC,TO)
CHDPAC: $UQSTR	(CHDCOM,PACMSK,<Packed-decimal number>)			;A411

BRINI.
BRKCH.	(0,37)			;Break on control characters
BRKCH.	(40,52)			;Break on Space thru *
BRKCH.	(54,54)			;Break on ,
BRKCH.	(57,57)			;Break on /
BRKCH.	(72,103)		;Break on : thru C
BRKCH.	(110,143)		;Break on H thru c
BRKCH.	(150,177)		;Break on h thru rubout

FLTMSK: EXP W0.,W1.,W2.,W3.		;Mask for floating-point	;A411

UNBRK.	"."
UNBRK.	"D"
UNBRK.	"E"
UNBRK.	"F"
UNBRK.	"G"
UNBRK.	"d"
UNBRK.	"e"
UNBRK.	"f"
UNBRK.	"g"

PACMSK: EXP W0.,W1.,W2.,W3.		;Mask for packed decimal	;A411

CHDCOM:	$COMMA	(CHDFLD,<$ALTERN(CFM)>)
CHDFLD:	$MACF	(CHADAT,name of datafield)


CHAFST:
CHARST:
CHAKDB: $CRLF
SUBTTL	SYNTAX FOR DEFINE CMD

; DEFINE FAB new-name (FOR) file-name [/FIELD-KYWD:VALUE ...]
; DEFINE RAB new-name (FOR) FAB-name [/FIELD-KYWD:VALUE ...]
; DEFINE XAB new-name (FOR) ALLOCATION!DATE!KEY!SUMMARY [/FIELD-KYWD:VALUE ...]
; DEFINE NAM nem-name (FOR) FAB-name [/FIELD-KYWD:VALUE ...]
; DEFINE DATAFIELD new-name [/POS /SIZE /TYPE]

.DEFIN:	$NOISE	(DEFTPN,<TYPE OF NAME>)
DEFTPN:	OP$TAB	(DEF,<DATAFIELD,FAB,NAM,RAB,TYP,XAB>,<AC$NOI(DEFNMI)>)
			;M510 fix naming conflict

; DEFINE FAB
;
DEFFAB:	$MACF	(DEFFI,<FAB name>)
DEFFI:	$NOISE	(DEFFN,FOR)
DEFFN:	$FILEF	(DEFFF,<file name>)
DEFFF:	AS$TAB	(DFF,<ALQ,BKS,BSZ,FAC,FOP,FSZ,MRN,MRS,NAM,ORG,RAT,RFM,SHR,TYP,XAB>,<$ALTER(DEFFDF)>) ;[2]
DEFFDF:	$CRLF	($HELP<confirm with CRLF (defaults are BSZ=7 FAC=GET MRS=250 ORG=SEQ RFM=VAR SHR=NIL)>)
DFFBKS:	$NUMGE	(DEFFF,BASE10,<number of pages per bucket>)
DFFBSZ:	$NUMGE	(DEFFF,BASE10,<bits in byte>)
DFFMRN:	$NUMGE	(DEFFF,BASE10,<maximum record number>)
DFFMRS:	$NUMGE	(DEFFF,BASE10,<maximum bytes in record>)
DFFFSZ:	$NUMGE	(DEFFF,BASE10,<size of fixed header>) ;[2]
DFFALQ:	$NUMGE	(DEFFF,BASE10,<size of file>) ;[2]
DFFORG:	AV$TAB	(DEFFF,DRG,FB,<IDX,REL,SEQ>)
DFFXAB:	$MACF	(DEFFF,<XAB name>)
DFFTYP:	$MACF	(DEFFF,<TYP block name>) ;[2]
DFFNAM:	$MACF	(DEFFF,<NAM block name>) ;[2]
;
; SYMBOLIC BITS
;
DFFSHR:
DFFFAC:	AV$TAB	(DACPLU,DAC,FB,<ALL,APP,BIO,BRO,DEL,GET,NIL,PUT,TRN,UPD>) ;[2]
DACPLU:	$TOKEN	(DFFFAC,+,<$ALTERN(DEFFF)>)
DFFFOP:	AV$TAB	(DOPPLU,DOP,FB,<CIF,CTG,DFW,DLT,DRJ,NIL,LKO,MKD,NAM,OFP,SCF,SPL,SUP,TMP,WAT>) ;[2]
DOPPLU:	$TOKEN	(DFFFOP,+,<$ALTERN(DEFFF)>)
DFFRAT:	AV$TAB	(DEFFF,DRT,FB,<BLK>)
DFFRFM:	AV$TAB	(DRFPLU,DRF,FB,<FIX,LSA,SCR,SLF,STM,UDF,VAR,VFC>)	;m572
DRFPLU:	$TOKEN	(DFFRFM,+,<$ALTERN(DEFFF)>)

;
; DEFINE NAM
;
;							;A510 VV
DEFNAM:	$MACF	(DEFNF,<NAM block name>)
DEFNF:	AS$TAB	(DFN,<NOP>,<$ALTERN(DEFNDF)>)
DEFNDF:	$CRLF	($HELP<confirm with CRLF>)
DFNNOP:	AV$TAB	(DNMPLU,DNAM,NA,<PWD,SYN>)
DNMPLU:	$TOKEN	(DFNNOP,+,<$ALTERN(DEFNF)>)
							;A510 ^^

;
; DEFINE TYP
;
;							;A510 VV
DEFTYP:	$MACF	(DEFTF,<TYP block name>)
DEFTF:	AS$TAB	(DTY,<CLA,FDT,FLN,FSC,MOR,NEX>,<$ALTERN(DEFTDF)>)
DEFTDF:	$CRLF	($HELP<confirm with CRLF>)
DTYCLA:	AV$TAB	(DEFTF,DCLA,TY,<ASC,BYT,IMA,M11>)
DTYFDT:	AV$TAB	(DEFTF,DFDT,TY,<ASC,BYT,IMA,M11>)
DTYMOR: $FNAME	(DEFTF,<Name of Next Variant Typ block>)
DTYNEX: $FNAME	(DEFTF,<Name of Next Field Typ block>)
DTYFSC: $NUMGE	(DEFTF,BASE10,<Scale Factor>)
DTYFLN: $NUMGE	(DEFTF,BASE10,<Length of Field>)
							;A510 ^^

; DEFINE RAB
;
DEFRAB:	$MACF	(DEFRFB,<RAB name>)
DEFRFB:	$NOISE	(DEFRFN,FOR)
DEFRFN:	$FNAME	(DEFRF,<name of FAB to connect to>)
DEFRF:	AS$TAB	(DFR,<BKT,ELS,KRF,LSN,MBF,PAD,RAC,RFA,ROP,RSZ,USZ>,<$ALTERN(DEFRDF)>)
DEFRDF:	$CRLF	($HELP<confirm with CRLF (defaults are KSZ=30 RAC=SEQ ROP=WBH USZ=50)>)

DFRRAC:	AV$TAB	(DRCPLU,DRAC,RB,<BFT,BLK,KEY,RFA,SEQ,TRA>)
DRCPLU:	$TOKEN	(DFRRAC,+,<$ALTERN(DEFRF)>)
DFRROP:	AV$TAB	(DRPPLU,DROP,RB,<EOF,FDL,KGE,KGT,LOA,LOC,NIL,NRP,PAD,RAH,WAA,WBA,WBH>)
DRPPLU:	$TOKEN	(DFRROP,+,<$ALTERN(DEFRF)>)
DFRKRF:	$NUMGE	(DEFRF,BASE10,<key number>)
DFRLSN:	$NUMGE	(DEFRF,BASE10,<line-sequence-number>)
DFRBKT: $NUMGE  (DEFRF,8,<bucket number>)
DFRELS: $NUMGE  (DEFRF,8,<address of end-of-line sequence>)
DFRMBF:	$NUMGE	(DEFRF,BASE10,<number of buffers to allocate>)
DFRRFA: $NUMGE  (DEFRF,8,<RFA of record>)
DFRPAD:	$NUMGE	(DEFRF,8,<octal code of pad byte>)
DFRRSZ:	$NUMGE	(DEFRF,BASE10,<bytes in record>)
DFRUSZ:	$NUMGE	(DEFRF,BASE10,<words in record buffer>)

; DEFINE XAB
;
DEFXAB:	$MACF	(DEFXBC,<XAB name>)
DEFXBC:	$NOISE	(DEFXCO,FOR)
DEFXCO:	SO$TAB	(DXC,XB,<AREA,CONFIG,DATE,KEY,SUMMARY>)			;M554
DXCCON:
DXCDAT:
DXCSUM:
	AS$TAB	(DXS,<NXT>,$ALTERN(CFM))
DXSNXT:	$MACF	(CFM,name of next XAB)

DXCARE:	AS$TAB	(DXA,<AID,BKZ,NXT>,<$ALTERN(DXCADF)>)
DXCADF:	$CRLF	($HELP<confirm with CRLF (defaults are AID=1 BKZ=1)>)
DXAAID:	$NUMGE	(DXCARE,BASE10,<area ID>)
DXABKZ:	$NUMGE	(DXCARE,BASE10,<number of pages in bucket>)
DXANXT:	$MACF	(DXCARE,name of next XAB)

DXCKEY:	AS$TAB	(DXK,<DAN,DFL,DTP,FLG,IAN,IFL,KNM,NXT,POS,REF,SIZ>,<$ALTERN(DXCKDF)>)
DXCKDF:	$CRLF	($HELP<confirm with CRLF (defaults are DTP=STG SIZ=1)>)

DXKDTP:	AV$TAB	(DXCKEY,DXKD,XB,<AS8,EBC,FL1,FL2,GFL,IN4,IN8,PAC,SIX,STG,UN4>)
DXKFLG:	AV$TAB	(DXKFPL,DXKF,XB,<CHG,DUP,NIL>)
DXKFPL:	$TOKEN	(DXKFLG,+,<$ALTERN(DXCKEY)>)
DXKDAN:	$NUMGE	(DXCKEY,BASE10,<area ID of data bucket>)
DXKDFL:	$NUMGE	(DXCKEY,BASE10,<max # of words to load into data bucket>)
DXKIAN:	$NUMGE	(DXCKEY,BASE10,<area ID of index bucket>)
DXKIFL:	$NUMGE	(DXCKEY,BASE10,<max # of words to load into index bucket>)
DXKKNM:	$FILEF	(DXCKEY,<name of key for $DISPLAY>)
DXKNXT:	$MACF	(DXCKEY,name of next XAB)
DXKPOS:	$NUMGE	(DXKPOC,BASE10,<starting byte number of key segment>)
DXKPOC:	$TOKEN	(DXKPOS,:,<$ALTERN(DXCKEY)>)
DXKREF:	$NUMGE	(DXCKEY,BASE10,<key number>)
DXKSIZ:	$NUMGE	(DXKSIC,BASE10,<number of bytes in key segment>)
DXKSIC:	$TOKEN	(DXKSIZ,:,<$ALTERN(DXCKEY)>)

; DEFINE FIELD
;
DISW%D==DFT%DEC
DISW%O==DFT%OCT
DESW%D==0
DEFDAT:	$MACF	(DEFDAS,<field name>)
DEFDAS:	$NOISE	(DEDTYP,WITH TYPE)
DEDTYP:	OP$TAB	(DFT,<ASCII,<FILE,BYTES>,<DOUBLE,DOUBLE_FLOATING>,FLOATING,GFLOATING,INTEGER,<LONG,LONG_INTEGER>,PACKED,SIXBIT,UNSIGNED>)

DFTUNS:
DFTDOU:
DFTFLO:
DFTGFL:
DFTLON:
DFTINT:	$NOISE	(DEDWRD,STARTING AT WORD)
DEDWRD:	$NUMGE	(DEDISW,BASE10,<number of words before field>,$ALTERN(DEDISW))
DEDISW:	SW$TAB	(DESW,<DISPLAY>,$ALTERN(CFM))
DESWDI:	KY$TAB	(CFM,DISW,<DECIMAL,OCTAL>,$ALTERN(CFM))

DFTASC:
DFTFIL:
DFTPAC:
DFTSIX:	$NOISE	(DEDLEN,WITH LENGTH)
DEDLEN:	$NUMGT	(DEDBYT,BASE10,<number of bytes in field>)
DEDBYT:	$NOISE	(DEDBNM,STARTING AT BYTE)
DEDBNM:	$NUMGE	(CFM,BASE10,<number of bytes before field>,$ALTERN(CFM))
SUBTTL	SYNTAX OF DISPLAY COMMAND

; DISPLAY argblk-name [FIELD-KYWD-list]
; DISPLAY [RAB-name] DATA!KEY-BUFFER!field-name-list

.DISPL:	$NOISE	(DISTP,VALUE IDENTIFIED BY)
DISTP:	KY$TAB	(CFM,DISD,<DATA,<KEY,KEY-BUFFER>>,<$ALTERN(DISFLD)>)
DISFLD:	$MACF	(0,<argblk or datafield name>,$ACTION(DISCAS))

DISFAB:	$NOISE	(DISFF,AND)
DISFF:	AK$TAB	(DISFFC,DISF,<ALQ,BKS,BSZ,DEV,FAC,FNA,FOP,FSZ,IFI,JFN,MRN,MRS,NAM,ORG,RAT,RFM,SHR,STS,STV,TYP,XAB>,<$ALTERN(CFM)>)
DISFFC:	$COMMA	(DISFF,<$ALTERN(CFM)>)

DISNAM: $NOISE	(DISTN,AND)						;m600
DISTN:	KY$TAB	(CFM,DSN,<DEVICE,DIRECTORY,<EXP,EXPANDED-STRING>,NAME,NODE,<RES,RESULTANT-STRING>,TYPE,VERSION>,<$ALTERN(DISNF)>)	;a600
DISNF:	AK$TAB	(DISNFC,DISN,<CHA,DRA,DRL,DVA,DVL,ESA,ESL,ESS,FNB,NDA,NDL,NMA,NML,NOP,RLF,RSA,RSL,RSS,TPA,TPL,VRA,VRL,WCT,WNX>,<$ALTERN(CFM)>)
DISNFC:	$COMMA	(DISNF,<$ALTERN(CFM)>)

DISTYP: $NOISE	(DISTF,AND)
DISTF:	AK$TAB	(DISTFC,DIST,<CLA,FDT,FLN,FSC,MOR,NEX>,<$ALTERN(CFM)>)
DISTFC:	$COMMA	(DISTF,<$ALTERN(CFM)>)

DISRAB:	$NOISE	(DIRFLD,AND)
DIRFLD:	AK$TAB	(DISRFC,DISR,<BKT,FAB,ISI,KBF,KRF,KSZ,LSN,MBF,PAD,RAC,RBF,RFA,ROP,RSZ,STS,STV,UBF,USZ>,<$ALTERN(DISRD)>)
DISRFC:	$COMMA	(DISRF,<$ALTERN(CFM)>)
DISRF:	$KEY	(DISRFC,DISRTB)
DISRD:	$KEY	(CFM,DISDTB,<$ALTERN(DIRCFM)>)
DIRCFM:	$CRLF	($ALTERN(DIDFLD))

DISXA:	$NOISE	(DISXAF,AND)
DISXC:	$NOISE	(DISXCF,AND)
DISXD:	$NOISE	(DISXDF,AND)
DISXK:	$NOISE	(DISXKF,AND)
DISXS:	$NOISE	(DISXSF,AND)

DISXAF:	AK$TAB	(DISXFC,DIXA,<AID,BKZ,NXT>,$ALTERN(CFM))
DISXCF: AK$TAB  (DISXFC,DIXC,<BFS,CAP,DSV,ECO,FIL,OST,USN,USV,VER>,$ALTERN(CFM))
DISXDF:	AK$TAB	(DISXFC,DIXD,<CDT,EDT,NXT,RDT>,$ALTERN(CFM))
DISXKF:	AK$TAB	(DISXFC,DIXK,<DAN,DFL,DTP,FLG,IAN,IFL,KNM,NXT,POS,REF,SIZ>,<$ALTERN(CFM)>)
DISXSF:	AK$TAB	(DISXFC,DIXS,<NOA,NOK,NXT>,$ALTERN(CFM))
DISXFC:	$COMMA	(0,<$ACTION(CXXNXT),$ALTERN(CFM)>)

DIDFLD:	$MACF	(DIDCMA,<name of datafield>)
DIDCMA:	$COMMA	(DIDFLD,<$ALTERN(CFM)>)

DISFST:
DISRST:
DISKDB: $CRLF
SUBTTL	SYNTAX FOR INFORMATION CMD

; INFO ALL!FABS!DATAFIELDS!RABS!XABS

.INFOR:	$NOISE	(INFTYP,ABOUT)
INFTYP:	KY$TAB	(CFM,INF,<ALL,CONTEXT,DATAFIELDS,FABS,RABS,XABS>) ;,<$ALTERN(INFNAM)>)
;INFNAM:	$MACF	(INFCMA,<name of FAB, RAB, XAB, or datafield>)
;INFCMA:	$COMMA	(INFNAM,<$ALTERN(CFM)>)
SUBTTL	SYNTAX FOR UNDEFINE CMD

; UNDEFINE name-list

.UNDEF:	$NOISE	(UNDNAM,NAME)
UNDNAM:	$MACF	(UNDCMA,<name of FAB, RAB, XAB, or datafield>)
UNDCMA:	$COMMA	(UNDNAM,<$ALTERN(CFM)>)

END