Trailing-Edge
-
PDP-10 Archives
-
704rmsf2
-
10,7/rms10/rmssrc/debcmd.mac
There are 7 other files named debcmd.mac in the archive. Click here to see a list.
TITLE DEBCMD - SYNTAX TABLES FOR RMSDEB
SUBTTL S. COHEN
SEARCH RMSMAC,RMSINT
$PROLOG(DEB)
SEARCH CMDPAR
P$COLON==0 ;;INIT DEF OF IT
;;USED TO APP COLON TO TOK NAME
; 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
>
; $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
DEFNAM: $NOISE (0,NAMING IT) ;FOR NOISE AFT DEF TYPE
XABCOM: 0 ;SPACE FOR PDB AFTER CMA IN XAB
PDBPAG: BLOCK 200 ;SPACE FOR PARSED DATA
$PURE
MSKFIL:
FLDB0. ;WORD-N OF MASK
FLDB1.&<^-<1B14!1B26!1B28!1B30>>;B14=. B26=: B28=< B30=>
FLDB2.&<^-<1B27!1B29>> ;B27=[ B29=]
FLDB3.
MSKMAC:
FLDB0. ;WORD-N OF MASK
FLDB1.&<^-<1B4!1B5!1B14>>!1B13 ;B4=$ B5=% B14=. AND EXCL B13=-
FLDB2.
FLDB3.
CHANXT:
SZ%BID==XA$TYP+XB$SUM+1 ;NUMBER OF ARGBLK TYPES
$INIT (BID)
$SET (DA$TYP,CHADAT)
$SET (FA$TYP,CHAFAB)
$SET (RA$TYP,CHARAB)
$SET (XA$TYP+XB$AREA,CHAXA)
$SET (XA$TYP+XB$KEY,CHAXK)
$SET (XA$TYP+XB$DAT,CHAXD)
$SET (XA$TYP+XB$SUM,CHAXS)
$ENDINIT
DISNXT:
$INIT (BID)
$SET (DA$TYP,DIDCMA) ;COMPLETE CMD COULD BE D D1 [,D2,...]
$SET (FA$TYP,DISFAB)
$SET (RA$TYP,DISRAB)
$SET (XA$TYP+XB$AREA,DISXA)
$SET (XA$TYP+XB$KEY,DISXK)
$SET (XA$TYP+XB$DAT,DISXD)
$SET (XA$TYP+XB$SUM,DISXS)
$ENDINIT
SUBTTL ACTION ROUTINES
CXCNXT: ;SETS PLACE TO GO AFTER COMMA IN XAB
$COPY .NEXT,XABCOM ;DO IT
POPJ P,
CHACAS: ;ACTION ROUTINE FOR CHANGE
$CALL FLDTYP ;SETUP BID TO DRIVE SETTING OF .NEXT
JUMPF [POPJ P,] ;TRANSIT RET FAILURE
$COPY .NEXT,CHANXT(T2),T1 ;SET GLOBAL "NEXT PDB" FLD
MOVEM T1,XABCOM ;SAVE WHERE TO GO AFTER COMMA
POPJ P, ;TRANSIT RET TRUE
DISCAS: ;ACTION ROUTINE FOR DISPLAY
$CALL FLDTYP ;SETUP BID TO DRIVE SETTING OF .NEXT
JUMPF [POPJ P,] ;TRANSIT RET FAILURE
$COPY .NEXT,DISNXT(T2),T1 ;SET GLOBAL "NEXT PDB" FLD
MOVEM T1,XABCOM ;SAVE WHERE TO GO AFTER COMMA
POPJ P, ;TRANSIT RET TRUE
FLDTYP:
;
; FLDTYP - ACTION ROUTINE TO DETERMINE NEXT PDB OF A FIELD
; ARGUMENTS:
; T1 = LENGTH OF CMDRET BLK
; T2 = ADDR OF CMDRET BLK
MOVE T5,CR.SAV(T2) ;GET ADDRESS OF PARSE DATA
$CALL SY.FIND,<TK.VAL(T5)> ;PASS THE FLD VALUE
JUMPT L$IFX ;A MATCH?
MOVEI T2,[ASCIZ/Name not known/] ;NO, TELL CALLER
SETZM TF ;FAILURE RET
POPJ P,
$ENDIF
$FETCH T2,BID,(T1) ;GET TYPE OF FLD
CAIE T2,XA$TYP ;XAB?
$SKIP ;YES
$FETCH T3,COD,(T1) ;GET TYPE OF XAB
ADD T2,T3 ;SEP PDB FOR EACH TYPE OF XAB
$ENDIF
SETOM 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,$GET,$MESSAGE,$NOMESSAGE,$OPEN,$PUT,$TRUNCATE,$UPDATE,ASSIGN,CHANGE,DDT,DEFINE,DISPLAY,EXIT,HELP,INFORMATION,TAKE,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,$GET,$PUT,$TRUNCATE,$UPDATE>
$NOISE (RABNAM,<USING RAB>)
RABNAM: $MACF (CFM,<RAB name>)
$LABEL <$CLOSE,$CREATE,$DISPLAY,$ERASE,$OPEN>
$NOISE (FABNAM,<USING FAB>)
FABNAM: $MACF (CFM,<FAB name>)
$LABEL <$MESSAGE,$NOMESSAGE,DDT,EXIT,HELP>
$NOISE (CFM,PLEASE)
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 (CHATYP,VALUE IDENTIFIED BY)
CHATYP: OP$TAB (CHA,<<KEY,KEY-BUFFER>>,$ALTERN(CHAFNM))
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,<BKS,BSZ,FAC,FOP,MRN,MRS,ORG,RAT,RFM,SHR,XAB>,AC$NOI(CHABTO))
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: SV$TAB (CHFCOM,CRG,FB,<IDX,REL,SEQ>)
CHFXAB: $MACF (CHFCOM,<XAB name>)
;
; SYMBOLIC BITS
;
CHFSHR:
CHFFAC: SV$TAB (CACPLU,CAC,FB,<ALL,DEL,GET,NIL,PUT,TRN,UPD>)
CACPLU: $TOKEN (CHFFAC,+,<$ALTERN(CHFCOM)>)
CHFFOP: SV$TAB (COPPLU,COP,FB,<CIF,DFW,DRJ,NIL,SUP,WAT>)
COPPLU: $TOKEN (CHFFOP,+,<$ALTERN(CHFCOM)>)
CHFRAT: SV$TAB (CHFCOM,CRT,FB,<BLK>)
CHFRFM: SV$TAB (CRFPLU,CRF,FB,<FIX,LSA,STM,VAR>)
CRFPLU: $TOKEN (CHFRFM,+,<$ALTERN(CHFCOM)>)
CHFCOM: $COMMA (CHAFF,<$ALTERN(CFM)>)
CHARAB: $NOISE (CHRFLD,AND)
CHRFLD: AO$TAB (CHR,<FAB,KRF,LSN,MBF,PAD,RAC,ROP,RSZ,USZ>,<$ALTERN(CHRKEY),AC$NOI(CHABTO)>)
CHRKEY: $KEYDSP (CHATB,<$ALTERN(CHDFLD)>)
CHRFAB: $MACF (CHRCOM,name of FAB)
CHRRAC: SV$TAB (CRCPLU,CRAC,RB,<KEY,SEQ,RFA>)
CRCPLU: $TOKEN (CHRRAC,+,<$ALTERN(CHRCOM)>)
CHRROP: SV$TAB (CRPPLU,CROP,RB,<EOF,FDL,KGE,KGT,LOA,LOC,NIL,NRP,PAD,RAH,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>)
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))
CHAXA: $NOISE (CHAXAF,AND)
CHAXD: $NOISE (CHAXDF,AND)
CHAXK: $NOISE (CHAXKF,AND)
CHAXS: $NOISE (CHAXSF,AND)
CXANXT:
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:
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: SV$TAB (CHXCOM,CXKD,XB,<EBC,SIX,STG>)
CXKFLG: SV$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(CXCNXT),$ALTERN(CFM)>)
CHADAT: $NOISE (CHDDEC,TO)
CHDDEC: $NUMBER (CHDCOM,BASE10,,<$ALTERN(CHDTEX)>)
CHDTEX: $QUOTE (CHDCOM,<quoted text>)
CHDCOM: $COMMA (CHDFLD,<$ALTERN(CFM)>)
CHDFLD: $MACF (CHADAT,name of datafield)
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 DATAFIELD new-name [/POS /SIZE /TYPE]
.DEFIN: $NOISE (DEFTYP,<TYPE OF NAME>)
DEFTYP: OP$TAB (DEF,<DATAFIELD,FAB,RAB,XAB>,<AC$NOI(DEFNAM)>)
; DEFINE FAB
;
DEFFAB: $MACF (DEFFI,<FAB name>)
DEFFI: $NOISE (DEFFN,FOR)
DEFFN: $FILEF (DEFFF,<file name>)
DEFFF: AS$TAB (DFF,<BKS,BSZ,FAC,FOP,MRN,MRS,ORG,RAT,RFM,SHR,XAB>,<$ALTER(DEFFDF)>)
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>)
DFFORG: SV$TAB (DEFFF,DRG,FB,<IDX,REL,SEQ>)
DFFXAB: $MACF (DEFFF,<XAB name>)
;
; SYMBOLIC BITS
;
DFFSHR:
DFFFAC: SV$TAB (DACPLU,DAC,FB,<ALL,DEL,GET,NIL,PUT,TRN,UPD>)
DACPLU: $TOKEN (DFFFAC,+,<$ALTERN(DEFFF)>)
DFFFOP: SV$TAB (DOPPLU,DOP,FB,<CIF,DFW,DRJ,NIL,SUP,WAT>)
DOPPLU: $TOKEN (DFFFOP,+,<$ALTERN(DEFFF)>)
DFFRAT: SV$TAB (DEFFF,DRT,FB,<BLK>)
DFFRFM: SV$TAB (DRFPLU,DRF,FB,<FIX,LSA,STM,VAR>)
DRFPLU: $TOKEN (DFFRFM,+,<$ALTERN(DEFFF)>)
; DEFINE RAB
;
DEFRAB: $MACF (DEFRFB,<RAB name>)
DEFRFB: $NOISE (DEFRFN,FOR)
DEFRFN: $FNAME (DEFRF,<name of FAB to connect to>)
DEFRF: AS$TAB (DFR,<KRF,LSN,MBF,PAD,RAC,ROP,RSZ,USZ>,<$ALTERN(DEFRDF)>)
DEFRDF: $CRLF ($HELP<confirm with CRLF (defaults are KSZ=30 RAC=SEQ ROP=WBH USZ=50)>)
DFRRAC: SV$TAB (DRCPLU,DRAC,RB,<KEY,SEQ,RFA>)
DRCPLU: $TOKEN (DFRRAC,+,<$ALTERN(DEFRF)>)
DFRROP: SV$TAB (DRPPLU,DROP,RB,<EOF,FDL,KGE,KGT,LOA,LOC,NIL,NRP,PAD,RAH,WBH>)
DRPPLU: $TOKEN (DFRROP,+,<$ALTERN(DEFRF)>)
DFRKRF: $NUMGE (DEFRF,BASE10,<key number>)
DFRLSN: $NUMGE (DEFRF,BASE10,<line-sequence-number>)
DFRMBF: $NUMGE (DEFRF,BASE10,<number of buffers to allocate>)
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,DATE,KEY,SUMMARY>)
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: SV$TAB (DXCKEY,DXKD,XB,<EBC,SIX,STG>)
DXKFLG: SV$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>,INTEGER,SIXBIT>)
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:
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 (DISTYP,VALUE IDENTIFIED BY)
DISTYP: 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,<BKS,BSZ,DEV,FAC,FNA,FOP,IFI,JFN,MRN,MRS,ORG,RAT,RFM,SHR,STS,STV,XAB>,<$ALTERN(CFM)>)
DISFFC: $COMMA (DISFF,<$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)
DISXD: $NOISE (DISXDF,AND)
DISXK: $NOISE (DISXKF,AND)
DISXS: $NOISE (DISXSF,AND)
DISXAF: AK$TAB (DISXFC,DIXA,<AID,BKZ,NXT>,$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(CXCNXT),$ALTERN(CFM)>)
DIDFLD: $MACF (DIDCMA,<name of datafield>)
DIDCMA: $COMMA (DIDFLD,<$ALTERN(CFM)>)
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