! ! MACRO TO GENERATE A STRING DESCRIPTOR PLIT ! MACRO $BITPOSITION(O,P,W,S) = P %, $DESCRIPTOR[]= UPLIT(%CHARCOUNT(%REMAINING),UPLIT BYTE(%REMAINING))%; ! ! Macro to initialize a dynamic descriptor ! MACRO $init_dyndesc(d) = begin bind _d = (d) : BLOCK[8,Byte]; _d[dsc$w_length] = 0; _d[dsc$b_class] = dsc$k_class_d; _d[dsc$b_dtype] = dsc$k_dtype_t; _d[dsc$a_pointer] = 0; end%; Literal DEV$M_TRM = 4; literal DSC$K_DTYPE_Z = 0; ! Unspecified. The calling program has literal DSC$K_DTYPE_V = 1; ! Bit. An aligned bit string. literal DSC$K_DTYPE_T = 14; ! Character-coded text. A single 8-bit character literal DSC$K_CLASS_Z = 0; ! Unspecified literal DSC$K_CLASS_S = 1; ! Scalar, String Descriptor literal DSC$K_CLASS_D = 2; ! Dynamic String Descriptor literal DSC$K_CLASS_V = 3; ! Reserved for use by Digital macro DSC$W_LENGTH = 0,0,16,0 %; ! A one-word field specifiec to the descriptor class; macro DSC$B_DTYPE = 2,0,8,0 %; ! A one-byte atomic data type code (see C.9) macro DSC$B_CLASS = 3,0,8,0 %; ! A one-byte descriptor class code (see above). macro DSC$A_POINTER = 4,0,32,0 %; ! An address pointing to the first byte of the data literal RMS$_SUC = 65537; literal RMS$_NORMAL = 65537; literal RMS$_EOF = 98938; ! ! file access block (fab) definitions ! literal FAB$C_BID = 3; ! code for fab literal FAB$M_PPF_RAT = %X'3FC0'; literal FAB$M_PPF_IND = %X'4000'; literal FAB$M_PPIFI = %X'8000'; literal FAB$M_ASY = %X'1'; literal FAB$M_MXV = %X'2'; literal FAB$M_SUP = %X'4'; literal FAB$M_TMP = %X'8'; literal FAB$M_TMD = %X'10'; literal FAB$M_DFW = %X'20'; literal FAB$M_SQO = %X'40'; literal FAB$M_RWO = %X'80'; literal FAB$M_POS = %X'100'; literal FAB$M_WCK = %X'200'; literal FAB$M_NEF = %X'400'; literal FAB$M_RWC = %X'800'; literal FAB$M_DMO = %X'1000'; literal FAB$M_SPL = %X'2000'; literal FAB$M_SCF = %X'4000'; literal FAB$M_DLT = %X'8000'; literal FAB$M_NFS = %X'10000'; literal FAB$M_UFO = %X'20000'; literal FAB$M_PPF = %X'40000'; literal FAB$M_INP = %X'80000'; literal FAB$M_CTG = %X'100000'; literal FAB$M_CBT = %X'200000'; literal FAB$M_SYNCSTS = %X'400000'; literal FAB$M_RCK = %X'800000'; literal FAB$M_NAM = %X'1000000'; literal FAB$M_CIF = %X'2000000'; literal FAB$M_ESC = %X'8000000'; literal FAB$M_TEF = %X'10000000'; literal FAB$M_OFP = %X'20000000'; literal FAB$M_KFO = %X'40000000'; literal FAB$M_PUT = %X'1'; literal FAB$M_GET = %X'2'; literal FAB$M_DEL = %X'4'; literal FAB$M_UPD = %X'8'; literal FAB$M_TRN = %X'10'; literal FAB$M_BIO = %X'20'; literal FAB$M_BRO = %X'40'; literal FAB$M_EXE = %X'80'; literal FAB$M_SHRPUT = %X'1'; literal FAB$M_SHRGET = %X'2'; literal FAB$M_SHRDEL = %X'4'; literal FAB$M_SHRUPD = %X'8'; literal FAB$M_MSE = %X'10'; literal FAB$M_NIL = %X'20'; literal FAB$M_UPI = %X'40'; literal FAB$M_ORG = %X'F0'; literal FAB$C_SEQ = 0; ! sequential literal FAB$C_REL = 16; ! relative literal FAB$C_IDX = 32; ! indexed literal FAB$C_HSH = 48; ! hashed literal FAB$M_FTN = %X'1'; literal FAB$M_CR = %X'2'; literal FAB$M_PRN = %X'4'; literal FAB$M_BLK = %X'8'; literal FAB$M_MSB = %X'10'; literal FAB$C_RFM_DFLT = 2; ! var len is default literal FAB$C_UDF = 0; ! undefined (also stream binary) literal FAB$C_FIX = 1; ! fixed length records literal FAB$C_VAR = 2; ! variable length records literal FAB$C_VFC = 3; ! variable fixed control literal FAB$C_STM = 4; ! RMS-11 stream (valid only for sequential org) literal FAB$C_STMLF = 5; ! LF stream (valid only for sequential org) literal FAB$C_STMCR = 6; ! CR stream (valid only for sequential org) literal FAB$C_MAXRFM = 6; ! maximum rfm supported literal FAB$M_ONLY_RU = %X'1'; literal FAB$M_RU = %X'2'; literal FAB$M_BI = %X'4'; literal FAB$M_AI = %X'8'; literal FAB$M_AT = %X'10'; literal FAB$M_NEVER_RU = %X'20'; literal FAB$M_JOURNAL_FILE = %X'40'; literal FAB$M_RCF_RU = %X'1'; literal FAB$M_RCF_AI = %X'2'; literal FAB$M_RCF_BI = %X'4'; literal FAB$K_BLN = 80; ! length of fab literal FAB$C_BLN = 80; ! length of fab literal FAB$S_FABDEF = 80; macro FAB$B_BID = 0,0,8,0 %; ! block id macro FAB$B_BLN = 1,0,8,0 %; ! block len macro FAB$R_IFI_OVERLAY = 2,0,16,0 %; macro FAB$W_IFI = 2,0,16,0 %; ! internal file index macro FAB$R_IFI_BITS = 2,0,16,0 %; macro FAB$V_PPF_RAT = 2,6,8,0 %; literal FAB$S_PPF_RAT = 8; ! rat value for process-permanent files macro FAB$V_PPF_IND = 2,14,1,0 %; ! indirect access to process-permanent file ! (i.e., restricted operations) macro FAB$V_PPIFI = 2,15,1,0 %; ! indicates that this is PPF file macro FAB$R_FOP_OVERLAY = 4,0,32,0 %; macro FAB$L_FOP = 4,0,32,0 %; ! file options macro FAB$R_FOP_BITS = 4,0,32,0 %; macro FAB$V_ASY = 4,0,1,0 %; ! asynchronous operations macro FAB$V_MXV = 4,1,1,0 %; ! maximize version number macro FAB$V_SUP = 4,2,1,0 %; ! supersede existing file macro FAB$V_TMP = 4,3,1,0 %; ! create temporary file macro FAB$V_TMD = 4,4,1,0 %; ! create temp file marked for delete macro FAB$V_DFW = 4,5,1,0 %; ! deferred write (rel and idx) macro FAB$V_SQO = 4,6,1,0 %; ! sequential access only macro FAB$V_RWO = 4,7,1,0 %; ! rewind mt on open macro FAB$V_POS = 4,8,1,0 %; ! use next magtape position macro FAB$V_WCK = 4,9,1,0 %; ! write checking macro FAB$V_NEF = 4,10,1,0 %; ! inhibit end of file positioning macro FAB$V_RWC = 4,11,1,0 %; ! rewind mt on close macro FAB$V_DMO = 4,12,1,0 %; ! dismount mt on close (not implemented) macro FAB$V_SPL = 4,13,1,0 %; ! spool file on close macro FAB$V_SCF = 4,14,1,0 %; ! submit command file on close macro FAB$V_DLT = 4,15,1,0 %; ! delete sub-option macro FAB$V_NFS = 4,16,1,0 %; ! non-file structured operation macro FAB$V_UFO = 4,17,1,0 %; ! user file open - no rms operations macro FAB$V_PPF = 4,18,1,0 %; ! process permanent file (pio segment) macro FAB$V_INP = 4,19,1,0 %; ! process-permanent file is 'input' macro FAB$V_CTG = 4,20,1,0 %; ! contiguous extension macro FAB$V_CBT = 4,21,1,0 %; ! contiguous best try macro FAB$V_SYNCSTS = 4,22,1,0 %; ! Synchronous status notification for asynchronous routines. macro FAB$V_RCK = 4,23,1,0 %; ! read checking macro FAB$V_NAM = 4,24,1,0 %; ! use name block dvi, did, and/or fid fields for open macro FAB$V_CIF = 4,25,1,0 %; ! create if non-existent macro FAB$V_ESC = 4,27,1,0 %; ! 'escape' to non-standard function ($modify) macro FAB$V_TEF = 4,28,1,0 %; ! truncate at eof on close (write-accessed seq. disk file only) macro FAB$V_OFP = 4,29,1,0 %; ! output file parse (only name type sticky) macro FAB$V_KFO = 4,30,1,0 %; ! known file open (image activator only release 1) macro FAB$L_STS = 8,0,32,0 %; ! status macro FAB$L_STV = 12,0,32,0 %; ! status value macro FAB$L_ALQ = 16,0,32,0 %; ! allocation quantity macro FAB$W_DEQ = 20,0,16,0 %; ! default allocation quantity macro FAB$R_FAC_OVERLAY = 22,0,8,0 %; macro FAB$B_FAC = 22,0,8,0 %; ! file access macro FAB$R_FAC_BITS = 22,0,8,0 %; macro FAB$V_PUT = 22,0,1,0 %; ! put access macro FAB$V_GET = 22,1,1,0 %; ! get access macro FAB$V_DEL = 22,2,1,0 %; ! delete access macro FAB$V_UPD = 22,3,1,0 %; ! update access macro FAB$V_TRN = 22,4,1,0 %; ! truncate access macro FAB$V_BIO = 22,5,1,0 %; ! block i/o access macro FAB$V_BRO = 22,6,1,0 %; ! block and record i/o access macro FAB$V_EXE = 22,7,1,0 %; ! execute access (caller must be exec or kernel mode, ! ufo must also be set) macro FAB$R_SHR_OVERLAY = 23,0,8,0 %; macro FAB$B_SHR = 23,0,8,0 %; ! file sharing macro FAB$R_SHR_BITS = 23,0,8,0 %; macro FAB$V_SHRPUT = 23,0,1,0 %; ! put access macro FAB$V_SHRGET = 23,1,1,0 %; ! get access macro FAB$V_SHRDEL = 23,2,1,0 %; ! delete access macro FAB$V_SHRUPD = 23,3,1,0 %; ! update access macro FAB$V_MSE = 23,4,1,0 %; ! multi-stream connects enabled macro FAB$V_NIL = 23,5,1,0 %; ! no sharing macro FAB$V_UPI = 23,6,1,0 %; ! user provided interlocking (allows multiple ! writers to seq. files) macro FAB$L_CTX = 24,0,32,0 %; ! user context ! -----***** macro FAB$B_RTV = 28,0,8,1 %; ! retrieval window size macro FAB$R_ORG_OVERLAY = 29,0,8,0 %; macro FAB$B_ORG = 29,0,8,0 %; ! file organization macro FAB$R_ORG_BITS = 29,0,8,0 %; macro FAB$V_ORG = 29,4,4,0 %; literal FAB$S_ORG = 4; macro FAB$R_RAT_OVERLAY = 30,0,8,0 %; macro FAB$B_RAT = 30,0,8,0 %; ! record format macro FAB$R_RAT_BITS = 30,0,8,0 %; macro FAB$V_FTN = 30,0,1,0 %; ! fortran carriage-ctl macro FAB$V_CR = 30,1,1,0 %; ! lf-record-cr carriage ctl macro FAB$V_PRN = 30,2,1,0 %; ! print-file carriage ctl macro FAB$V_BLK = 30,3,1,0 %; ! records don't cross block boundaries macro FAB$V_MSB = 30,4,1,0 %; ! MSB formatted byte count macro FAB$B_RFM = 31,0,8,0 %; ! record format macro FAB$R_JOURNAL_OVERLAY = 32,0,8,0 %; macro FAB$B_JOURNAL = 32,0,8,0 %; ! journaling options (from FH2$B_JOURNAL) macro FAB$R_JOURNAL_BITS = 32,0,8,0 %; ! note: only one of RU, ONLY_RU, NEVER_RU ! may be set at a time macro FAB$V_ONLY_RU = 32,0,1,0 %; ! file is accessible only in recovery unit macro FAB$V_RU = 32,1,1,0 %; ! enable recovery unit journal macro FAB$V_BI = 32,2,1,0 %; ! enable before image journal macro FAB$V_AI = 32,3,1,0 %; ! enable after image journal macro FAB$V_AT = 32,4,1,0 %; ! enable audit trail journal macro FAB$V_NEVER_RU = 32,5,1,0 %; ! file is never accessible in recovery unit macro FAB$V_JOURNAL_FILE = 32,6,1,0 %; ! this is a journal file macro FAB$B_RU_FACILITY = 33,0,8,0 %; ! recoverable facility id number macro FAB$L_XAB = 36,0,32,1 %; ! xab address macro FAB$L_NAM = 40,0,32,1 %; ! nam block address macro FAB$L_FNA = 44,0,32,1 %; ! file name string address macro FAB$L_DNA = 48,0,32,1 %; ! default file name string addr macro FAB$B_FNS = 52,0,8,0 %; ! file name string size macro FAB$B_DNS = 53,0,8,0 %; ! default name string size macro FAB$W_MRS = 54,0,16,0 %; ! maximum record size macro FAB$L_MRN = 56,0,32,1 %; ! maximum record number macro FAB$W_BLS = 60,0,16,0 %; ! blocksize for tape macro FAB$B_BKS = 62,0,8,0 %; ! bucket size macro FAB$B_FSZ = 63,0,8,0 %; ! fixed header size macro FAB$L_DEV = 64,0,32,0 %; ! device characteristics macro FAB$L_SDC = 68,0,32,0 %; ! spooling device characteristics macro FAB$W_GBC = 72,0,16,0 %; ! Global buffer count macro FAB$R_ACMODES_OVERLAY = 74,0,8,0 %; macro FAB$B_ACMODES = 74,0,8,0 %; ! agent access modes macro FAB$R_ACMODES_BITS = 74,0,8,0 %; macro FAB$V_LNM_MODE = 74,0,2,0 %; literal FAB$S_LNM_MODE = 2; ! ACMODE for log nams macro FAB$V_CHAN_MODE = 74,2,2,0 %; literal FAB$S_CHAN_MODE = 2; ! ACMODE for channel macro FAB$V_FILE_MODE = 74,4,2,0 %; literal FAB$S_FILE_MODE = 2; ! ACMODE to use for determining file accessibility macro FAB$V_CALLERS_MODE = 74,6,2,0 %; literal FAB$S_CALLERS_MODE = 2; ! ACMODE for user structure probing; ! maximized with actual mode of caller macro FAB$R_RCF_OVERLAY = 75,0,8,0 %; ! recovery control flags macro FAB$B_RCF = 75,0,8,0 %; ! (only for use by RMS Recovery) macro FAB$R_RCF_BITS = 75,0,8,0 %; macro FAB$V_RCF_RU = 75,0,1,0 %; ! recovery unit recovery macro FAB$V_RCF_AI = 75,1,1,0 %; ! after image recovery macro FAB$V_RCF_BI = 75,2,1,0 %; ! before image recovery !*** MODULE $RABDEF *** ! ! record access block (rab) definitions ! literal RAB$C_BID = 1; ! code for rab literal RAB$M_PPF_RAT = %X'3FC0'; literal RAB$M_PPF_IND = %X'4000'; literal RAB$M_PPISI = %X'8000'; literal RAB$M_ASY = %X'1'; literal RAB$M_TPT = %X'2'; literal RAB$M_REA = %X'4'; literal RAB$M_RRL = %X'8'; literal RAB$M_UIF = %X'10'; literal RAB$M_MAS = %X'20'; literal RAB$M_FDL = %X'40'; literal RAB$M_REV = %X'80'; literal RAB$M_EOF = %X'100'; literal RAB$M_RAH = %X'200'; literal RAB$M_WBH = %X'400'; literal RAB$M_BIO = %X'800'; literal RAB$M_CDK = %X'1000'; literal RAB$M_LOA = %X'2000'; literal RAB$M_LIM = %X'4000'; literal RAB$M_SYNCSTS = %X'8000'; literal RAB$M_LOC = %X'10000'; literal RAB$M_WAT = %X'20000'; literal RAB$M_ULK = %X'40000'; literal RAB$M_RLK = %X'80000'; literal RAB$M_NLK = %X'100000'; literal RAB$M_KGE = %X'200000'; literal RAB$M_KGT = %X'400000'; literal RAB$M_NXR = %X'800000'; literal RAB$M_RNE = %X'1000000'; literal RAB$M_TMO = %X'2000000'; literal RAB$M_CVT = %X'4000000'; literal RAB$M_RNF = %X'8000000'; literal RAB$M_ETO = %X'10000000'; literal RAB$M_PTA = %X'20000000'; literal RAB$M_PMT = %X'40000000'; literal RAB$M_EQNXT = %X'200000'; literal RAB$M_NXT = %X'400000'; literal RAB$C_SEQ = 0; ! sequential access literal RAB$C_KEY = 1; ! keyed access literal RAB$C_RFA = 2; ! rfa access literal RAB$C_STM = 3; ! stream access (valid only for sequential org) literal RAB$C_MAXRAC = 2; ! Maximum RAC value currently supported by RMS literal RAB$K_BLN = 68; ! length of rab literal RAB$C_BLN = 68; ! length of rab literal RAB$S_RABDEF = 68; macro RAB$B_BID = 0,0,8,0 %; ! block id macro RAB$B_BLN = 1,0,8,0 %; ! block length macro RAB$R_ISI_OVERLAY = 2,0,16,0 %; macro RAB$W_ISI = 2,0,16,0 %; ! internal stream index ! (ifi in fab) macro RAB$R_ISI_BITS = 2,0,16,0 %; macro RAB$V_PPF_RAT = 2,6,8,0 %; literal RAB$S_PPF_RAT = 8; ! rat value for process-permanent files macro RAB$V_PPF_IND = 2,14,1,0 %; ! indirect access to process-permanent file ! (i.e., restricted operations) macro RAB$V_PPISI = 2,15,1,0 %; ! indicates that this is process-permanent stream macro RAB$R_ROP_OVERLAY = 4,0,32,0 %; macro RAB$L_ROP = 4,0,32,0 %; ! record options macro RAB$R_ROP_BITS0 = 4,0,32,0 %; macro RAB$V_ASY = 4,0,1,0 %; ! asynchronous operations macro RAB$V_TPT = 4,1,1,0 %; ! truncate put - allow sequential put not at ! eof, thus truncating file (seq. org only) ! ! these next two should be in the byte for bits ! input to $find or $get, but there is no room there ! macro RAB$V_REA = 4,2,1,0 %; ! lock record for read only, allow other readers macro RAB$V_RRL = 4,3,1,0 %; ! read record regardless of lock ! macro RAB$V_UIF = 4,4,1,0 %; ! update if existent macro RAB$V_MAS = 4,5,1,0 %; ! mass-insert mode macro RAB$V_FDL = 4,6,1,0 %; ! fast record deletion macro RAB$V_REV = 4,7,1,0 %; ! reverse-search - can only be set with NXT or EQNXT ! macro RAB$V_EOF = 4,8,1,0 %; ! connect to eof macro RAB$V_RAH = 4,9,1,0 %; ! read ahead macro RAB$V_WBH = 4,10,1,0 %; ! write behind macro RAB$V_BIO = 4,11,1,0 %; ! connect for bio only macro RAB$V_CDK = 4,12,1,0 %; ! check for duplicate keys on $GET macro RAB$V_LOA = 4,13,1,0 %; ! use bucket fill percentage macro RAB$V_LIM = 4,14,1,0 %; ! compare for key limit reached on $get/$find seq. (idx only) macro RAB$V_SYNCSTS = 4,15,1,0 %; ! Synchronous status notification for asynchronous routines. ! ! the following bits are input to ! $find or $get, (see above also REA and RRL) ! (separate byte) ! macro RAB$V_LOC = 4,16,1,0 %; ! use locate mode macro RAB$V_WAT = 4,17,1,0 %; ! wait if record not available macro RAB$V_ULK = 4,18,1,0 %; ! manual unlocking macro RAB$V_RLK = 4,19,1,0 %; ! allow readers for this locked record macro RAB$V_NLK = 4,20,1,0 %; ! do not lock record macro RAB$V_KGE = 4,21,1,0 %; ! key > or = macro RAB$V_KGT = 4,22,1,0 %; ! key greater than macro RAB$V_NXR = 4,23,1,0 %; ! get non-existent record ! ! the following bits are terminal qualifiers only ! (separate byte) ! macro RAB$V_RNE = 4,24,1,0 %; ! read no echo macro RAB$V_TMO = 4,25,1,0 %; ! use time-out period macro RAB$V_CVT = 4,26,1,0 %; ! convert to upper case macro RAB$V_RNF = 4,27,1,0 %; ! read no filter macro RAB$V_ETO = 4,28,1,0 %; ! extended terminal operation macro RAB$V_PTA = 4,29,1,0 %; ! purge type ahead macro RAB$V_PMT = 4,30,1,0 %; ! use prompt buffer macro RAB$V_CCO = 4,31,1,0 %; ! cancel control o on output macro RAB$R_ROP_BITS1 = 4,0,24,0 %; macro RAB$V_EQNXT = 4,21,1,0 %; ! Synonyms for KGE and macro RAB$V_NXT = 4,22,1,0 %; ! KGT ! the following bits may be ! input to various rab-related ! operations ! macro RAB$R_ROP_FIELDS = 4,0,32,0 %; macro RAB$B_ROP1 = 5,0,8,0 %; ! various options macro RAB$B_ROP2 = 6,0,8,0 %; ! get/find options (use of this field discouraged ! due to REA and RRL being in a different byte) macro RAB$B_ROP3 = 7,0,8,0 %; ! terminal read options ! macro RAB$L_STS = 8,0,32,0 %; ! status macro RAB$R_STV_OVERLAY = 12,0,32,0 %; macro RAB$L_STV = 12,0,32,0 %; ! status value macro RAB$R_STV_FIELDS = 12,0,32,0 %; macro RAB$W_STV0 = 12,0,16,0 %; ! low word of stv macro RAB$W_STV2 = 14,0,16,0 %; ! high word of stv macro RAB$R_RFA_OVERLAY = 16,0,0,0 %; macro RAB$W_RFA = 16,0,0,0 %; literal RAB$S_RFA = 6; ! record's file address macro RAB$R_RFA_FIELDS = 16,0,0,0 %; macro RAB$L_RFA0 = 16,0,32,0 %; macro RAB$W_RFA4 = 20,0,16,0 %; ! to the rfa field to be a move quad, overwriting ! this reserved word) macro RAB$L_CTX = 24,0,32,0 %; ! user context ! -----***** macro RAB$B_RAC = 30,0,8,0 %; ! record access macro RAB$B_TMO = 31,0,8,0 %; ! time-out period macro RAB$W_USZ = 32,0,16,0 %; ! user buffer size macro RAB$W_RSZ = 34,0,16,0 %; ! record buffer size macro RAB$L_UBF = 36,0,32,1 %; ! user buffer address macro RAB$L_RBF = 40,0,32,1 %; ! record buffer address macro RAB$L_RHB = 44,0,32,1 %; ! record header buffer addr macro RAB$R_KBF_OVERLAY = 48,0,32,0 %; macro RAB$L_KBF = 48,0,32,1 %; ! key buffer address macro RAB$L_PBF = 48,0,32,1 %; ! prompt buffer addr macro RAB$R_KSZ_OVERLAY = 52,0,8,0 %; macro RAB$B_KSZ = 52,0,8,0 %; ! key buffer size macro RAB$B_PSZ = 52,0,8,0 %; ! prompt buffer size macro RAB$B_KRF = 53,0,8,0 %; ! key of reference macro RAB$B_MBF = 54,0,8,1 %; ! multi-buffer count macro RAB$B_MBC = 55,0,8,0 %; ! multi-block count macro RAB$R_BKT_OVERLAY = 56,0,32,0 %; macro RAB$L_BKT = 56,0,32,0 %; ! bucket hash code, vbn, or rrn macro RAB$L_DCT = 56,0,32,0 %; ! duplicates count on key accessed on alternate key macro RAB$L_FAB = 60,0,32,1 %; ! related fab for connect macro RAB$L_XAB = 64,0,32,1 %; ! XAB address !*** MODULE $NAMDEF *** ! ! name block field definitions ! ! the nam block is used to communicate optional ! filename-related information ! literal NAM$C_BID = 2; ! code for nam block literal NAM$C_MAXRSS = 255; ! maximum resultant name string size (network) literal NAM$C_MAXRSSLCL = 255; ! maximum resultant name string size (local) literal NAM$M_PWD = %X'1'; literal NAM$M_FILL_1 = %X'2'; literal NAM$M_FILL_2 = %X'4'; literal NAM$M_SYNCHK = %X'8'; literal NAM$M_NOCONCEAL = %X'10'; literal NAM$M_SLPARSE = %X'20'; literal NAM$M_SRCHXABS = %X'40'; literal NAM$C_UFS = 0; ! Unknown file system for remote file access or ! not applicable for local file access or literal NAM$C_NO_RFS = 0; ! task-to-task operation literal NAM$C_RMS11 = 1; ! RMS-11 literal NAM$C_RMS20 = 2; ! RMS-20 literal NAM$C_RMS32 = 3; ! RMS-32 literal NAM$C_FCS11 = 4; ! FCS-11 literal NAM$C_RT11FS = 5; ! RT-11 file system literal NAM$C_TOPS20FS = 7; ! TOPS-20 file system literal NAM$C_TOPS10FS = 8; ! TOPS-10 file system literal NAM$C_RMS32S = 10; ! RMS-32 subset (e.g., VAXELAN) literal NAM$C_CPMFS = 11; ! CP/M file system literal NAM$C_MS_DOSFS = 12; ! MS/DOS file system literal NAM$C_ULTRIX32_FS = 13; ! Ultrix-32 file system literal NAM$C_ULTRIX11_FS = 14; ! Ultrix-11 file system literal DAP$K_SNADTF_FS = 15; ! SNADTF compatable FS ! +++++++++++++++++++++++ literal NAM$C_DVI = 16; ! length of dvi field ! +++++***** literal NAM$M_IFI = %X'10000'; literal NAM$M_SRCHNMF = %X'40000000'; literal NAM$K_BLN_V2 = 56; ! Version 2 name block length literal NAM$C_BLN_V2 = 56; ! Version 2 name block length literal NAM$M_WILDCARD = %X'100'; literal NAM$M_SEARCH_LIST = %X'800'; literal NAM$M_CNCL_DEV = %X'1000'; literal NAM$M_ROOT_DIR = %X'2000'; literal NAM$M_LOWVER = %X'4000'; literal NAM$M_HIGHVER = %X'8000'; literal NAM$M_PPF = %X'10000'; literal NAM$M_NODE = %X'20000'; literal NAM$M_GRP_MBR = %X'80000'; literal NAM$M_WILD_DIR = %X'100000'; literal NAM$M_DIR_LVLS = %X'E00000'; literal NAM$K_BLN_DIRWC = 96; ! Not documented optional length literal NAM$C_BLN_DIRWC = 96; ! Not documented optional length literal NAM$K_BLN = 96; ! Name block length literal NAM$C_BLN = 96; ! Name block length literal NAM$S_NAMDEF = 96; macro NAM$B_BID = 0,0,8,0 %; ! block id macro NAM$B_BLN = 1,0,8,0 %; ! block length ! +++++++++++++++++++++++ ! the following 3 fields must not be rearranged relative to each other ! macro NAM$B_RSS = 2,0,8,0 %; ! resultant string area size macro NAM$B_RSL = 3,0,8,0 %; ! resultant string length macro NAM$L_RSA = 4,0,32,1 %; ! resultant string area address ! ----------------------- macro NAM$R_NOP_OVERLAY = 8,0,8,0 %; macro NAM$B_NOP = 8,0,8,0 %; ! Name options macro NAM$R_NOP_BITS = 8,0,8,0 %; macro NAM$V_PWD = 8,0,1,0 %; ! Return password if present in nodespec string and any ! other task-specific data of the form /netacp_data" ! (default is to mask out password from expanded and ! resultant name strings and to create a logical name ! whose equivalence string is the unaltered nodespec) macro NAM$V_FILL_1 = 8,1,1,0 %; ! unused. (used to be undocumented ROD) macro NAM$V_FILL_2 = 8,2,1,0 %; ! unused. (used to be undocumented SOD) macro NAM$V_SYNCHK = 8,3,1,0 %; ! Only do syntax check on $parse operation macro NAM$V_NOCONCEAL = 8,4,1,0 %; ! Do not conceal device/root directory macro NAM$V_SLPARSE = 8,5,1,0 %; ! Parse search list (not documented) -- used by BACKUP. macro NAM$V_SRCHXABS = 8,6,1,0 %; ! Fill in attached XABS on $SEARCH operations over the ! network (not documented) -- used by directory. macro NAM$B_RFS = 9,0,8,0 %; ! Remote file system type (currently not documented) ! Note: This field is reserved for use by Digital ! the following 3 fields must not be rearranged relative to each other ! macro NAM$B_ESS = 10,0,8,0 %; ! espanded string area size macro NAM$B_ESL = 11,0,8,0 %; ! expanded string length macro NAM$L_ESA = 12,0,32,1 %; ! expanded string area address ! ----------------------- macro NAM$L_RLF = 16,0,32,1 %; ! related file nam block addr macro NAM$T_DVI = 20,0,0,0 %; literal NAM$S_DVI = 16; ! device id ! the location of the following fields must not ! be changed due to their commonality with the fib macro NAM$R_FID_OVERLAY = 36,0,0,0 %; macro NAM$W_FID = 36,0,0,0 %; literal NAM$S_FID = 6; ! file id macro NAM$R_FID_FIELDS = 36,0,0,0 %; macro NAM$W_FID_NUM = 36,0,16,0 %; ! file number macro NAM$W_FID_SEQ = 38,0,16,0 %; ! sequence number macro NAM$R_FID_RVN_OVERLAY = 40,0,16,0 %; macro NAM$W_FID_RVN = 40,0,16,0 %; ! relative volume number macro NAM$R_FID_RVN_FIELDS = 40,0,16,0 %; macro NAM$B_FID_RVN = 40,0,8,0 %; ! alternate format RVN macro NAM$B_FID_NMX = 41,0,8,0 %; ! alternate format file number extension macro NAM$R_DID_OVERLAY = 42,0,0,0 %; macro NAM$W_DID = 42,0,0,0 %; literal NAM$S_DID = 6; ! directory id macro NAM$R_DID_FIELDS = 42,0,0,0 %; macro NAM$W_DID_NUM = 42,0,16,0 %; ! file number macro NAM$W_DID_SEQ = 44,0,16,0 %; ! sequence number macro NAM$R_DID_RVN_OVERLAY = 46,0,16,0 %; macro NAM$W_DID_RVN = 46,0,16,0 %; ! relative volume number macro NAM$R_DID_RVN_FIELDS = 46,0,16,0 %; macro NAM$B_DID_RVN = 46,0,8,0 %; ! alternate format RVN macro NAM$B_DID_NMX = 47,0,8,0 %; ! alternate format file number extension macro NAM$R_WCC_OVERLAY = 48,0,32,0 %; macro NAM$L_WCC = 48,0,32,0 %; ! wild card context macro NAM$R_WCC_BITS = 48,0,32,0 %; macro NAM$V_IFI = 48,16,1,0 %; ! the first word contains an IFI macro NAM$V_SRCHNMF = 48,30,1,0 %; ! no-more-files has been encountered on a search macro NAM$V_SVCTX = 48,31,1,0 %; ! save context across search calls macro NAM$R_FNB_OVERLAY = 52,0,32,0 %; macro NAM$L_FNB = 52,0,32,0 %; ! file name status bits macro NAM$R_FNB_BITS0 = 52,0,24,0 %; macro NAM$V_EXP_VER = 52,0,1,0 %; ! version was explicit macro NAM$V_EXP_TYPE = 52,1,1,0 %; ! type was explicit macro NAM$V_EXP_NAME = 52,2,1,0 %; ! name was explicit macro NAM$V_WILD_VER = 52,3,1,0 %; ! version contained a wild card macro NAM$V_WILD_TYPE = 52,4,1,0 %; ! type contained a wild card macro NAM$V_WILD_NAME = 52,5,1,0 %; ! name contained a wild card macro NAM$V_EXP_DIR = 52,6,1,0 %; ! directory was explicit macro NAM$V_EXP_DEV = 52,7,1,0 %; ! device was explicit macro NAM$V_WILDCARD = 52,8,1,0 %; ! filename string included a wild card ! (inclusive or of other wild card bits) macro NAM$V_SEARCH_LIST = 52,11,1,0 %; ! search list present macro NAM$V_CNCL_DEV = 52,12,1,0 %; ! concealed device present macro NAM$V_ROOT_DIR = 52,13,1,0 %; ! root directory present macro NAM$V_LOWVER = 52,14,1,0 %; ! lower numbered version(s) of file exist(s) macro NAM$V_HIGHVER = 52,15,1,0 %; ! higher " ! macro NAM$V_PPF = 52,16,1,0 %; ! process-permanent file referenced indirectly macro NAM$V_NODE = 52,17,1,0 %; ! filename specification included a nodename macro NAM$V_QUOTED = 52,18,1,0 %; ! filename spec included a quoted string macro NAM$V_GRP_MBR = 52,19,1,0 %; ! directory spec was of group-member format macro NAM$V_WILD_DIR = 52,20,1,0 %; ! directory spec included a wild card macro NAM$V_DIR_LVLS = 52,21,3,0 %; literal NAM$S_DIR_LVLS = 3; ! number of directory levels (0=ufd only) macro NAM$R_FNB_BITS1 = 52,0,32,0 %; macro NAM$V_WILD_UFD = 52,24,1,0 %; ! ufd included a wild card macro NAM$V_WILD_SFD1 = 52,25,1,0 %; ! sfd1 included a wild card macro NAM$V_WILD_SFD2 = 52,26,1,0 %; ! sfd2 included a wild card macro NAM$V_WILD_SFD3 = 52,27,1,0 %; ! sfd3 included a wild card macro NAM$V_WILD_SFD4 = 52,28,1,0 %; ! sfd4 included a wild card macro NAM$V_WILD_SFD5 = 52,29,1,0 %; ! sfd5 included a wild card macro NAM$V_WILD_SFD6 = 52,30,1,0 %; ! sfd6 included a wild card macro NAM$V_WILD_SFD7 = 52,31,1,0 %; ! sfd7 included a wild card macro NAM$R_FNB_BITS2 = 52,0,32,0 %; macro NAM$V_WILD_GRP = 52,24,1,0 %; ! group contained a wild card macro NAM$V_WILD_MBR = 52,25,1,0 %; ! member contained a wild card ! -----***** ! (prior to 40 byte extension) ! ! Extend the NAM block by 40 bytes. ! macro NAM$B_NODE = 56,0,8,0 %; ! Nodespec length macro NAM$B_DEV = 57,0,8,0 %; ! Device length macro NAM$B_DIR = 58,0,8,0 %; ! Directory length macro NAM$B_NAME = 59,0,8,0 %; ! Filename length macro NAM$B_TYPE = 60,0,8,0 %; ! Filetype length macro NAM$B_VER = 61,0,8,0 %; ! Version number length macro NAM$L_NODE = 64,0,32,1 %; ! Nodespec address macro NAM$L_DEV = 68,0,32,1 %; ! Device address macro NAM$L_DIR = 72,0,32,1 %; ! Directory address macro NAM$L_NAME = 76,0,32,1 %; ! Filename address macro NAM$L_TYPE = 80,0,32,1 %; ! Filetype address macro NAM$L_VER = 84,0,32,1 %; ! Version number address MACRO $RMS_OFFSET(NAME) = $RMS_OFFSET_1(%REMOVE(NAME)) %, $RMS_OFFSET_1 (X) = X %; MACRO $RMS_BITS(A,B)[]= %NAME(A,B) $RMS_OR(%REMAINING) $RMS_BITS(A,%REMAINING) %, $RMS_OR[]= OR %, $RMS_BITFLD(ALLOC,PREFIX,VALUE)= %IF %NULL(VALUE) %THEN ALLOC(0) %ELSE ALLOC($RMS_BITS(PREFIX,%REMOVE(VALUE))) %FI %, $RMS_BITFLD_INI(BLK,NAME,PREFIX,VALUE)= %IF %NULL(VALUE) %THEN %EXITMACRO %FI BLOCK[BLK,%REMOVE(NAME);0,BYTE] = $RMS_BITS(PREFIX,%REMOVE(VALUE)) %, $RMS_CODFLD(ALLOC,PREFIX,VALUE)= ALLOC(%NAME(PREFIX,%REMOVE(VALUE))) %, $RMS_CODFLD_INI(BLK,NAME,PREFIX,VALUE)= %IF %NULL(VALUE) %THEN %EXITMACRO %FI BLOCK[BLK,%REMOVE(NAME);0,BYTE] = (%NAME(PREFIX,%REMOVE(VALUE))) %, $RMS_VALFLD(ALLOC,VALUE)= ALLOC(VALUE) %, $RMS_VALFLD_INI(BLK,NAME,VALUE)= %IF %NULL(VALUE) %THEN %EXITMACRO %FI %IF %IDENTICAL(VALUE,0) %THEN %EXITMACRO %FI BLOCK[BLK,%REMOVE(NAME);0,BYTE] = VALUE %, $RMS_8FLD(ALLOC,VAL0,VAL1,VAL2,VAL3,VAL4,VAL5,VAL6,VAL7)= ALLOC( %IF %NULL(VAL0) %THEN (0) %ELSE (VAL0) %FI, %IF %NULL(VAL1) %THEN (0) %ELSE (VAL1) %FI, %IF %NULL(VAL2) %THEN (0) %ELSE (VAL2) %FI, %IF %NULL(VAL3) %THEN (0) %ELSE (VAL3) %FI, %IF %NULL(VAL4) %THEN (0) %ELSE (VAL4) %FI, %IF %NULL(VAL5) %THEN (0) %ELSE (VAL5) %FI, %IF %NULL(VAL6) %THEN (0) %ELSE (VAL6) %FI, %IF %NULL(VAL7) %THEN (0) %ELSE (VAL7) %FI )%, $RMS_8FLD_INI(BLK,NAME) [VAL]= %IF %COUNT GEQ 8 %THEN %ERROR('Excess POS or SIZ values.') %EXITMACRO %FI $RMS_VALFLD_INI(BLK, (%NAME(NAME,%COUNT)), VAL) %, $RMS_VALPR2(RWEDCHAR)[]= AND NOT %IF %IDENTICAL(RWEDCHAR,'R') %THEN XAB$M_NOREAD %ELSE %IF %IDENTICAL(RWEDCHAR,'W') %THEN XAB$M_NOWRITE %ELSE %IF %IDENTICAL(RWEDCHAR,'E') %THEN XAB$M_NOEXE %ELSE %IF %IDENTICAL(RWEDCHAR,'D') %THEN XAB$M_NODEL %ELSE 0 %ERROR('Illegal value "', RWEDCHAR, '" of parameter PRO') %FI %FI %FI %FI $RMS_VALPR2(%REMAINING) %, $RMS_VALPR1(RWEDGROUP)= %B'1111' $RMS_VALPR2(%EXPLODE(RWEDGROUP)) %, $RMS_VALPRO(SYSTEM,OWNER,GROUP,WORLD)= %IF %LENGTH GTR 4 %THEN WORD(0) %ERROR('Illegal value of parameter PRO') %ELSE WORD( ($RMS_VALPR1(SYSTEM)) OR ($RMS_VALPR1(OWNER))^4 OR ($RMS_VALPR1(GROUP))^8 OR ($RMS_VALPR1(WORLD))^12) %FI %, $RMS_VALPRO_INI(BLK,SYSTEM,OWNER,GROUP,WORLD)= %IF %LENGTH GTR 5 %THEN %ERROR('Illegal value of parameter PRO') %EXITMACRO %FI %IF %LENGTH EQL 1 %THEN %EXITMACRO %FI BLOCK[BLK,XAB$W_PRO;0,BYTE] = ($RMS_VALPR1(SYSTEM) OR ($RMS_VALPR1(OWNER))^4 OR ($RMS_VALPR1(GROUP))^8 OR ($RMS_VALPR1(WORLD))^12) %, $RMS_VALRFI(FILENO,SEQNO,RVN)= %IF %LENGTH NEQ 3 %THEN REP 3 OF WORD(0) %ERROR('Illegal value of parameter RFI') %ELSE WORD(FILENO,SEQNO,RVN) %FI %, $RMS_VALRFI_INI(BLK,FILENO,SEQNO,RVN)= %IF %LENGTH NEQ 4 %THEN %ERROR('Illegal value of parameter RFI') %EXITMACRO %FI %IF %IDENTICAL(FILENO,0) AND %IDENTICAL(SEQNO ,0) AND %IDENTICAL(RVN ,0) %THEN %EXITMACRO %FI BLOCK[BLK,XAB$W_RFI0;0,BYTE]= FILENO; BLOCK[BLK,XAB$W_RFI2;0,BYTE]= SEQNO; BLOCK[BLK,XAB$W_RFI4;0,BYTE]= RVN %; !++ ! ! $FAB_DECL ! ! Used to declare a FAB control block where ! initialization is not required. !-- MACRO $FAB_DECL = BLOCK[FAB$C_BLN,BYTE] %; !++ ! ! $FAB ! ! Used to allocate and statically initialize ! a FAB control block. ! !-- KEYWORDMACRO $FAB( FAC=GET, SHR, FNA=0, FNS=0, DNA=0, DNS=0, RTV=0, ORG=SEQ, RAT, FOP, XAB=0, MRS=0, JOURNAL, MRN=0, ALQ=0, DEQ=0, BLS=0, NAM=0, RFM=VAR, FSZ=0, FNM, DNM, BKS=0, CTX=0, GBC=0, LNM_MODE=0, CHAN_MODE=0, FILE_MODE=0, RU_FACILITY=0 )= $FAB_DECL INITIAL( $RMS_VALFLD(BYTE, FAB$C_BID), ! BID $RMS_VALFLD(BYTE, FAB$C_BLN), ! BLN $RMS_VALFLD(WORD, 0), ! IFI $RMS_BITFLD(LONG, FAB$M_, FOP), ! FOP $RMS_VALFLD(LONG, 0), ! STS $RMS_VALFLD(LONG, 0), ! STV $RMS_VALFLD(LONG, ALQ), ! ALQ $RMS_VALFLD(WORD, DEQ), ! DEQ $RMS_BITFLD(BYTE, FAB$M_, FAC), ! FAC $RMS_BITFLD(BYTE, FAB$M_, SHR), ! SHR $RMS_VALFLD(LONG, CTX), ! CTX $RMS_VALFLD(BYTE, RTV), ! RTV $RMS_CODFLD(BYTE, FAB$C_, ORG), ! ORG $RMS_BITFLD(BYTE, FAB$M_, RAT), ! RAT $RMS_CODFLD(BYTE, FAB$C_, RFM), ! RFM $RMS_BITFLD(BYTE, FAB$M_, JOURNAL), ! JOURNAL $RMS_VALFLD(BYTE, RU_FACILITY), ! RU_FACILITY $RMS_VALFLD(WORD, 0), ! SPARE $RMS_VALFLD(LONG, XAB), ! XAB $RMS_VALFLD(LONG, NAM), ! NAM %IF %NULL(FNM) %THEN $RMS_VALFLD(LONG, FNA), ! FNA %ELSE $RMS_VALFLD(LONG, UPLIT BYTE(FNM)), ! FNA %FI %IF %NULL(DNM) %THEN $RMS_VALFLD(LONG, DNA), ! DNA %ELSE $RMS_VALFLD(LONG, UPLIT BYTE(DNM)), ! DNA %FI %IF %NULL(FNM) %THEN $RMS_VALFLD(BYTE, FNS), ! FNS %ELSE $RMS_VALFLD(BYTE, %CHARCOUNT(FNM)), ! FNS %FI %IF %NULL(DNM) %THEN $RMS_VALFLD(BYTE, DNS), ! DNS %ELSE $RMS_VALFLD(BYTE, %CHARCOUNT(DNM)), ! DNS %FI $RMS_VALFLD(WORD, MRS), ! MRS $RMS_VALFLD(LONG, MRN), ! MRN $RMS_VALFLD(WORD, BLS), ! BLS $RMS_VALFLD(BYTE, BKS), ! BKS $RMS_VALFLD(BYTE, FSZ), ! FSZ $RMS_VALFLD(LONG, 0), ! DEV $RMS_VALFLD(LONG, 0), ! SDC $RMS_VALFLD(WORD, GBC), ! GBC BYTE( ! ACMODES ( LNM_MODE ^ $BITPOSITION(FAB$V_LNM_MODE) ) + ( CHAN_MODE ^ $BITPOSITION(FAB$V_CHAN_MODE) ) + ( FILE_MODE ^ $BITPOSITION(FAB$V_FILE_MODE) ) ), $RMS_VALFLD(BYTE, 0), ! RCF $RMS_VALFLD(LONG, 0) ! SPARE ) %; !++ ! ! $NAM_DECL ! ! Permits the declaration of the NAM control block ! where initialization is not required. ! !-- MACRO $NAM_DECL = BLOCK[NAM$C_BLN,BYTE] %; !++ ! ! $NAM ! ! Macro to allocate and initialize the NAM control block. ! !-- KEYWORDMACRO $NAM( RSA=0, RSS=0, ESA=0, ESS=0, RLF=0, NOP)= $NAM_DECL INITIAL( $RMS_VALFLD(BYTE, NAM$C_BID), ! BID $RMS_VALFLD(BYTE, NAM$C_BLN), ! BLN $RMS_VALFLD(BYTE, RSS), ! RSS $RMS_VALFLD(BYTE, 0), ! RSL $RMS_VALFLD(LONG, RSA), ! RSA $RMS_BITFLD(BYTE, NAM$M_, NOP), ! NOP $RMS_VALFLD(BYTE, 0), ! RFS $RMS_VALFLD(BYTE, ESS), ! ESS $RMS_VALFLD(BYTE, 0), ! ESL $RMS_VALFLD(LONG, ESA), ! ESA $RMS_VALFLD(LONG, RLF), ! RLF REP 8 OF $RMS_VALFLD(WORD, 0), ! DVI REP 3 OF $RMS_VALFLD(WORD, 0), ! FID REP 3 OF $RMS_VALFLD(WORD, 0), ! DID $RMS_VALFLD(LONG, 0), ! WCC $RMS_VALFLD(LONG, 0), ! FNB $RMS_VALFLD(BYTE, 0), ! NODE $RMS_VALFLD(BYTE, 0), ! DEV $RMS_VALFLD(BYTE, 0), ! DIR $RMS_VALFLD(BYTE, 0), ! NAME/QUOTED $RMS_VALFLD(BYTE, 0), ! TYPE $RMS_VALFLD(BYTE, 0), ! VER REP 2 OF $RMS_VALFLD(BYTE, 0), ! SPARE $RMS_VALFLD(LONG, 0), ! NODE $RMS_VALFLD(LONG, 0), ! DEV $RMS_VALFLD(LONG, 0), ! DIR $RMS_VALFLD(LONG, 0), ! NAME/QUOTED $RMS_VALFLD(LONG, 0), ! TYPE $RMS_VALFLD(LONG, 0), ! VER REP 2 OF $RMS_VALFLD(LONG, 0) ! SPARE ) %; MACRO $RAB_DECL = BLOCK[RAB$C_BLN,BYTE] %; KEYWORDMACRO $RAB( RAC=SEQ, ROP, UBF=0, USZ=0, RBF=0, RSZ=0, BKT=0, KBF=0, PBF=0, KSZ=0, PSZ=0, RHB=0, FAB=0, MBF=0, MBC=0, TMO=0, CTX=0, KRF=0, ASYN=NO, XAB=0)= $RAB_DECL INITIAL( $RMS_VALFLD(BYTE, RAB$C_BID), ! BID $RMS_VALFLD(BYTE, RAB$C_BLN), ! BLN $RMS_VALFLD(WORD, 0), ! ISI $RMS_BITFLD(LONG, RAB$M_, ROP), ! ROP $RMS_VALFLD(LONG, 0), ! STS $RMS_VALFLD(LONG, 0), ! STV REP 3 OF $RMS_VALFLD(WORD, 0), ! RFA $RMS_VALFLD(WORD, 0), ! SPARE $RMS_VALFLD(LONG, CTX), ! CTX $RMS_VALFLD(WORD, 0), ! SPARE $RMS_CODFLD(BYTE, RAB$C_, RAC), ! RAC $RMS_VALFLD(BYTE, TMO), ! TMO $RMS_VALFLD(WORD, USZ), ! USZ $RMS_VALFLD(WORD, RSZ), ! RSZ $RMS_VALFLD(LONG, UBF), ! UBF $RMS_VALFLD(LONG, RBF), ! RBF $RMS_VALFLD(LONG, RHB), ! RHB $RMS_VALFLD(LONG, (KBF)+(PBF)), ! KBF and PBF $RMS_VALFLD(BYTE, (KSZ)+(PSZ)), ! KSZ and PSZ $RMS_VALFLD(BYTE, KRF), ! KRF $RMS_VALFLD(BYTE, MBF), ! MBF $RMS_VALFLD(BYTE, MBC), ! MBC $RMS_VALFLD(LONG, BKT), ! BKT $RMS_VALFLD(LONG, FAB), ! FAB $RMS_VALFLD(LONG, XAB) ! XAB ) %;