Google
 

Trailing-Edge - PDP-10 Archives - RMS-10_T10_704_FT2_880425 - 10,7/rms10/rmssrc/utlcmd.mac
There are 6 other files named utlcmd.mac in the archive. Click here to see a list.
TITLE	UTLCMD - SYNTAX TABLES FOR RMSUTL
SUBTTL A. UDDIN
SEARCH	RMSMAC,RMSINT,CMDPAR
$PROLOG(UTL)

P$COLON==0				;;INIT DEF OF IT
LSS==74b6				;;BECAUSE OF A MACRO BUG
GTR==76B6
LE==361720,,0
GE==371720,,0

; $AID - DEFINE NUMERIC FLD THAT IS USED TO IDENTIFY AN AREA ID
;
DEFINE $AID(NEXT$,KDOPT$,%NUM)<
	$NOISE	(%NUM,#)		;;INDIC CLASS RATHER THAN SCALAR
%NUM:	$NUMGE	(NEXT$,BASE10,area ID,<KDOPT$>)
>

; 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$)<E.'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$)<E.'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$)<E.'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$>)>

; $INDEX - DEFINE NUMERIC FLD THAT IS USED TO IDENTIFY AN ELEMENT OF A CLASS
;
DEFINE $INDEX(NEXT$,KDOPT$,%NUM)<
	$NOISE	(%NUM,#)		;;INDIC CLASS RATHER THAN SCALAR
%NUM:	$NUMGT	(NEXT$,BASE10,positive decimal number,<KDOPT$>)
>

; $KREF - DEFINE NUMERIC FLD THAT IS USED TO IDENTIFY A KEY OF REFERENCE
;
DEFINE $KREF(NEXT$,KDOPT$,%NUM)<
	$NOISE	(%NUM,#)		;;INDIC CLASS RATHER THAN SCALAR
%NUM:	$NUMGE	(NEXT$,BASE10,key of reference,<KDOPT$>)
>

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

SUBTTL	DATA DECLARATIONS

BASE10==^D10				;FOR $NUM--- MACRO
BASE8==8

$IMPURE
$GDATA	(PDBPAG,1000)			;BLOCK FOR PARSED DATA

$DATA	(CHENT)				;ON IF CHANGING ENTRY (AS OPP ID)
$DATA	(QRFADO)			;VAR FOR RET VAL FROM RFADO
$DATA	(QVALDF)			;VAR FOR RET VAL FROM VALDF
$DATA	(VALDF)				;VAR FOR PDB OF CURR FLD'S DATTYP

CHABTO:	$NOISE	(0,TO)			;FOR AC$NOI IN CHANGE

$PURE

MSKFIL:
	FLDB0.				;WORD-N OF MASK
	FLDB1.&<^-<1B12!1B14!1B26!1B28!1B30>>
					;B12=, B14=. B26=: B28=< B30=>
	FLDB2.&<^-<1B27!1B29>>		;B27=[ B29=]
	FLDB3.
MSKMAC:
	FLDB0.				;WORD-N OF MASK
	FLDB1.&<^-<1B4!1B5!1B13!1B14>>	;B4=$ B5=% B13=- B14=.
	FLDB2.
	FLDB3.

SUBTTL	ACTION ROUTINES

; ACTION ROUTINES ARE EFFECTIVELY PART OF CMDPAR
; CMDPAR CALLS THEM WITH:
;	T1 = LENGTH OF CMD DATA BLK
;	T2 = ITS ADDR
; YOU SHOULD RETURN:
;	TF = -1 IF SUCCESSFUL
;	TF = 0 IF FAILED, WITH T2 = PTR TO ASCIZ ERR MSG

CHENACT:				;ACTION ROUTINE FOR CHANGE BKT ENT
	SETOM	CHENT			;INDIC CHANGE ENT
	JRST	CIEACT			;MERGE
CHIDACT:				;ACTION ROUTINE FOR CHANGE BKT ID
	SETZM	CHENT			;INDIC ID

CIEACT:
;
; SET PDB ON BASIC OF TYPE OF ENTRY BEING CHANGED
;
	MOVE	T1,UTLFLG		;CHK IF FILE OPEN
	TXNE	T1,UT%FOP		;IS IT?
	$SKIP				;NO
		MOVEI	T2,[ASCIZ/File not open/]
		SETZM	TF
		POPJ	P,
	$ENDIF
	MOVE	T1,CU$TYPE		;GET BKT INFO
	CASES	T1,MX%BTY
$CASE	(BTY%CLOB)
	MOVEI	T2,[ASCIZ/Current bucket has bad header/]
	SETZM	TF			;FAILURE RETURN
	POPJ	P,
$CASE	(BTY%IDX)
	MOVEI	T5,CIESET		;YES
	SKIPGE	CHENT			;ENTRY # SPEC?
	JRST	L$CASX			;YES, NO PROB
	MOVEI	T2,[ASCIZ/Current bucket not a data bucket/]
	SETZM	TF			;FAILURE RETURN
	POPJ	P,
$CASE	(BTY%PRIM)
	MOVE	T2,FAB			;ADDR OF FAB
	MOVEI	T5,CVESET		;ASSUME VAR LENGTH RECORDS
	$FETCH	T1,RFM,(T2)		;CHECK RECORD FORMAT
	CAIE	T1,FB$VAR		;VARIABLE FORMAT?
	MOVEI	T5,CFESET		;FIXED HEADER FORMAT
	JRST	L$CASX
$CASE	(BTY%SEC)
	MOVEI	T5,CSESET		;SECONDARY BKT.
$CASX
	MOVEM	T5,.NEXT		;SET NEXT PDB
	SETOM	TF			;SUCC RET
	POPJ	P,

SETDFV:
;
; ACTION ROUTINE FOR DATAfield VALUE, SET PDB FROM DATA TYPE OF FLD
;
	MOVE	T5,CR.SAV(T2)		;GET ADDRESS OF PARSE DATA
	$CALL	SY.FIND,<0(T5)>		;PASS THE CURR TOK
	JUMPT	L$IFX			;A MATCH?
	  MOVEI	T2,[ASCIZ/Name not known/] ;NO, TELL CALLER
	  SETZM	TF			;FAILURE RET
	  POPJ	P,
	$ENDIF
	MOVEI	T5,VALQUO		;ASSUME STRING
	LOAD	T2,UF.TYP(T1)		;GET ACTUAL DATA TYPE
	CAIN	T2,DFT%DEC		;IS IT DEC INTEGER?
	MOVEI	T5,VALDEC		;YES
	CAIN	T2,DFT%OCT		;IS IT OCTAL INT?
	MOVEI	T5,VALOCT		;YES
	CAIN	T2,DFT%FLO		;IS IT FLOATING PT VAL?
	MOVEI	T5,VALFLO		;YES
	MOVEM	T5,VALDF		;SETUP NEXT PDB
	SETOM	T1
	POPJ	P,

REDCAS:
;
; ACTION ROUTINE FOR REDEFINE, SET PDB FROM TYPE OF SYMBOL
;
	MOVE	T5,CR.SAV(T2)		;GET ADDRESS OF PARSE DATA
	$CALL	SY.FIND,<0(T5)>		;PASS THE DATA FOR CURR TOK
	JUMPT	L$IFX			;A MATCH?
	  MOVEI	T2,[ASCIZ/Name not known/] ;NO, TELL CALLER
	  SETZM	TF			;FAILURE RET
	  POPJ	P,
	$ENDIF
	SETZM	T3			;INDIC NO PDB SET YET
	$FETCH	T2,BID,(T1)		;GET TYPE OF FLD
	CAIN	T2,DA$TYP		;DAT FLD?
	MOVEI	T3,DEFDAS		;YES
	CAIE	T2,XA$TYP		;XAB?
	$SKIP				;YES
	  $FETCH T2,COD,(T1)		;GET TYPE OF XAB
	  CAIN	T2,XB$KEY		;KEY?
	  MOVEI	T3,DEFXBC		;YES
	  CAIN	T2,XB$ALL		;AREA?
	  MOVEI	T3,DEFBKZ		;YES
	$ENDIF
	JUMPE	T3,L$ERRU(IUE)		;UNKNOWN TYPE CODES IN BLK
	MOVEM	T3,.NEXT		;SET NEXT PDB
	SETOM	TF			;SUCC RET
	POPJ	P,

SUBTTL	TOP-LEVEL SYNTAX OF RMSUTL

UTLCMD::			 	;ARG BLK PASSED ON EACH PARSE$ CALL
	CMDINI				;1ST PDB PASSED TO COMND ON EACH CMD
	[ASCIZ/RMSUTL>/]		;PROMPT STRING
	PDBPAG				;PAGE FOR PARSED DATA
	0				;USE TTY FOR CMD INPUT & OUTPUT

CMDINI:	$INITC(CMDS)			;THE INIT-CMD PARSER DESC BLK

CMDS:	CM$TAB	(<CHANGE,CLOSE,DEFINE,DELETE,DISPLAY,EXIT,FIX,HELP,INFORMATION,OPEN,REDEFINE,SET,SPACE,TAKE,UNCLUTTER,VERIFY>,$BREAK(MSKMAC))

CFM:	$CRLF			;CRLF IS COMMON TERMINATOR OF COMMANDS

SUBTTL	SYNTAX OF CHANGE COMMAND

;General Syntax:
;---------------
;
; CHANGE (VALUE OF) object location (SETTING) to-list
;	 WHERE <to-list> IS:  <field-name> (TO) <value>

; TOP-LEVEL DISPATCH
;
VAR$AD==QVALDF			;FOR AC$SET TO CHANGE DATFLD
.CHANG:	$NOISE (CHAENT,VALUE OF,<AC$SET(CHDCOM)>)
CHAENT:	OP$TAB	(CHA,<BUCKET,<PROLOGUE,PROLOGUE-DATA>>,<$ALTERN(CHADF)>)


;CHANGE to-list (FOR RECORDS IDENTIFIED BY) records-to-use
;

;CHGDAT:$SUB	(CHDCOM,CHADF)	;BECAUSE CHG DF IS $ALTERN, QVALDF PRESET
CHDCOM:	$COMMA	(CHADF,<$ALTERN(RTUSEL)>)

CHADF:	$MACF	(CHDTO,<datafield-name>,$ACTION(SETDFV))
CHDTO:	$NOISE	(@VALDF,<TO>)

CBEDF:	KY$WRD	(CBEDFN,CBED,DATAFIELD)	;MERGE FOR CHANGE BKT ENTRY datafld-list
CBEDFN:	$NOISE	(CHADF,NAMED)		;...CAN BE CAUSE QVALDF ALREADY SET	

;CHANGE (VALUE OF) BUCKET (AT) HEADER!ENTRY n1!ID n2 (SETTING) to-list


; CHANGE BUCKET DISPATCH
;
CHABUC:	$NOISE	(BUCOPT,<AT>)
BUCOPT:	OP$TAB	(CHG,<ENTRY,HEADER,ID>)

; CHANGE BUCKET HEADER
;

CHGHEA:	$NOISE	(HTOLST,<SETTING>)
CBHCOM:	$COMMA	(HTOLST,$ALTERN(CFM))
HTOLST:	AO$TAB	(CBH,<<ANO,<AREA-NUMBER>>,<IBA,ATTRIBUTES>,<LID,<LAST-ID>>,LEVEL,<NBP,<NEXT-BUCKET>>,<NID,<NEXT-ID>>,<IBT,TYPE>,<WIU,WORDS-IN-USE>>,AC$NOI(CHABTO))
CBHANO:	$NUMGE	(CBHCOM,BASE10,<area-ID of bucket>)
CBHIBT:	AV$TAB	(CBHCOM,IBT,IB,<DATA,INDEX>)
CBHLID:	$NUMGE	(CBHCOM,BASE10,<maximum ID for this bucket>)
CBHLEV:	$NUMGE	(CBHCOM,BASE10,<# of index levels to data-level>)
CBHNBP:	$NUMGE	(CBHCOM,BASE10,<page number of next bucket>)
CBHNID:	$NUMGE	(CBHCOM,BASE10,<ID that will be assigned next entry>)
CBHWIU:	$NUMGE	(CBHCOM,BASE10,<# of words used in bucket>)

CBHIBA:	AV$TAB	(CIBAPL,IBA,IB,<NIL,RIGHTMOST,ROOT>)
CIBAPL:	$TOKEN	(CBHIBA,+,<$ALTERN(CBHCOM)>)

;CHANGE ENTRY: GET OBJECT NUMBER & SETUP OPTIONS FOR REMAINDER OF CMD LINE

CHGID:	$INDEX	(0,$ACTION(CHIDACT))
CHGENT:	$INDEX	(0,$ACTION(CHENACT))

; CHANGE ENTRY to-list FOR INDEX ENTRY
;
CIESET:	$NOISE	(CIEOPT,<SETTING>)
CIEOPT:	AO$TAB	(CIE,<<IRA,ATTRIBUTES>,<DBP,DOWN-POINTER>,<IKV,KEY-VALUE>>,AC$NOI(CHABTO))
CIEDBP:	$NUMGT	(CIECMA,BASE10,<page number of a bucket>)
CIEIKV:	$QUOTE	(CIECMA,<Quoted key>)
CIECMA:	$COMMA	(CIEOPT,<$ALTERN(CFM)>)

CIEIRA:	AV$TAB	(CIATPL,IAT,IR,<HIKEY,NIL>)
CIATPL:	$TOKEN	(CIEIRA,+,<$ALTERN(CIECMA)>)

; CHANGE ENTRY to-list FOR VARIABLE-LENGTH UDR
;
VAR$AD==QVALDF			;FOR AC$SET
CVESET:	$NOISE	(CVEOPT,SETTING,<AC$SET(CVECMA)>)
CVEOPT:	AO$TAB	(CVE,<<IRA,ATTRIBUTES>,<RID,ENTRY-ID>,RFA,<IRS,SIZE>>,<$ALTERN(CBEDF),AC$NOI(CHABTO)>)

CVERID:	$NUMGT	(CVECMA,BASE10,<ID to assign this entry>)
CVERFA:	$SUB	(CVECMA,RFADO)
CVEIRS:	$NUMGE	(CVECMA,BASE10,<bytes in the record>)
CVECMA:	$COMMA	(CVEOPT,<$ALTERN(CFM)>)

CVEIRA:	AV$TAB	(CVATPL,VAT,IR,<DELETED,KEEP,NIL,POINTER>)
CVATPL:	$TOKEN	(CVEIRA,+,<$ALTERN(CVECMA)>)

; CHANGE ENTRY to-list FOR FIXED-LENGTH UDR
;
VAR$AD==QVALDF			;FOR AC$SET
CFESET:	$NOISE	(CFEOPT,SETTING,<AC$SET(CFECMA)>)
CFEOPT:	AO$TAB	(CFE,<<RID,ENTRY-ID>,RFA>,<$ALTERN(CBEDF),AC$NOI(CHABTO)>)
CFERID:	$NUMGT	(CFECMA,BASE10,<ID to assign this entry>)
CFERFA:	$SUB	(CFECMA,RFADO)
CFECMA:	$COMMA	(CFEOPT,<$ALTERN(CFM)>)

CFEIRA:	AV$TAB	(CFATPL,FAT,IR,<DELETED,KEEP,NIL,POINTER>)
CFATPL:	$TOKEN	(CFEIRA,+,<$ALTERN(CFECMA)>)

; CHANGE ENTRY to-list FOR SIDR ENTRY
;
CSESET:	$NOISE	(CSEOPT,<SETTING>)
CSEOPT:	AO$TAB	(CSE,<<RID,ENTRY-ID>,<SKV,KEY-VALUE>,<SRS,SIZE>>,<$ALTERN(CSRFA),AC$NOI(CHABTO)>)
CSERID:	$NUMGT	(CSECMA,BASE10,ID to assign this entry)
CSESKV:	$QUOTE	(CSECMA,<Quoted key>)
CSESRS:	$NUMGT	(CSECMA,BASE10,# of words after header)
CSECMA:	$COMMA	(CSEOPT,<$ALTERN(CFM)>)

CSEIRA:	AV$TAB	(CSATPL,SAT,IR,<NIL>)
CSATPL:	$TOKEN	(CSEIRA,+,<$ALTERN(CSECMA)>)

CSRFA:	AO$TAB	(CSR,<<RFEL,RFA>>)
CSRRFE:	$INDEX	(CSRFTO)
	VAR$AD==QRFADO			;CANT ALTERN TO SUB
CSRFTO:	$NOISE	(CSRRFA,TO,AC$SET(CSECMA))
CSRRFA:	KY$WRD	(CSECMA,RNIL,<NIL>,$ALTERN(RFADO))

;CHANGE (VALUE OF) PROLOG-DATA (FOR) FILE!AREA n1!KEY n2 (SETTING) to-list
;

CHAPRO:	$NOISE	(CPROPT,<FOR>)
CPROPT:	OP$TAB	(CHN,<AREA,FILE,KEY>)
CHFCOM:	$COMMA	(CPFOPT,$ALTERN(CFM))		;FOR SUBSEQ FLDS
CHKCOM:	$COMMA	(CPKOPT,$ALTERN(CFM))

; CHANGE PROLOG AREA
;
CHNARE:	$AID	(ASETNG)
ASETNG:	$NOISE	(ATOLST,<SETTING>)
ATOLST:	AO$TAB	(ABKZ,<<BKZ,BUCKET-SIZE>>)
ABKZBK:	$NOISE	(BKTVAL,<TO>)
BKTVAL:	$NUMGE	(CFM,BASE10,pages per bucket)

; CHANGE PROLOG FILE
;
CHNFIL:	$NOISE	(CPFOPT,<SETTING>)
CPFOPT:	AO$TAB	(CPF,<<ARC,AREA-COUNT>,<ARO,AREA-OFFSET>,<BKS,<BUCKET-SIZE>>,<BSZ,<BYTE-SIZE>>,<KYC,<KEY-COUNT>>,<KYO,<KEY-OFFSET>>,<MRS,<MAXIMUM-RECORD-SIZE>>,<ORG,<ORGANIZATION>>,<PIF,<PAGES-IN-FILE>>,<RFM,RECORD-FORMAT>>,AC$NOI(CHABTO))

CPFBKS:	$NUMGE	(CHFCOM,BASE10)
CPFBSZ:	$NUMGE	(CHFCOM,BASE10)
CPFMRS:	$NUMGE	(CHFCOM,BASE10)
CPFORG:	AV$TAB	(CHFCOM,ORZ,FB,<INDEXED,RELATIVE,SEQUENTIAL>)
	FB$IND==FB$IDX				;DEFINE SYMBOL AV$TAB EXPECTS
CPFRFM:	AV$TAB	(CHFCOM,RFM,FB,<FIXED,VARIABLE>)

CPFARC:	$NUMGE	(CHFCOM,BASE10,<number of areas>)
CPFARO:	$NUMGE	(CHFCOM,BASE10,<offset of first area descriptor>)
CPFPIF:	$NUMGE	(CHFCOM,BASE10,<next available page>)
CPFKYC:	$NUMGE	(CHFCOM,BASE10,<number of keys in file>)
CPFKYO:	$NUMGE	(CHFCOM,BASE10,<offset of first key descriptor>)

; CHANGE PROLOG KEY n
;
CHNKEY:	$KREF	(CPKSET)
CPKSET:	$NOISE	(CPKOPT,<SETTING>)
CPKOPT:	AO$TAB	(CPK,<<KYA,ATTRIBUTES>,<DAN,DATA-AREA>,<DFL,DATA-FILL>,<DTP,DATA-TYPE>,<IAN,INDEX-AREA>,<IFL,INDEX-FILL>,<REF,KEY-OF-REFERENCE>,<LVS,LEVELS>,<NKP,NEXT-KEY>,<ROOT,ROOT-PAGE>>,<$ALTERN(CPKSEG),AC$NOI(CHABTO)>)
CPKSEG:	AO$TAB	(CKS,<<POS,POSITION>,<SIZ,SIZE>>)

CPKLVS:	$NUMGE	(CHKCOM,BASE10,<# of levels in index structure>)
CPKNKP:	$NUMGE	(CHKCOM,BASE10,<offset of next key descriptor>)
CPKROO:	$NUMGE	(CHKCOM,BASE10,<page of index's root>)
CPKDAN:	$NUMGE	(CHKCOM,BASE10,<area ID of key's data buckets>)
CPKDFL:	$NUMGE	(CHKCOM,BASE10,max words to load in key's data buckets)
CPKDTP:	AV$TAB	(CHKCOM,DT,XB,<SIXBIT,<STG,ASCII>,EBCDIC>)
CPKIAN:	$NUMGE	(CHKCOM,BASE10,<area ID of key's index buckets>)
CPKIFL:	$NUMGE	(CHKCOM,BASE10,max words to load in key's index buckets)
CPKREF:	$NUMGE	(CHKCOM,BASE10,<key-of-reference>)

CPKKYA:	AV$TAB	(CKATPL,KAT,XB,<<CHG,CHANGES-ALLOWED>,<DUP,DUPLICATES-ALLOWED>,NIL>)
CKATPL:	$TOKEN	(CPKKYA,+,$ALTERN(CHKCOM))

CKSPOS:	$NOISE	(POSIDX,<OF SEGMENT>)
POSIDX:	$INDEX	(POSTO)
POSTO:	$NOISE	(POSIT,TO)
POSIT:	$NUMGE	(CHKCOM,BASE10,<# of bytes before key segment>)

CKSSIZ:	$NOISE	(SIZIDX,<OF SEGMENT>)
SIZIDX:	$INDEX	(SIZTO)
SIZTO:	$NOISE	(SIZIT,TO)
SIZIT:	$NUMGE	(CHKCOM,BASE10,<bytes in key segment>)

SUBTTL	SYNTAX OF CLOSE

; CLOSE RMSFILE ! REPORT
;
.CLOSE:	$NOISE	(CLOTYP,<FILE TYPE>)
CLOTYP:	KY$TAB	(CFM,CLO,<REPORT,<RMS,RMS-FILE>>)


SUBTTL	SYNTAX OF DEFINE COMMAND

.DEFIN:	$NOISE	(DEFTYP,OBJECT)
DEFTYP:	OP$TAB	(DEF,<AREA,DATAFIELD,FILE,KEY>)		;PROC APPROP OPTION

; SYNTAX TO DEFINE A DATA RECORD AND IT'S FIELDS:
; ----------------------------------------------
;
;	DEFINE  DATAFIELD datafieldname (WITH TYPE) ASCII!FILE-BYTES!SIXBIT
;		(WITH LENGTH) n1 (STARTING AT BYTE) n2
;
;	DEFINE DATAFIELD datafieldname INTEGER (STARTING AT WORD) n3
;

DISW%D==DFT%DEC
DISW%O==DFT%OCT
DESW%D==0
DEFDAT:	$NOISE	(DEFDNM,NAMING IT)
DEFDNM:	$MACF	(DEFDAS,<field name>)
DEFDAS:	$NOISE	(DEDTYP,WITH TYPE)
DEDTYP:	OP$TAB	(DFT,<ASCII,<FILE,FILE-BYTES>,FLOATING,INTEGER,SIXBIT>)

DFTFLO:	$NOISE	(DEDFLW,STARTING AT WORD)
DEDFLW:	$NUMGE	(DEDKEY,BASE10,<number of words before field>,$ALTERN(DEDKEY))

DFTINT:	$NOISE	(DEDINW,STARTING AT WORD)
DEDINW:	$NUMGE	(DEDISW,BASE10,<number of words before field>,$ALTERN(DEDISW))
DEDISW:	SV$TAB	(DESW,<DISPLAY>,$ALTERN(DEDKEY))
	DESW%D==KD%DIS				;COMMON TABLE WITH KEY ATTR
DESWDI:	KY$TAB	(CFM,DISW,<DECIMAL,OCTAL>,$DEFAULT(DECIMAL))

DFTASC:
DFTFIL:
DFTSIX:	$NOISE	(DEDLEN,WITH LENGTH)
DEDLEN:	$NUMGT	(DEDBYT,BASE10,<number of bytes in field>)
DEDBYT:	$NOISE	(DEDBNM,STARTING AT BYTE)
DEDBNM:	$NUMGE	(DEDKEY,BASE10,<number of bytes before field>,$ALTERN(DEDKEY))

DEDKEY:	SW$TAB	(DDK,<KEY>,$ALTERN(DKEYSW))
DDKKEY==CFM
	DDK%KEY==KD%KEY				;COMMON TAB WITH KEY ATTR

; SYNTAX TO DEFINE A FILE (SEE TABLES FOR SPELLED OUT SWITCHES):
; -----------------------
;
;DEFINE FILE file-name (WITH ORGANIZATION)
;
; FOR V1:
;		INDEXED (WITH KEYS) key-name-list [/MRS /BSZ /RFM]
;
; IN FUTURE:
;		RELATIVE (WITH CELL SIZE) n [/MRN /BSZ /RFM /BLOCK]
;		SEQUENTIAL [/MRS /BSZ /RFM /BLOCK]
;		ASCII
;		LINE-SEQUENCED

DEFFIL:	$NOISE	(DEFFNM,NAMING IT)
DEFFNM:	$FILEF	(DEFORN,<file spec>)
DEFORN:	$NOISE	(DEFORG,WITH ORGANIZATION)
DEFORG:	OP$TAB	(DFO,<INDEXED>)		;,LSA,RELATIVE,SEQUENTIAL,STREAM>)

DFOIND:	$NOISE	(DFKNAM,WITH KEYS)
DFKNAM:	$MACF	(DFCOMA,<key-name>)
DFCOMA:	$COMMA	(DFKnam,<$ALTERN(DFISW)>)
DFISW:	SV$TAB	(DFI,<<BKS,BUCKET-SIZE>,<BSZ,BYTE-SIZE>,<RFM,FORMAT>,<MRS,RECORD-SIZE>>,<$ALTERN(DFI.DF)>)
DFI.DF:	$CRLF	($HELP<confirm with CRLF (defaults are BYTE-SIZE=7, FORMAT=VAR)>)
DFIBKS:	$NUMGE	(DFISW,BASE10,default pages per bucket)
DFIBSZ:	$NUMGE	(DFISW,BASE10,bits per byte)
DFIMRS:	$NUMGE	(DFISW,BASE10,bytes per record)
DFIRFM:	AV$TAB	(DFISW,DER,FB,<FIX,VAR>)

;DFRAT:	AV$TAB	(DEFFF,DRA,FB,<BLK>)
;DFRFM:	AV$TAB	(DEFFE,DFR,FB,<FIX,VAR>)
;DEFFE:	SV$TAB	(DE,<BSZ,MRN,MRS,RAT>,<$ALTERN(DFNDEF)>)
;DEBSZ:	$NUMGE	(DEFFE,BASE10,<byte size>)
;DEMRN:	$NUMGE	(DEFFE,BASE10,<maximum record number>)
;DEMRS:	$NUMGE	(DEFFE,BASE10,<maximum record size>)
;DERAT:	AV$TAB	(DEFFE,DRB,FB,<BLK>)

;SYNTAX TO DEFINE AN AREA
;------------------------
;
;	DEFINE AREA (NAMING IT) area-name (WITH BUCKET SIZE) n
;

DEFARE:	$NOISE	(DEFANM,NAMING IT)
DEFANM:	$MACF	(DEFBKZ,<area-name>)
DEFBKZ:	$NOISE	(DFBKZ,<WITH BUCKET SIZE>)
DFBKZ:	$NUMGE	(CFM,BASE10,# of pages per bucket)


;SYNTAX TO DEFINE A KEY DESCRIPTION:
;-----------------------------------
;
;	DEFINE KEY key-name (WITH SEGMENTS) segment-list [SWITCHES]
;

DEFKEY:	$NOISE	(DEFKNM,NAMING IT)
DEFKNM:	$MACF	(DEFXBC,<key-name>)
DEFXBC:	$NOISE	(DFSNAM,WITH SEGMENTS)
DFSNAM:	$MACF	(DSCOMA,<segment-name>)
DSCOMA:	$COMMA	(DFSNAM,<$ALTERN(DKEYSW)>)

DKEYSW:	SW$TAB	(KD,<<CHA,CHANGES-ALLOWED>,<DFL,DAFILL:>,<DAN,DANAME:>,<DUP,DUPLICATES-ALLOWED>,<IFL,IAFILL:>,<IAN,IANAME:>>,$ALTERN(CFM))
KDCHA==DKEYSW
KDDUP==DKEYSW
KDDAN:	$MACF	(DKEYSW,<area name>)
KDDFL:	$NUMGE	(DKEYSW,BASE10,max words to load in key's data buckets)
KDIAN:	$MACF	(DKEYSW,<area name>)
KDIFL:	$NUMGE	(DKEYSW,BASE10,max words to load in key's index buckets)

SUBTTL	SYNTAX OF DELETE COMMAND

.DELET:	$NOISE	(DELEOP,<OBJECT>)
DELEOP:	OP$TAB	(DEL,<<BUC,BUCKET-ENTRY>,RECORD>)


; DELETE (OBJECT) BUCKET-ENTRY (IDENTIFIED BY) ENTRY n1!ID n2
;

DELBUC:	$NOISE	(DELOPT,<IDENTIFIED BY>)
DELOPT:	KY$TAB	(DELVAL,DLT,<ENTRY,ID>)
DELVAL:	$INDEX	(CFM)


; DELETE (OBJECT) RECORD (IDENTIFIED BY) records-to-use
;

DELREC:	$NOISE	(RTUSEL,<IDENTIFIED BY>)

SUBTTL	SYNTAX OF DISPLAY COMMAND

; DISPLAY PROLOGUE-DATA!BUCKET!DATA!<datafield>  ........
;	DISPLAY PROLOGUE-DATA (FOR) FILE!AREA n1!KEY n2
;
;	DISPLAY BUCKET (AT) ENTRY n1-list!ID n2-list!HEADER!KEY-VALUE!LARGEST-ENTRY
;
;	DISPLAY DATA!<datafield> (FOR RECORDS IDENTIFIED BY) .....
;
.DISPL:	$NOISE	(DSPVAL,<VALUE OF>)
DSPVAL:	OP$TAB	(DSP,<BUCKET,DATA,<PROLOGUE,PROLOGUE-DATA>>,<$ALTERN(DSPDAF)>)

DSPBUC:	$NOISE	(DISBUC,<AT>)
DISBUC:	OP$TAB	(DIS,<ENTRY,HEADER,ID,<KEY,KEY-VALUE>,<LAST,LARGEST-ENTRY>>,$ALTERN(CFM))
DISENT:	$INDEX	(DIBETO,,DIBELO)
DIBETO:	$NOISE	(DIBEHI,TO)
DIBEHI:	$NUMGE	(DIBECM,BASE10,larger number,$ALTERN(DIBECM))
DIBECM:	$COMMA	(DIBELO,<$ALTERN(CFM)>)
DISID==DISENT
DISHEA==CFM
DISKEY:	$NOISE	(DISKEV,GREATER OR EQUAL TO)
DISKEV:	$QUOTE	(CFM,<Quoted key>)
DISLAS==CFM

DSPDAT:	$NOISE	(RTUSEL,<FOR RECORDS IDENTIFIED BY>)

DSPPRO:	$NOISE	(DSOPT,<FOR>)
DSOPT:	OP$TAB	(DS,<AREA,FILE,KEY>,<$ALTERN(CFM)>)

DSAREA:	$AID	(CFM)
DSFILE: AK$TAB	(DSFCON,DSF,<<ARC,AREA-COUNT>,<ARO,AREA-OFFSET>,<BKS,<BUCKET-SIZE>>,<BSZ,<BYTE-SIZE>>,<KYC,KEY-COUNT>,<KYO,KEY-OFFSET>,<MRS,<MAXIMUM-RECORD-SIZE>>,<ORG,<ORGANIZATION>>,<PIF,<PAGES-IN-FILE>>,<RFM,<RECORD-FORMAT>>>,<$ALTERN(CFM)>)
DSFCON:	$COMMA	(DSFILE,<$ALTERN(CFM)>)

DSKEY:	$KREF	(IDXFLD)
IDXFLD:	AK$TAB	(IDXCON,DIX,<<KYA,ATTRIBUTES>,<DAN,DATA-AREA>,<DFL,<DATA-FILL>>,<DTP,<DATA-TYPE>>,<IAN,<INDEX-AREA>>,<IFL,<INDEX-FILL>>,<REF,<KEY-OF-REFERENCE>>,<LVS,LEVELS>,<NKP,<NEXT-KEY>>,POSITION,<ROOT,ROOT-PAGE>,SIZE>,$ALTERN(CFM))
IDXCON:	$COMMA	(IDXFLD,<$ALTERN(CFM)>)

DSPDAF:	$MACF	(DSPDFC,<datafield-name>)
DSPDFC:	$COMMA	(DSPDAF,$ALTERN(RTUSEL))

SUBTTL	SYNTAX OF EXIT COMMAND

;EXIT	(to monitor)
;
.EXIT:	$NOISE (CFM,<TO MONITOR>)


SUBTTL	SYNTAX OF FIX COMMAND

; FIX RFA-list
;

.FIX:	$NOISE	(FIXRFA,<RECORD WITH RFA>)
FIXRFA:	$SUB	(FIXIDX,RFADO)
FIXIDX:	$NOISE	(FIXKRF,OF INDEX)
FIXKRF:	$NUMGE	(FIXCMA,BASE10,key of reference,$DEFAULT(0))
FIXCMA:	$COMMA	(FIXRFA,$ALTERN(CFM))


SUBTTL	SYNTAX OF HELP COMMAND

;HELP		(please)
;
.HELP:	$NOISE (CFM,<PLEASE>)


SUBTTL	SYNTAX OF INFO COMMAND

;INFO	ALL!AREAS!CONTEXT!DATAFIELDS!KEYS
;
.INFOR:	$NOISE	(INFTYP,ABOUT)
INFTYP:	KY$TAB	(CFM,INF,<ALL,AREAS,CONTEXT,DATAFIELDS,KEYS>)


SUBTTL		SYNTAX OF OPEN COMMAND

;OPEN (FILETYPE) RMSFILE (WITH NAME) file-name (FOR) INPUT!OUTPUT
;OPEN (FILE TYPE) REPORT (WITH NAME) file-name /APPEND
;

.OPEN:	$NOISE	(OPNTYP,<FILE TYPE>)
OPNTYP:	OP$TAB	(OPE,<REPORT,<RMS,RMS-FILE>>)
OPEREP:	$NOISE	(REPNAM,<WITH NAME>)
REPNAM:	$FILEF	(REPSWI,<file spec>)
REPSWI:	SW$TAB	(OPN,<APPEND>,$ALTERN(CFM))
OPNAPP:	$CRLF

OPERMS:	$NOISE	(RMSNAM,<WITH NAME>)
RMSNAM:	$FILEF	(RMSOPT,<file spec>)
RMSOPT:	$NOISE	(OPNIO,<FOR>)
OPNIO:	KY$TAB	(OPNMOD,OP,<INPUT,OUTPUT,PATCHING>,$DEFAULT(INPUT))
OPNMOD:	SW$TAB	(OSRM,<<MAX,MAXIMUM-RECORD-SIZE:>>,$ALTERN(CFM))
	OSRM%M=0
OSRMMAX:$NUMGE	(CFM,BASE10,bytes in largest record)

SUBTTL	SYNTAX OF REDEFINE CMD

;REDEFINE (NAME) BLK-NAME ... [CONTINUE WITH DEFINE CMD]
;

.REDEF:	$NOISE	(REDNAM,NAME)
REDNAM:	$MACF	(0,already DEFINEd name,$ACTION(REDCAS))

;REDCAS SETS NEXT PDB TO MERGE WITH APPROP DEFINE OPTION

SUBTTL		SYNTAX OF SET COMMAND

.SET:	$NOISE	(SETENT,<CURRENT>)
SETENT:	OP$TAB	(SET,<BUCKET,INDEX,RECORD>)

;SET (CURRENT) INDEX (USING KRF) n [(AND) ROOT ! PAGE n ! RFA a/b]
;
SETIND:	$NOISE	(SINKRF,USING KEY OF REFERENCE)
SINKRF:	$NUMGE	(SINLOC,BASE10)
SINLOC:	$NOISE	(SINLTY,AND)
SINLTY:	OP$TAB	(SIL,<BUCKET,RFA,ROOT>,$DEFAULT(ROOT))
SILBUC:	$NOISE	(SILBUV,AT PAGE)
SILBUV:	$NUMGT	(CFM,BASE10,file page number)
SILRFA:	$NOISE	(SILRFV,BKT/ID)
SILRFV:	$SUB	(CFM,RFADO)
SILROOT==CFM

; SET BUCKET (TO ...) DATA-LEVEL!DOWN!ENTRY n!LAST-RECORD!NEXT!ROOT n!UP
;
SETBUC:	$NOISE	(SBKT,<TO ONE IDENTIFIED BY>)
SBKT:	OP$TAB	(STB,<<DATA,DATA-LEVEL>,DOWN,<LAST,LAST-RECORD>,NEXT,ROOT,UP>)
STBDAT==CFM
STBDOW:	$NOISE	(STBDNU,USING ENTRY)
STBDNU:	$NUMGT	(CFM,BASE10, positive decimal number,$DEFAULT(1))
STBLAS==CFM
STBNEX==CFM
STBROO==CFM
STBUP==CFM

; SET RECORD (TO ...)  [KEY range ! ! LAST ! REL range]   [(AND) name opr value]
;
SETREC:	$NOISE	(RTUSEL,<TO FIRST ONE IDENTIFIED BY>)

RTUSEL:	OP$TAB	(RTU,<KEY,<LAST,LAST-ENTRY>,<REL,RELATIVE-REC-NO>>,$ALTERN(CFM))
RTULAS==CFM
RTUKEY:	$KREF	(RTUFRO,$ALTERN(RTUST1))
RTUFRO:	$NOISE	(RTUST1,FROM)
RTUST1:	$QUOTE	(RTUKTO,<quoted key>,<$ALTERN(RTUKY1)>)
RTUKY1:	KY$WRD	(RTUKTO,RTUL,<LOWEST>)
RTUKTO:	$NOISE	(RTUST2,<TO>)
RTUST2:	$QUOTE	(RTUTST,<quoted key>,<$ALTERN(RTUKY2)>)
RTUKY2:	KY$TAB	(RTUTST,RUH,<<FOUND,FOUND-KEY-VALUE>,HIGHEST>,$ALTERN(RTUCFM))

RTUREL:	$NOISE	(RTUNUM,FROM)
RTUNUM:	$NUMGE	(RTUNTO,BASE10)
RTUNTO:	$NOISE	(RTUN2,<TO>)
RTUN2:	$NUMGE	(RTUTST,BASE10,<larger number>,$ALTERN(CFM))

VAR$AD==QVALDF				;FOR RET VAR AFTER DATTYP DEP DF VAL
RTUTST:	$NOISE	(RTUCFM,<AND>)
RTUCFM:	$CRLF	($ALTERN(RTUSYM))
RTUSYM:	$MACF	(RTUOPR,<datafield to test>,$ACTION(SETDFV))
RTUOPR:	$NOISE	(RTUEQL,OPERATOR,AC$SET(CFM))
RTUEQL:	$TOKEN	(RTUVAL,=,<$ALTERN(RTUNE)>)
RTUNE:	$TOKEN	(RTUVAL,#,<$ALTERN(RTUGE)>)
RTUGE:	$OTOK	(RTUVAL,GE,<$ALTERN(RTUGTR)>)
RTUGTR:	$OTOK	(RTUVAL,GTR,<$ALTERN(RTULE)>)
RTULE:	$OTOK	(RTUVAL,LE,<$ALTERN(RTULSS)>)
RTULSS:	$OTOK	(RTUVAL,LSS)
RTUVAL:	$NOISE	(@VALDF,VALUE)

SUBTTL	PROCESS THE SPACE CMD

;	SPACE (USAGE OF FILE FROM) verify-options

.SPACE:	$NOISE	(SPAOPT,USAGE OF FILE FROM)
SPAOPT:	OP$TAB	(SPA,<<ALL,ALL-KEYS>,KEY,<SEC,SECONDARY-KEYS>>,$DEFAULT(ALL-KEYS))
SPAKEY:	$KREF	(SPFROM)
SPFROM:	$NOISE	(SPSTR1,FROM)
SPSTR1:	$QUOTE	(SPTO,<quoted key>,<$ALTERN(SPKY1)>)
SPKY1:	KY$WRD	(SPTO,SP1,<LOWEST>,$ALTERN(CFM))
SPTO:	$NOISE	(SPSTR2,<TO>)
SPSTR2:	$QUOTE	(CFM,<quoted key>,<$ALTERN(SPKY2)>)
SPKY2:	KY$WRD	(CFM,SP2,<HIGHEST>,$ALTERN(CFM))
SPAALL==CFM
SPASEC==CFM

SUBTTL	PROCESS THE UNCLUTTER COMMAND

;	UNCLUTTER (FILE) [keys-to-use] /PROGRESS:n2

.UNCLU:	$NOISE	(UNCST1,<INDEX FILE FROM>)
UNCST1:	$QUOTE	(UNCTO,<quoted key>,<$ALTERN(UNCKY1)>)
UNCKY1:	KY$WRD	(UNCTO,UCL,<LOWEST>,$ALTERN(UNCSW))
UNCTO:	$NOISE	(UNCST2,<TO>)
UNCST2:	$QUOTE	(UNCSW,<quoted key>,<$ALTERN(UNCKY2)>)
UNCKY2:	KY$WRD	(UNCSW,UCH,<HIGHEST>,$ALTERN(UNCSW))
UNCSW:	UCS%PRO==VSW%PRO			;TREAT AS COMMON TABLE
	SV$TAB	(UCS,<PROGRESS>,<$ALTERN(CFM)>)
UCSPRO:	$NUMGT	(UNCSW,BASE10,<frequency to show progress>)


SUBTTL	PROCESS THE VERIFY COMMAND

; VERIFY [KEY n [key-range] ! SECONDARY ! ALL] /NOACCESS/NOFIX/PROGRESS:n2

.VERIF:	$NOISE	(VEROPT,<INDEX FILE UPON>)
VEROPT:	OP$TAB	(VER,<<ALL,ALL-KEYS>,KEY,<SEC,SECONDARY-KEYS>>,$DEFAULT(ALL-KEYS))
VERKEY:	$KREF	(VFROM)
VFROM:	$NOISE	(VRSTR1,FROM)
VRSTR1:	$QUOTE	(VRTO,<quoted key>,<$ALTERN(VRKY1)>)
VRKY1:	KY$WRD	(VRTO,VR1,<LOWEST>,$ALTERN(VRYSW))
VRTO:	$NOISE	(VRSTR2,<TO>)
VRSTR2:	$QUOTE	(VRYSW,<quoted key>,<$ALTERN(VRKY2)>)
VRKY2:	KY$WRD	(VRYSW,VR2,<HIGHEST>,$ALTERN(VRYSW))
VRYSW:	SW$TAB	(VSW,<<ACC,NOACCESS>,<FIX,NOFIX>,<PROG,PROGRESS:>>,$ALTERN(CFM))
VSWACC==VRYSW
VSWFIX==VRYSW
VSWPRO:	$NUMGT	(VRYSW,BASE10,<frequency to show progress>)

VERALL==VRYSW
VERSEC==VRYSW

SUBTTL	COMMAND "SUBROUTINES"

; RFADO - PARSE AN RFA FIELD
;
RFADO:	$NUMGT	(RFASLA,BASE10,bucket of RFA)
RFASLA:	$TOKEN	(RFAID,/)
RFAID:	$NUMGT	(@QRFADO,BASE10,ID of RFA)

; VALDF - PICK UP DATA TYPE DEP DATFLD VALUE
;
VALQUO:	$QUOTE	(@QVALDF,<quoted string>)
VALDEC:	$NUMBER	(@QVALDF,BASE10)
VALOCT:	$NUMBER	(@QVALDF,BASE8)
VALFLO:	$FLOAT	(@QVALDF)

END