; 0001 0 MODULE LOCK ; 0002 0 ( ; 0003 0 MAIN = LOCK, ; 0004 0 %TITLE'Lock resource at DCL level' ; 0005 0 IDENT = '1-0.0' ; 0006 0 ) = ; 0007 0 ; 0008 1 BEGIN ; 0009 1 !++ ; 0010 1 ! FACILITY: User utilities ; 0011 1 ! ; 0012 1 ! ABSTRACT: ; 0013 1 ! ; 0014 1 ! This program allows the user to lock resources using supervisor-mode ; 0015 1 ! locks, which will not be dequeued upon image rundown. ; 0016 1 ! ; 0017 1 ! ENVIRONMENT: User mode, kernel mode, CMKRNL required, ; 0018 1 ! possibly SYSLCK ; 0019 1 ! ; 0020 1 ! AUTHOR: Ken A L Coar ; 0021 1 ! ; 0022 1 ! MODIFIED BY: ; 0023 1 ! ; 0024 1 ! KLC0178 Ken Coar 1-APR-1986 08:22 ; 0025 1 ! Genesis. ; 0026 1 !-- ; 0027 1 ; 0028 1 %SBTTL'Declarations' ; 0029 1 ; 0030 1 ! ; 0031 1 ! SWITCHES: ; 0032 1 ! ; 0033 1 ; 0034 1 SWITCHES ; 0035 1 ADDRESSING_MODE (EXTERNAL = GENERAL, NONEXTERNAL = WORD_RELATIVE); ; 0036 1 ; 0037 1 ! ; 0038 1 ! LINKAGES: ; 0039 1 ! ; 0040 1 ! NONE. ; 0041 1 ! ; 0042 1 ; 0043 1 ! ; 0044 1 ! INCLUDE FILES: ; 0045 1 ! ; 0046 1 ; 0047 1 LIBRARY 'KEN_LIBRARY:LIB'; ! LIB plus STARLET ; 0048 1 LIBRARY 'KEN_LIBRARY:KENLIB'; ! Local declarations ; 0049 1 ; 0050 1 ! ; 0051 1 ! FORWARD ROUTINES: ; 0052 1 ! ; 0053 1 ; 0054 1 FORWARD ROUTINE ; 0055 1 EXIT_HANDLER : INTERNAL_CALL, ; 0056 1 KERNEL_CANCEL : INTERNAL_CALL, ; 0057 1 KERNEL_ENQ : INTERNAL_CALL, ; 0058 1 KERNEL_POST : INTERNAL_CALL; ; 0059 1 ; 0060 1 ! ; 0061 1 ! EXTERNAL REFERENCES: ; 0062 1 ! ; 0063 1 ; 0064 1 EXTERNAL ROUTINE ; 0065 1 CLI$GET_VALUE, ; 0066 1 CLI$PRESENT, ; 0067 1 LIB$GET_EF, ; 0068 1 LIB$LOOKUP_KEY, ; 0069 1 LIB$SYS_FAO, ; 0070 1 LIB_CLI_SIG_TO_RET; ; 0071 1 ; 0072 1 EXTERNAL LITERAL ; 0073 1 LOCK_OBTAINED, ; 0074 1 LOCK_RELEASED, ; 0075 1 LOCK_CONVERTED, ; 0076 1 LOCK_WAIT, ; 0077 1 LOCK_CANCELLED, ; 0078 1 LOCK_NOTLOCKED, ; 0079 1 LOCK_NOWAIT; ; 0080 1 ; 0081 1 ! ; 0082 1 ! MACROS: ; 0083 1 ! ; 0084 1 ! NONE. ; 0085 1 ! ; 0086 1 ; 0087 1 ! ; 0088 1 ! EQUATED SYMBOLS: ; 0089 1 ! ; 0090 1 ! NONE. ; 0091 1 ! ; 0092 1 ; 0093 1 ! ; 0094 1 ! FIELDS: ; 0095 1 ! ; 0096 1 ; 0097 1 MDL_STRUCT (OP); ; 0098 1 MDL_FIELD (FLAGS, L, ); ; P 0099 1 MDL_BIT( ; P 0100 1 MASK, , ; P 0101 1 (CONVERT, ), ; P 0102 1 (QUEUED, ), ; P 0103 1 (SYSLOCK, ), ; P 0104 1 (RELEASE, ), ; P 0105 1 (WAIT, ), ; P 0106 1 (LOG, ) ; 0107 1 ); ; 0108 1 MDL_FIELD (MODE, B, ); ; 0109 1 MDL_FIELD (EF, L, ); ; 0110 1 MDL_LENGTH (LENGTH); ; 0111 1 MDL_END; ; 0112 1 ; 0113 1 ! ; 0114 1 ! PSECTS: ; 0115 1 ! ; 0116 1 ; 0117 1 RTL_PSECTS (FACILITY=LIB); ; 0118 1 ; 0119 1 ! ; 0120 1 ! OWN STORAGE: ; 0121 1 ! ; 0122 1 ; 0123 1 OWN ; 0124 1 OP : BBLOCK [OP_K_LENGTH] ; 0125 1 INITIAL (REP OP_K_LENGTH OF BYTE (0)), ; 0126 1 LKSTAT : _LKSB, ; 0127 1 ESTATUS : LONG, ; 0128 1 EBLOCK : VECTOR [4, LONG] ; 0129 1 PRESET( ; 0130 1 [1] = EXIT_HANDLER, ; 0131 1 [2] = 1, ; 0132 1 [3] = ESTATUS ; 0133 1 ), ; 0134 1 DSCR : DESCR (CLASS=DYNAMIC), ; 0135 1 DRESOURCE : DESCR (CLASS=DYNAMIC), ; 0136 1 DLNAME : DESCR (CLASS=DYNAMIC), ; 0137 1 DMODE : DESCR (CLASS=DYNAMIC), ; 0138 1 DOMODE : DESCR (CLASS=DYNAMIC), ; 0139 1 MESSAGE : VECTOR [10, LONG]; ; 0140 1 ; 0141 1 BIND ; 0142 1 KD_P1 = %ASCID'P1', ; 0143 1 KD_SCOPE = %ASCID'SCOPE', ; 0144 1 KD_MODE = %ASCID'MODE', ; 0145 1 KD_RELEASE = %ASCID'RELEASE', ; 0146 1 KD_WAIT = %ASCID'WAIT', ; 0147 1 KD_LOG = %ASCID'LOG', ; 0148 1 KD_LNAME = %ASCID'LOCK_!AS', ; 0149 1 KD_LTABLE = %ASCID'LNM$PROCESS', ; 0150 1 KD_AF = %ASCID'!AF', ; P 0151 1 KR_MODES = $KEY_TABLE( ; P 0152 1 ('CREAD', LCK$K_CRMODE), ; P 0153 1 ('CWRITE', LCK$K_CWMODE), ; P 0154 1 ('EXCLUSIVE', LCK$K_EXMODE), ; P 0155 1 ('NULL', LCK$K_NLMODE), ; P 0156 1 ('PREAD', LCK$K_PRMODE), ; P 0157 1 ('PWRITE', LCK$K_PWMODE) ; 0158 1 ), ; P 0159 1 KR_SCOPES = $KEY_TABLE( ; P 0160 1 ('GROUP', 0), ; P 0161 1 ('SYSTEM', 1) ; 0162 1 ); ; 0163 1 %SBTTL'EXIT_HANDLER - Cancel request on program abort' ; 0164 1 ROUTINE EXIT_HANDLER : INTERNAL_CALL = ; 0165 1 !++ ; 0166 1 ! FUNCTIONAL DESCRIPTION: ; 0167 1 ! ; 0168 1 ! This routine is called as an exit handler when the program aborts ; 0169 1 ! unexpectedly. His task is to cancel an outstanding $ENQ request ; 0170 1 ! in kernel mode so it doesn't complete after the program has run down. ; 0171 1 ! ; 0172 1 ! CALLING SEQUENCE: ; 0173 1 ! ; 0174 1 ! EXIT_HANDLER () ; 0175 1 ! ; 0176 1 ! FORMAL PARAMETERS: ; 0177 1 ! ; 0178 1 ! NONE. ; 0179 1 ! ; 0180 1 ! IMPLICIT INPUTS: ; 0181 1 ! ; 0182 1 ! OP control block describes how far we've gotten and what we're doing. ; 0183 1 ! ; 0184 1 ! IMPLICIT OUTPUTS: ; 0185 1 ! ; 0186 1 ! NONE. ; 0187 1 ! ; 0188 1 ! COMPLETION STATUS: ; 0189 1 ! ; 0190 1 ! SS$_NORMAL successful completion ; 0191 1 ! ; 0192 1 ! SIDE EFFECTS: ; 0193 1 ! ; 0194 1 ! Any outstanding lock request gets canned. ; 0195 1 ! ; 0196 1 !-- ; 0197 2 BEGIN ; 0198 2 LOCAL ; 0199 2 STATUS : LONG; ; 0200 2 IF NOT .OP [OP_V_QUEUED] THEN RETURN SS$_NORMAL; ; 0201 2 %CHECK (STATUS = $CMKRNL (ROUTIN=KERNEL_CANCEL)); ; 0202 2 ! ; 0203 2 ! Now, it's possible that the request was granted in the meantime, ; 0204 2 ! so we shouldn't display the 'cancelled' message. We should, however, ; 0205 2 ! ensure that the logical name gets defined, because it obviously ; 0206 2 ! hasn't if QUEUED is set and the lock was granted. ; 0207 2 ! ; 0208 2 IF .STATUS EQL SS$_CANCELGRANT THEN RETURN KERNEL_POST (); ; 0209 2 ! ; 0210 2 ! All right, we really cancelled an outstanding request. Tell the ; 0211 2 ! user about it, and exit with the appropriate status. ; 0212 2 ! ; 0213 2 MESSAGE [0] = 4; ; 0214 2 MESSAGE [1] = LOCK_CANCELLED; ; 0215 2 MESSAGE [2] = 2; ; 0216 2 MESSAGE [3] = 0; ; 0217 2 MESSAGE [4] = DRESOURCE; ; 0218 2 $PUTMSG (MSGVEC=MESSAGE); ; 0219 2 RETURN $EXIT (CODE=.MESSAGE [1] OR STS$M_INHIB_MSG); ; 0220 1 END; .TITLE LOCK Lock resource at DCL level .IDENT \1-0.0\ .PSECT _LIB_DATA,NOEXE, PIC,0 ;OP U.5: .BYTE 0[9] ; 00# 00000 .BLKB 3 ; 00009 ;LKSTAT U.6: .BLKB 8 ; 0000C ;ESTATUS U.7: .BLKB 4 ; 00014 ;EBLOCK U.8: .BYTE 0[4] ; 00# 00018 .ADDRESS U.1 ; 00000000' 0001C .LONG 1 ; 00000001 00020 .ADDRESS U.7 ; 00000000' 00024 ;DSCR U.9: .WORD 0 ; 0000 00028 .BYTE 0, 2 ; 02 00 0002A .LONG 0 ; 00000000 0002C ;DRESOURCE U.10: .WORD 0 ; 0000 00030 .BYTE 0, 2 ; 02 00 00032 .LONG 0 ; 00000000 00034 ;DLNAME U.11: .WORD 0 ; 0000 00038 .BYTE 0, 2 ; 02 00 0003A .LONG 0 ; 00000000 0003C ;DMODE U.12: .WORD 0 ; 0000 00040 .BYTE 0, 2 ; 02 00 00042 .LONG 0 ; 00000000 00044 ;DOMODE U.13: .WORD 0 ; 0000 00048 .BYTE 0, 2 ; 02 00 0004A .LONG 0 ; 00000000 0004C ;MESSAGE U.14: .BLKB 40 ; 00050 .PSECT _LIB_CODE,NOWRT, SHR, PIC,0 P.AAB: .ASCII \P1\<0><0> ; 00 00 31 50 00000 P.AAA: .LONG 17694722 ; 010E0002 00004 .ADDRESS P.AAB ; 00000000' 00008 P.AAD: .ASCII \SCOPE\<0><0><0> ; 00 00 00 45 50 4F 43 53 0000C P.AAC: .LONG 17694725 ; 010E0005 00014 .ADDRESS P.AAD ; 00000000' 00018 P.AAF: .ASCII \MODE\ ; 45 44 4F 4D 0001C P.AAE: .LONG 17694724 ; 010E0004 00020 .ADDRESS P.AAF ; 00000000' 00024 P.AAH: .ASCII \RELEASE\<0> ; 00 45 53 41 45 4C 45 52 00028 P.AAG: .LONG 17694727 ; 010E0007 00030 .ADDRESS P.AAH ; 00000000' 00034 P.AAJ: .ASCII \WAIT\ ; 54 49 41 57 00038 P.AAI: .LONG 17694724 ; 010E0004 0003C .ADDRESS P.AAJ ; 00000000' 00040 P.AAL: .ASCII \LOG\<0> ; 00 47 4F 4C 00044 P.AAK: .LONG 17694723 ; 010E0003 00048 .ADDRESS P.AAL ; 00000000' 0004C P.AAN: .ASCII \LOCK_!AS\ ; 53 41 21 5F 4B 43 4F 4C 00050 P.AAM: .LONG 17694728 ; 010E0008 00058 .ADDRESS P.AAN ; 00000000' 0005C P.AAP: .ASCII \LNM$PROCESS\<0> ; 43 4F 52 50 24 4D 4E 4C 00060 ; 00 53 53 45 00068 P.AAO: .LONG 17694731 ; 010E000B 0006C .ADDRESS P.AAP ; 00000000' 00070 P.AAR: .ASCII \!AF\<0> ; 00 46 41 21 00074 P.AAQ: .LONG 17694723 ; 010E0003 00078 .ADDRESS P.AAR ; 00000000' 0007C P.AAT: .ASCII <5>\CREAD\<0><0> ; 00 00 44 41 45 52 43 05 00080 P.AAU: .ASCII <6>\CWRITE\<0> ; 00 45 54 49 52 57 43 06 00088 P.AAV: .ASCII <9>\EXCLUSIVE\<0><0> ; 49 53 55 4C 43 58 45 09 00090 ; 00 00 45 56 00098 P.AAW: .ASCII <4>\NULL\<0><0><0> ; 00 00 00 4C 4C 55 4E 04 0009C P.AAX: .ASCII <5>\PREAD\<0><0> ; 00 00 44 41 45 52 50 05 000A4 P.AAY: .ASCII <6>\PWRITE\<0> ; 00 45 54 49 52 57 50 06 000AC P.AAS: .LONG 12 ; 0000000C 000B4 .ADDRESS P.AAT ; 00000000' 000B8 .LONG 1 ; 00000001 000BC .ADDRESS P.AAU ; 00000000' 000C0 .LONG 2 ; 00000002 000C4 .ADDRESS P.AAV ; 00000000' 000C8 .LONG 5 ; 00000005 000CC .ADDRESS P.AAW ; 00000000' 000D0 .LONG 0 ; 00000000 000D4 .ADDRESS P.AAX ; 00000000' 000D8 .LONG 3 ; 00000003 000DC .ADDRESS P.AAY ; 00000000' 000E0 .LONG 4 ; 00000004 000E4 P.ABA: .ASCII <5>\GROUP\<0><0> ; 00 00 50 55 4F 52 47 05 000E8 P.ABB: .ASCII <6>\SYSTEM\<0> ; 00 4D 45 54 53 59 53 06 000F0 P.AAZ: .LONG 4 ; 00000004 000F8 .ADDRESS P.ABA ; 00000000' 000FC .LONG 0 ; 00000000 00100 .ADDRESS P.ABB ; 00000000' 00104 .LONG 1 ; 00000001 00108 U.15= P.AAA U.16= P.AAC U.17= P.AAE U.18= P.AAG U.19= P.AAI U.20= P.AAK U.21= P.AAM U.22= P.AAO U.23= P.AAQ U.24= P.AAS U.25= P.AAZ .EXTRN CLI$GET_VALUE, CLI$PRESENT, LIB$GET_EF, LIB$LOOKUP_KEY, LIB$SYS_FAO, LIB_CLI_SIG_TO_RET .EXTRN LOCK_OBTAINED, LOCK_RELEASED, LOCK_CONVERTED, LOCK_WAIT, LOCK_CANCELLED, LOCK_NOTLOCKED .EXTRN LOCK_NOWAIT, SYS$CMKRNL, SYS$PUTMSG, SYS$EXIT ;EXIT_HANDLER U.1: .WORD ^M ;Save R2 0164 0004 00000 MOVAB L^U.14, R2 ;U.14, R2 52 00000000' EF 9E 00002 BBS #1, -80(R2), 1$ ;#1, OP, 1$ 0200 B0 A2 01 E0 00009 ; 04 0000D MOVL #1, R0 ;#1, R0 50 01 D0 0000E RET ; 04 00011 1$: CLRL -(SP) ;-(SP) 0201 7E D4 00012 PUSHAB W^U.2 ;U.2 0000V CF 9F 00014 CALLS #2, G^SYS$CMKRNL ;#2, SYS$CMKRNL 00000000G 00 02 FB 00018 MOVL R0, R1 ;STATUS, ___STATUS 51 50 D0 0001F BLBS R1, 2$ ;___STATUS, 2$ 04 51 E8 00022 MOVL R1, R0 ;___STATUS, R0 50 51 D0 00025 RET ; 04 00028 2$: CMPL R0, #3626 ;STATUS, #3626 0208 00000E2A 8F 50 D1 00029 BNEQ 3$ ;3$ 06 12 00030 CALLS #0, W^U.4 ;#0, U.4 0000V CF 00 FB 00032 RET ; 04 00037 3$: MOVL #4, (R2) ;#4, MESSAGE 0213 62 04 D0 00038 MOVL #LOCK_CANCELLED, 4(R2) ;#LOCK_CANCELLED, MESSAGE+4 0214 04 A2 00000000G 8F D0 0003B MOVQ #2, 8(R2) ;#2, MESSAGE+8 0215 08 A2 02 7D 00043 MOVAB -32(R2), 16(R2) ;DRESOURCE, MESSAGE+16 0217 10 A2 E0 A2 9E 00047 CLRQ -(SP) ;-(SP) 0218 7E 7C 0004C CLRL -(SP) ;-(SP) 7E D4 0004E PUSHL R2 ;R2 52 DD 00050 CALLS #4, G^SYS$PUTMSG ;#4, SYS$PUTMSG 00000000G 00 04 FB 00052 BISL3 #268435456, 4(R2), -(SP) ;#268435456, MESSAGE+4, -(SP) 0219 04 A2 10000000 8F C9 00059 ; 7E 00061 CALLS #1, G^SYS$EXIT ;#1, SYS$EXIT 00000000G 00 01 FB 00062 RET ; 0220 04 00069 ; Routine Size: 106 bytes, Routine Base: _LIB_CODE + 010C ; 0221 1 %SBTTL'KERNEL_CANCEL - Cancel outstanding request' ; 0222 1 ROUTINE KERNEL_CANCEL : INTERNAL_CALL = ; 0223 1 !++ ; 0224 1 ! FUNCTIONAL DESCRIPTION: ; 0225 1 ! ; 0226 1 ! This routine executes in kernel mode, and dequeues any outstanding ; 0227 1 ! request on the lock block. We have to run in a higher mode than user ; 0228 1 ! because the locks are requested in supervisor mode. ; 0229 1 ! ; 0230 1 ! CALLING SEQUENCE: ; 0231 1 ! ; 0232 1 ! $CMKRNL (ROUTIN=KERNEL_CANCEL) ; 0233 1 ! ; 0234 1 ! FORMAL PARAMETERS: ; 0235 1 ! ; 0236 1 ! NONE. ; 0237 1 ! ; 0238 1 ! IMPLICIT INPUTS: ; 0239 1 ! ; 0240 1 ! LKSTAT is the lock block. ; 0241 1 ! ; 0242 1 ! IMPLICIT OUTPUTS: ; 0243 1 ! ; 0244 1 ! NONE. ; 0245 1 ! ; 0246 1 ! COMPLETION STATUS: ; 0247 1 ! ; 0248 1 ! SS$_NORMAL successful completion ; 0249 1 ! SS$_CANCELGRANT success; lock was granted before we could ; 0250 1 ! abort the request ; 0251 1 ! ; 0252 1 ! SIDE EFFECTS: ; 0253 1 ! ; 0254 1 ! Any outstanding lock requests are cancelled. ; 0255 1 ! ; 0256 1 !-- ; 0257 2 BEGIN ; P 0258 2 RETURN $DEQ( ; P 0259 2 LKID=.LKSTAT [LKSB_L_LOCKID], ; P 0260 2 ACMODE=PSL$C_SUPER, ; P 0261 2 FLAGS=LCK$M_CANCEL ; 0262 2 ); ; 0263 1 END; .EXTRN SYS$DEQ ;KERNEL_CANCEL U.2: .WORD ^M<> ;Save nothing 0222 0000 00000 PUSHL #2 ;#2 0262 02 DD 00002 PUSHL #2 ;#2 02 DD 00004 CLRL -(SP) ;-(SP) 7E D4 00006 PUSHL L^U.6+4 ;U.6+4 00000000' EF DD 00008 CALLS #4, G^SYS$DEQ ;#4, SYS$DEQ 00000000G 00 04 FB 0000E RET ; 0263 04 00015 ; Routine Size: 22 bytes, Routine Base: _LIB_CODE + 0176 ; 0264 1 %SBTTL'KERNEL_ENQ - Workhorse routine' ; 0265 1 ROUTINE KERNEL_ENQ : INTERNAL_CALL = ; 0266 1 !++ ; 0267 1 ! FUNCTIONAL DESCRIPTION: ; 0268 1 ! ; 0269 1 ! This routine is called by the main program once all the parameters ; 0270 1 ! have been determined. We don't have to run in kernel mode, but since ; 0271 1 ! that's the way we're protecting the logical name containing the ; 0272 1 ! lock block, it's just as well. ; 0273 1 ! ; 0274 1 ! We do an $ENQ rather than an $ENQW because we want to be able to tell ; 0275 1 ! the user we're waiting for his lock. ; 0276 1 ! ; 0277 1 ! CALLING SEQUENCE: ; 0278 1 ! ; 0279 1 ! $CMKRNL (ROUTIN=KERNEL_ENQ) ; 0280 1 ! ; 0281 1 ! FORMAL PARAMETERS: ; 0282 1 ! ; 0283 1 ! NONE. ; 0284 1 ! ; 0285 1 ! IMPLICIT INPUTS: ; 0286 1 ! ; 0287 1 ! OP control block contains flags. ; 0288 1 ! ; 0289 1 ! IMPLICIT OUTPUTS: ; 0290 1 ! ; 0291 1 ! NONE. ; 0292 1 ! ; 0293 1 ! COMPLETION STATUS: ; 0294 1 ! ; 0295 1 ! SS$_NORMAL successful completion ; 0296 1 ! other status from $DEQ or $ENQ ; 0297 1 ! ; 0298 1 ! SIDE EFFECTS: ; 0299 1 ! ; 0300 1 ! NONE. ; 0301 1 ! ; 0302 1 !-- ; 0303 2 BEGIN ; 0304 2 LOCAL ; 0305 2 ENQFLAGS : LONG INITIAL (0), ; 0306 2 STATUS : LONG; ; 0307 2 IF .OP [OP_V_WAIT] ; 0308 2 THEN ENQFLAGS = .ENQFLAGS OR LCK$M_SYNCSTS ; 0309 2 ELSE ENQFLAGS = .ENQFLAGS OR LCK$M_NOQUEUE; ; 0310 2 IF .OP [OP_V_SYSLOCK] THEN ENQFLAGS = .ENQFLAGS OR LCK$M_SYSTEM; ; 0311 2 IF .OP [OP_V_CONVERT] THEN ENQFLAGS = .ENQFLAGS OR LCK$M_CONVERT; ; 0312 2 IF .OP [OP_V_RELEASE] ; 0313 3 THEN STATUS = $DEQ (LKID=.LKSTAT [LKSB_L_LOCKID], ACMODE=PSL$C_SUPER) ; 0314 2 ELSE ; 0315 3 BEGIN ; P 0316 3 STATUS = $ENQ( ; P 0317 3 EFN=.OP [OP_L_EF], ; P 0318 3 LKMODE=.OP [OP_B_MODE], ; P 0319 3 LKSB=LKSTAT, ; P 0320 3 FLAGS = .ENQFLAGS, ; P 0321 3 RESNAM=DLNAME, ; P 0322 3 ACMODE=PSL$C_SUPER ; 0323 3 ); ; 0324 3 OP [OP_V_QUEUED] = 1; ; 0325 2 END; ; 0326 2 RETURN .STATUS; ; 0327 1 END; .EXTRN SYS$ENQ ;KERNEL_ENQ U.3: .WORD ^M ;Save R2,R3 0265 000C 00000 MOVAB L^U.5, R3 ;U.5, R3 53 00000000' EF 9E 00002 CLRL R2 ;ENQFLAGS 0303 52 D4 00009 BBC #4, (R3), 1$ ;#4, OP, 1$ 0307 63 04 E1 0000B ; 05 0000E BISB2 #8, R2 ;#8, ENQFLAGS 0308 52 08 88 0000F BRB 2$ ;2$ 03 11 00012 1$: BISB2 #4, R2 ;#4, ENQFLAGS 0309 52 04 88 00014 2$: BBC #2, (R3), 3$ ;#2, OP, 3$ 0310 63 02 E1 00017 ; 03 0001A BISB2 #16, R2 ;#16, ENQFLAGS 52 10 88 0001B 3$: BLBC (R3), 4$ ;OP, 4$ 0311 03 63 E9 0001E BISB2 #2, R2 ;#2, ENQFLAGS 52 02 88 00021 4$: BBC #3, (R3), 5$ ;#3, OP, 5$ 0312 63 03 E1 00024 ; 10 00027 MOVQ #2, -(SP) ;#2, -(SP) 0313 7E 02 7D 00028 CLRL -(SP) ;-(SP) 7E D4 0002B PUSHL 16(R3) ;LKSTAT+4 10 A3 DD 0002D CALLS #4, G^SYS$DEQ ;#4, SYS$DEQ 00000000G 00 04 FB 00030 RET ; 04 00037 5$: MOVQ #2, -(SP) ;#2, -(SP) 0323 7E 02 7D 00038 CLRQ -(SP) ;-(SP) 7E 7C 0003B CLRQ -(SP) ;-(SP) 7E 7C 0003D PUSHAB 56(R3) ;DLNAME 38 A3 9F 0003F PUSHL R2 ;ENQFLAGS 52 DD 00042 PUSHAB 12(R3) ;LKSTAT 0C A3 9F 00044 MOVZBL 4(R3), -(SP) ;OP+4, -(SP) 7E 04 A3 9A 00047 PUSHL 5(R3) ;OP+5 05 A3 DD 0004B CALLS #11, G^SYS$ENQ ;#11, SYS$ENQ 00000000G 00 0B FB 0004E BISB2 #2, (R3) ;#2, OP 0324 63 02 88 00055 RET ; 0327 04 00058 ; Routine Size: 89 bytes, Routine Base: _LIB_CODE + 018C ; 0328 1 %SBTTL'KERNEL_POST - Post process logical name' ; 0329 1 ROUTINE KERNEL_POST : INTERNAL_CALL = ; 0330 1 !++ ; 0331 1 ! FUNCTIONAL DESCRIPTION: ; 0332 1 ! ; 0333 1 ! This routine is called to either (re)set or remove the logical ; 0334 1 ! name containing the lock status block. ; 0335 1 ! ; 0336 1 ! CALLING SEQUENCE: ; 0337 1 ! ; 0338 1 ! $CMKRNL (ROUTIN=KERNEL_POST) ; 0339 1 ! ; 0340 1 ! FORMAL PARAMETERS: ; 0341 1 ! ; 0342 1 ! NONE. ; 0343 1 ! ; 0344 1 ! IMPLICIT INPUTS: ; 0345 1 ! ; 0346 1 ! OP control block, DLNAME descriptor of lock name. ; 0347 1 ! ; 0348 1 ! IMPLICIT OUTPUTS: ; 0349 1 ! ; 0350 1 ! NONE. ; 0351 1 ! ; 0352 1 ! COMPLETION STATUS: ; 0353 1 ! ; 0354 1 ! SS$_NORMAL successful completion ; 0355 1 ! ; 0356 1 ! SIDE EFFECTS: ; 0357 1 ! ; 0358 1 ! Logical name described by DLNAME changed or deleted. ; 0359 1 ! ; 0360 1 !-- ; 0361 2 BEGIN ; 0362 2 LOCAL ; 0363 2 LNMLST : BBLOCK [28] INITIAL (REP 28 OF BYTE (0)); ; 0364 2 IF .OP [OP_V_RELEASE] THEN ; P 0365 2 RETURN $DELLNM( ; P 0366 2 TABNAM=KD_LTABLE, ; P 0367 2 LOGNAM=DLNAME, ; P 0368 2 ACMODE=%REF(PSL$C_KERNEL) ; 0369 2 ); ; 0370 2 LNMLST [0,0,16,0] = LKSB_K_LENGTH; ; 0371 2 LNMLST [2,0,16,0] = LNM$_STRING; ; 0372 2 LNMLST [4,0,32,0] = LKSTAT; ; 0373 2 LNMLST [8,0,32,0] = LKSB_K_LENGTH; ; 0374 2 LNMLST [12,0,16,0] = .DMODE [DSC$W_LENGTH]; ; 0375 2 LNMLST [14,0,16,0] = LNM$_STRING; ; 0376 2 LNMLST [16,0,32,0] = .DMODE [DSC$A_POINTER]; ; P 0377 2 RETURN $CRELNM( ; P 0378 2 ATTR=%REF( ; P 0379 2 LNM$M_NO_ALIAS OR ; P 0380 2 LNM$M_CONFINE ; P 0381 2 ), ; P 0382 2 TABNAM=KD_LTABLE, ; P 0383 2 LOGNAM=DLNAME, ; P 0384 2 ACMODE=%REF(PSL$C_KERNEL), ; P 0385 2 ITMLST=LNMLST ; 0386 2 ); ; 0387 1 END; .BLKB 3 ; 001E5 P.ABC: .BYTE 0[28] ; 00# 001E8 .EXTRN SYS$DELLNM, SYS$CRELNM ;KERNEL_POST U.4: .WORD ^M ;Save R2,R3,R4,R5,R6,R7 0329 00FC 00000 MOVAB W^U.22, R7 ;U.22, R7 57 FE62 CF 9E 00002 MOVAB L^U.11, R6 ;U.11, R6 56 00000000' EF 9E 00007 SUBL2 #36, SP ;#36, SP 5E 24 C2 0000E MOVC3 #28, 380(R7), 8(SP) ;#28, P.ABC, LNMLST 0363 017C C7 1C 28 00011 ; 08 AE 00016 BBC #3, -56(R6), 1$ ;#3, OP, 1$ 0364 C8 A6 03 E1 00018 ; 12 0001C CLRL 4(SP) ;4(SP) 0369 04 AE D4 0001D PUSHAB 4(SP) ;4(SP) 04 AE 9F 00020 PUSHL R6 ;R6 56 DD 00023 PUSHL R7 ;R7 57 DD 00025 CALLS #3, G^SYS$DELLNM ;#3, SYS$DELLNM 00000000G 00 03 FB 00027 RET ; 04 0002E 1$: MOVL #131080, 8(SP) ;#131080, LNMLST 0370 08 AE 00020008 8F D0 0002F MOVAB -44(R6), 12(SP) ;LKSTAT, LNMLST+4 0372 0C AE D4 A6 9E 00037 MOVL #8, 16(SP) ;#8, LNMLST+8 0373 10 AE 08 D0 0003C MOVW 8(R6), 20(SP) ;DMODE, LNMLST+12 0374 14 AE 08 A6 B0 00040 MOVW #2, 22(SP) ;#2, LNMLST+14 0375 16 AE 02 B0 00045 MOVL 12(R6), 24(SP) ;DMODE+4, LNMLST+16 0376 18 AE 0C A6 D0 00049 PUSHAB 8(SP) ;LNMLST 0386 08 AE 9F 0004E CLRL 8(SP) ;8(SP) 08 AE D4 00051 PUSHAB 8(SP) ;8(SP) 08 AE 9F 00054 PUSHL R6 ;R6 56 DD 00057 PUSHL R7 ;R7 57 DD 00059 MOVL #3, 16(SP) ;#3, 16(SP) 10 AE 03 D0 0005B PUSHAB 16(SP) ;16(SP) 10 AE 9F 0005F CALLS #5, G^SYS$CRELNM ;#5, SYS$CRELNM 00000000G 00 05 FB 00062 RET ; 0387 04 00069 ; Routine Size: 106 bytes, Routine Base: _LIB_CODE + 0204 ; 0388 1 %SBTTL'LOCK - Main program' ; 0389 1 GLOBAL ROUTINE LOCK = ; 0390 1 !++ ; 0391 1 ! FUNCTIONAL DESCRIPTION: ; 0392 1 ! ; 0393 1 ! This is the main program. It interrogates the command line to find out ; 0394 1 ! what needs to be done, and calls routines appropriately. ; 0395 1 ! ; 0396 1 ! CALLING SEQUENCE: ; 0397 1 ! ; 0398 1 ! Called as main routine by DCL. ; 0399 1 ! ; 0400 1 ! FORMAL PARAMETERS: ; 0401 1 ! ; 0402 1 ! NONE. ; 0403 1 ! ; 0404 1 ! IMPLICIT INPUTS: ; 0405 1 ! ; 0406 1 ! Must be running under DCL command interpreter. ; 0407 1 ! ; 0408 1 ! IMPLICIT OUTPUTS: ; 0409 1 ! ; 0410 1 ! NONE. ; 0411 1 ! ; 0412 1 ! COMPLETION STATUS: ; 0413 1 ! ; 0414 1 ! LOCK_OBTAINED success; requested lock obtained ; 0415 1 ! LOCK_RELEASED success; lock relinquished ; 0416 1 ! LOCK_CONVERTED success; lock mode changed ; 0417 1 ! LOCK_NOWAIT failure; /NOWAIT was specified and lock was ; 0418 1 ! not immediately obtainable ; 0419 1 ! LOCK_CANCELLED failure; program was aborted (possibly by ^Y) ; 0420 1 ! before the lock was granted. Note that this ; 0421 1 ! is returned by EXIT_HANDLER, not the mainline ; 0422 1 ! code. ; 0423 1 ! ; 0424 1 ! SIDE EFFECTS: ; 0425 1 ! ; 0426 1 ! Lock at the appropriate mode either taken out or released on the ; 0427 1 ! specified resource, or no change. ; 0428 1 ! ; 0429 1 !-- ; 0430 2 BEGIN ; 0431 2 LOCAL ; 0432 2 LNMLST : BBLOCK [40] INITIAL (REP 40 OF BYTE (0)), ; 0433 2 LNMEQV : BBLOCK [255], ; 0434 2 LNMLEN : WORD, ; 0435 2 LNMOMODE : BBLOCK [255], ; 0436 2 LNMMLEN : WORD, ; 0437 2 STATUS : LONG; ; 0438 2 ENABLE LIB_CLI_SIG_TO_RET; ; 0439 2 ! ; 0440 2 ! Get the resource name, and build up the internal name from it. ; 0441 2 ! ; 0442 2 %CHECK ($DCLEXH (DESBLK=EBLOCK)); ; 0443 2 %CHECK (CLI$GET_VALUE (KD_P1, DRESOURCE)); ; 0444 2 %CHECK (LIB$SYS_FAO (KD_LNAME, 0, DLNAME, DRESOURCE)); ; 0445 2 ! ; 0446 2 ! See if this is an existing resource we already have locked. ; 0447 2 ! ; 0448 2 LNMLST [0,0,16,0] = 255; ; 0449 2 LNMLST [2,0,16,0] = LNM$_STRING; ; 0450 2 LNMLST [4,0,32,0] = LNMEQV; ; 0451 2 LNMLST [8,0,32,0] = LNMLEN; ; 0452 2 LNMLST [12,0,16,0] = 4; ; 0453 2 LNMLST [14,0,16,0] = LNM$_INDEX; ; 0454 2 LNMLST [16,0,32,0] = UPLIT (1); ; 0455 2 LNMLST [24,0,16,0] = 255; ; 0456 2 LNMLST [26,0,16,0] = LNM$_STRING; ; 0457 2 LNMLST [28,0,32,0] = LNMOMODE; ; 0458 2 LNMLST [32,0,32,0] = LNMMLEN; ; P 0459 2 STATUS = $TRNLNM( ; P 0460 2 TABNAM=KD_LTABLE, ; P 0461 2 LOGNAM=DLNAME, ; P 0462 2 ACMODE=%REF(PSL$C_KERNEL), ; P 0463 2 ITMLST=LNMLST ; 0464 2 ); ; 0465 2 IF .STATUS NEQ SS$_NOLOGNAM THEN ; 0466 3 BEGIN ; 0467 3 %CHECK (); ; 0468 3 ! ; 0469 3 ! If the length of the equivalence name is not equal to the size of a ; 0470 3 ! lock block, then we didn't define the name and we must abort. ; 0471 3 ! ; 0472 3 IF .LNMLEN NEQ LKSB_K_LENGTH THEN RETURN SS$_BUGCHECK; ; 0473 3 ! ; 0474 3 ! Copy the lock block from the logical name into real storage for future ; 0475 3 ! reference. ; 0476 3 ! ; 0477 3 CH$MOVE (LKSB_K_LENGTH, LNMEQV, LKSTAT); ; 0478 3 ! ; 0479 3 ! Store the name of the mode it is currently locked at; if this is NOT a ; 0480 3 ! release request, we will note the change in modes in the conversion ; 0481 3 ! message. ; 0482 3 ! ; 0483 3 %CHECK (LIB$SYS_FAO (KD_AF, 0, DOMODE, .LNMMLEN, LNMOMODE)); ; 0484 3 OP [OP_V_CONVERT] = 1; ; 0485 2 END; ; 0486 2 ! ; 0487 2 ! Get flags from the command qualifiers. Note that no assumptions are ; 0488 2 ! made in the program; what actions are default are determined SOLELY ; 0489 2 ! by the command definition. ; 0490 2 ! ; 0491 2 %CHECK (LIB$GET_EF (OP [OP_L_EF])); ; 0492 2 OP [OP_V_LOG] = CLI$PRESENT (KD_LOG); ; 0493 2 OP [OP_V_RELEASE] = CLI$PRESENT (KD_RELEASE); ; 0494 2 ! ; 0495 2 ! We have to tell him about his mistake if he tries to release what he ; 0496 2 ! doesn't have. ; 0497 2 ! ; 0498 2 IF .OP [OP_V_RELEASE] AND (NOT .OP [OP_V_CONVERT]) THEN ; 0499 3 BEGIN ; 0500 3 MESSAGE [0] = 3; ; 0501 3 MESSAGE [1] = LOCK_NOTLOCKED; ; 0502 3 MESSAGE [2] = 1; ; 0503 3 MESSAGE [3] = DRESOURCE; ; 0504 3 $PUTMSG (MSGVEC=MESSAGE); ; 0505 3 RETURN .MESSAGE [1] OR STS$M_INHIB_MSG; ; 0506 2 END; ; 0507 2 ! ; 0508 2 ! Special actions if he's trying to release an existing lock. ; 0509 2 ! ; 0510 2 IF NOT .OP [OP_V_RELEASE] THEN ; 0511 3 BEGIN ; 0512 3 OP [OP_V_WAIT] = CLI$PRESENT (KD_WAIT); ; 0513 3 %CHECK (CLI$GET_VALUE (KD_MODE, DMODE)); ; 0514 3 %CHECK (LIB$LOOKUP_KEY (DMODE, KR_MODES, STATUS, DMODE)); ; 0515 3 OP [OP_B_MODE] = .STATUS; ; 0516 3 %CHECK (CLI$GET_VALUE (KD_SCOPE, DSCR)); ; 0517 3 %CHECK (LIB$LOOKUP_KEY (DSCR, KR_SCOPES, STATUS, DSCR)); ; 0518 3 OP [OP_V_SYSLOCK] = .STATUS; ; 0519 2 END; ; 0520 2 ! ; 0521 2 ! Setup all done; change to kernel mode (to get locks at supervisor ; 0522 2 ! mode) and twiddle things appropriately. ; 0523 2 ! ; 0524 2 STATUS = $CMKRNL (ROUTIN=KERNEL_ENQ); ; 0525 2 ! ; 0526 2 ! Now handle the return status. ; 0527 2 ! ; 0528 2 ! ; 0529 2 ! We'll get the NOTQUEUED status only if he specified /NOWAIT; we have ; 0530 2 ! no other interest in anything at all, since we were obviously ; 0531 2 ! unsuccessful. ; 0532 2 ! ; 0533 2 IF .STATUS EQL SS$_NOTQUEUED THEN ; 0534 3 BEGIN ; 0535 3 MESSAGE [0] = 4; ; 0536 3 MESSAGE [1] = LOCK_NOWAIT; ; 0537 3 MESSAGE [2] = 2; ; 0538 3 MESSAGE [3] = 0; ; 0539 3 MESSAGE [4] = DRESOURCE; ; 0540 3 $PUTMSG (MSGVEC=MESSAGE); ; 0541 3 RETURN .MESSAGE [1] OR STS$M_INHIB_MSG; ; 0542 2 END; ; 0543 2 ! ; 0544 2 ! Now for the hard part. If there was an error doing a $DEQ, we WILL NOT ; 0545 2 ! do anything special about displaying it. ; 0546 2 ! ; 0547 2 IF .OP [OP_V_RELEASE] ; 0548 2 THEN ; 0549 3 BEGIN ; 0550 3 ! ; 0551 3 ! See if there was an error. On a release, we just return the ; 0552 3 ! error message. ; 0553 3 ! ; 0554 3 %CHECK (); ; 0555 3 MESSAGE [0] = 5; ; 0556 3 MESSAGE [1] = LOCK_RELEASED; ; 0557 3 MESSAGE [2] = 3; ; 0558 3 MESSAGE [3] = 0; ; 0559 3 MESSAGE [4] = DOMODE; ; 0560 3 MESSAGE [5] = DRESOURCE; ; 0561 3 END ; 0562 2 ELSE ; 0563 3 BEGIN ; 0564 3 IF (.STATUS EQL SS$_NORMAL) AND .OP [OP_V_WAIT] THEN ; 0565 4 BEGIN ; 0566 4 ! ; 0567 4 ! If he wanted to wait for his lock, and he wanted to know if we ; 0568 4 ! had to do so (/LOG present), then tell him what he wants to ; 0569 4 ! know. ; 0570 4 ! ; 0571 4 MESSAGE [0] = 4; ; 0572 4 MESSAGE [1] = LOCK_WAIT; ; 0573 4 MESSAGE [2] = 2; ; 0574 4 MESSAGE [3] = 0; ; 0575 4 MESSAGE [4] = DRESOURCE; ; 0576 4 IF .OP [OP_V_LOG] THEN $PUTMSG (MSGVEC=MESSAGE); ; 0577 4 ! ; 0578 4 ! No do like we said we were going to, and wait for his request. ; 0579 4 ! ; 0580 4 $SYNCH (EFN=.OP [OP_L_EF], IOSB=LKSTAT); ; 0581 3 END; ; 0582 3 ! ; 0583 3 ! When we get here, we have succeeded. We have either gotten the ; 0584 3 ! lock, converted it, or released it. Say the right things to ; 0585 3 ! the l'user. We basically just set up the message vector ; 0586 3 ! specific to each case. It will be displayed, if appropriate, ; 0587 3 ! at the end of this sequence. ; 0588 3 ! ; 0589 3 IF .OP [OP_V_CONVERT] ; 0590 3 THEN ; 0591 4 BEGIN ; 0592 4 MESSAGE [0] = 6; ; 0593 4 MESSAGE [1] = LOCK_CONVERTED; ; 0594 4 MESSAGE [2] = 4; ; 0595 4 MESSAGE [3] = 0; ; 0596 4 MESSAGE [4] = DOMODE; ; 0597 4 MESSAGE [5] = DRESOURCE; ; 0598 4 MESSAGE [6] = DMODE; ; 0599 4 END ; 0600 3 ELSE ; 0601 4 BEGIN ; 0602 4 MESSAGE [0] = 5; ; 0603 4 MESSAGE [1] = LOCK_OBTAINED; ; 0604 4 MESSAGE [2] = 3; ; 0605 4 MESSAGE [3] = 0; ; 0606 4 MESSAGE [4] = DMODE; ; 0607 4 MESSAGE [5] = DRESOURCE; ; 0608 3 END; ; 0609 2 END; ; 0610 2 IF .OP [OP_V_LOG] THEN $PUTMSG (MSGVEC=MESSAGE); ; 0611 2 %CHECK ($CMKRNL (ROUTIN=KERNEL_POST)); ; 0612 2 ! ; 0613 2 ! Turn off the QUEUED flag because we've completed everything. Otherwise, ; 0614 2 ! the exit handler will be given confusing instructions. We only want him ; 0615 2 ! to do things if we fell out before getting here. ; 0616 2 ! ; 0617 2 OP [OP_V_QUEUED] = 0; ; 0618 2 RETURN .MESSAGE [1] OR STS$M_INHIB_MSG; ; 0619 1 END; .BLKB 2 ; 0026E P.ABD: .BYTE 0[40] ; 00# 00270 P.ABE: .LONG 1 ; 00000001 00298 .EXTRN SYS$DCLEXH, SYS$TRNLNM, SYS$SYNCH .ENTRY LOCK, ^M ;R10,R11 MOVAB G^LIB$SYS_FAO, R11 ;LIB$SYS_FAO, R11 5B 00000000G 00 9E 00002 MOVAB G^SYS$PUTMSG, R10 ;SYS$PUTMSG, R10 5A 00000000G 00 9E 00009 MOVAB G^CLI$PRESENT, R9 ;CLI$PRESENT, R9 59 00000000G 00 9E 00010 MOVAB G^CLI$GET_VALUE, R8 ;CLI$GET_VALUE, R8 58 00000000G 00 9E 00017 MOVAB B^P.ABD, R7 ;P.ABD, R7 57 B3 AF 9E 0001E MOVAB L^U.5, R6 ;U.5, R6 56 00000000' EF 9E 00022 MOVAB -568(SP), SP ;-568(SP), SP 5E FDC8 CE 9E 00029 MOVAL 24$, (FP) ;24$, (FP) 0432 6D 0268 CF DE 0002E MOVC3 #40, (R7), -40(FP) ;#40, P.ABD, LNMLST 67 28 28 00033 ; D8 AD 00036 PUSHAB 24(R6) ;EBLOCK 0442 18 A6 9F 00038 CALLS #1, G^SYS$DCLEXH ;#1, SYS$DCLEXH 00000000G 00 01 FB 0003B BLBC R0, 1$ ;___STATUS, 1$ 7C 50 E9 00042 PUSHAB 48(R6) ;DRESOURCE 0443 30 A6 9F 00045 PUSHAB -620(R7) ;KD_P1 FD94 C7 9F 00048 CALLS #2, (R8) ;#2, CLI$GET_VALUE 68 02 FB 0004C BLBC R0, 1$ ;___STATUS, 1$ 6F 50 E9 0004F PUSHAB 48(R6) ;DRESOURCE 0444 30 A6 9F 00052 PUSHAB 56(R6) ;DLNAME 38 A6 9F 00055 CLRL -(SP) ;-(SP) 7E D4 00058 PUSHAB -536(R7) ;KD_LNAME FDE8 C7 9F 0005A CALLS #4, (R11) ;#4, LIB$SYS_FAO 6B 04 FB 0005E BLBC R0, 1$ ;___STATUS, 1$ 5D 50 E9 00061 MOVL #131327, -40(FP) ;#131327, LNMLST 0448 D8 AD 000200FF 8F D0 00064 MOVAB 272(SP), -36(FP) ;LNMEQV, LNMLST+4 0450 DC AD 0110 CE 9E 0006C MOVAB 4(SP), -32(FP) ;LNMLEN, LNMLST+8 0451 E0 AD 04 AE 9E 00072 MOVL #65540, -28(FP) ;#65540, LNMLST+12 0452 E4 AD 00010004 8F D0 00077 MOVAB 40(R7), -24(FP) ;P.ABE, LNMLST+16 0454 E8 AD 28 A7 9E 0007F MOVL #131327, -16(FP) ;#131327, LNMLST+24 0455 F0 AD 000200FF 8F D0 00084 MOVAB 16(SP), -12(FP) ;LNMOMODE, LNMLST+28 0457 F4 AD 10 AE 9E 0008C MOVAB 8(SP), -8(FP) ;LNMMLEN, LNMLST+32 0458 F8 AD 08 AE 9E 00091 PUSHAB -40(FP) ;LNMLST 0464 D8 AD 9F 00096 CLRL 4(SP) ;4(SP) 04 AE D4 00099 PUSHAB 4(SP) ;4(SP) 04 AE 9F 0009C PUSHAB 56(R6) ;DLNAME 38 A6 9F 0009F PUSHAB -516(R7) ;KD_LTABLE FDFC C7 9F 000A2 CLRL -(SP) ;-(SP) 7E D4 000A6 CALLS #5, G^SYS$TRNLNM ;#5, SYS$TRNLNM 00000000G 00 05 FB 000A8 MOVL R0, 12(SP) ;R0, STATUS 0C AE 50 D0 000AF CMPL 12(SP), #444 ;STATUS, #444 0465 000001BC 8F 0C AE D1 000B3 BEQL 3$ ;3$ 33 13 000BB MOVL 12(SP), R0 ;STATUS, ___STATUS 0467 50 0C AE D0 000BD 1$: BLBC R0, 4$ ;___STATUS, 4$ 36 50 E9 000C1 CMPW 4(SP), #8 ;LNMLEN, #8 0472 08 04 AE B1 000C4 BEQL 2$ ;2$ 06 13 000C8 MOVZWL #676, R0 ;#676, R0 50 02A4 8F 3C 000CA RET ; 04 000CF 2$: MOVC3 #8, 272(SP), 12(R6) ;#8, LNMEQV, LKSTAT 0477 0110 CE 08 28 000D0 ; 0C A6 000D5 PUSHAB 16(SP) ;LNMOMODE 0483 10 AE 9F 000D7 MOVZWL 12(SP), -(SP) ;LNMMLEN, -(SP) 7E 0C AE 3C 000DA PUSHAB 72(R6) ;DOMODE 48 A6 9F 000DE CLRL -(SP) ;-(SP) 7E D4 000E1 PUSHAB -504(R7) ;KD_AF FE08 C7 9F 000E3 CALLS #5, (R11) ;#5, LIB$SYS_FAO 6B 05 FB 000E7 BLBC R0, 7$ ;___STATUS, 7$ 78 50 E9 000EA BISB2 #1, (R6) ;#1, OP 0484 66 01 88 000ED 3$: PUSHAB 5(R6) ;OP+5 0491 05 A6 9F 000F0 CALLS #1, G^LIB$GET_EF ;#1, LIB$GET_EF 00000000G 00 01 FB 000F3 4$: BLBC R0, 8$ ;___STATUS, 8$ 7A 50 E9 000FA PUSHAB -552(R7) ;KD_LOG 0492 FDD8 C7 9F 000FD CALLS #1, (R9) ;#1, CLI$PRESENT 69 01 FB 00101 INSV R0, #5, #1, (R6) ;R0, #5, #1, OP 05 50 F0 00104 ; 66 01 00107 PUSHAB -576(R7) ;KD_RELEASE 0493 FDC0 C7 9F 00109 CALLS #1, (R9) ;#1, CLI$PRESENT 69 01 FB 0010D INSV R0, #3, #1, (R6) ;R0, #3, #1, OP 03 50 F0 00110 ; 66 01 00113 BBC #3, (R6), 6$ ;#3, OP, 6$ 0498 66 03 E1 00115 ; 1F 00118 BLBS (R6), 5$ ;OP, 5$ 18 66 E8 00119 MOVL #3, 80(R6) ;#3, MESSAGE 0500 50 A6 03 D0 0011C MOVL #LOCK_NOTLOCKED, 84(R6) ;#LOCK_NOTLOCKED, MESSAGE+4 0501 54 A6 00000000G 8F D0 00120 MOVL #1, 88(R6) ;#1, MESSAGE+8 0502 58 A6 01 D0 00128 MOVAB 48(R6), 92(R6) ;DRESOURCE, MESSAGE+12 0503 5C A6 30 A6 9E 0012C BRW 11$ ;11$ 0504 0093 31 00131 5$: BBS #3, (R6), 10$ ;#3, OP, 10$ 0510 66 03 E0 00134 ; 5F 00137 6$: PUSHAB -564(R7) ;KD_WAIT 0512 FDCC C7 9F 00138 CALLS #1, (R9) ;#1, CLI$PRESENT 69 01 FB 0013C INSV R0, #4, #1, (R6) ;R0, #4, #1, OP 04 50 F0 0013F ; 66 01 00142 PUSHAB 64(R6) ;DMODE 0513 40 A6 9F 00144 PUSHAB -592(R7) ;KD_MODE FDB0 C7 9F 00147 CALLS #2, (R8) ;#2, CLI$GET_VALUE 68 02 FB 0014B BLBC R0, 9$ ;___STATUS, 9$ 3D 50 E9 0014E PUSHAB 64(R6) ;DMODE 0514 40 A6 9F 00151 PUSHAB 16(SP) ;STATUS 10 AE 9F 00154 PUSHAB -444(R7) ;KR_MODES FE44 C7 9F 00157 PUSHAB 64(R6) ;DMODE 40 A6 9F 0015B CALLS #4, G^LIB$LOOKUP_KEY ;#4, LIB$LOOKUP_KEY 00000000G 00 04 FB 0015E 7$: BLBC R0, 13$ ;___STATUS, 13$ 74 50 E9 00165 MOVB 12(SP), 4(R6) ;STATUS, OP+4 0515 04 A6 0C AE 90 00168 PUSHAB 40(R6) ;DSCR 0516 28 A6 9F 0016D PUSHAB -604(R7) ;KD_SCOPE FDA4 C7 9F 00170 CALLS #2, (R8) ;#2, CLI$GET_VALUE 68 02 FB 00174 8$: BLBC R0, 13$ ;___STATUS, 13$ 62 50 E9 00177 PUSHAB 40(R6) ;DSCR 0517 28 A6 9F 0017A PUSHAB 16(SP) ;STATUS 10 AE 9F 0017D PUSHAB -376(R7) ;KR_SCOPES FE88 C7 9F 00180 PUSHAB 40(R6) ;DSCR 28 A6 9F 00184 CALLS #4, G^LIB$LOOKUP_KEY ;#4, LIB$LOOKUP_KEY 00000000G 00 04 FB 00187 9$: BLBC R0, 13$ ;___STATUS, 13$ 4B 50 E9 0018E INSV 12(SP), #2, #1, (R6) ;STATUS, #2, #1, OP 0518 02 0C AE F0 00191 ; 66 01 00195 10$: CLRL -(SP) ;-(SP) 0524 7E D4 00197 PUSHAB W^U.3 ;U.3 FD53 CF 9F 00199 CALLS #2, G^SYS$CMKRNL ;#2, SYS$CMKRNL 00000000G 00 02 FB 0019D MOVL R0, 12(SP) ;R0, STATUS 0C AE 50 D0 001A4 CMPL 12(SP), #2488 ;STATUS, #2488 0533 000009B8 8F 0C AE D1 001A8 BNEQ 12$ ;12$ 22 12 001B0 MOVL #4, 80(R6) ;#4, MESSAGE 0535 50 A6 04 D0 001B2 MOVL #LOCK_NOWAIT, 84(R6) ;#LOCK_NOWAIT, MESSAGE+4 0536 54 A6 00000000G 8F D0 001B6 MOVQ #2, 88(R6) ;#2, MESSAGE+8 0537 58 A6 02 7D 001BE MOVAB 48(R6), 96(R6) ;DRESOURCE, MESSAGE+16 0539 60 A6 30 A6 9E 001C2 11$: CLRQ -(SP) ;-(SP) 0540 7E 7C 001C7 CLRL -(SP) ;-(SP) 7E D4 001C9 PUSHAB 80(R6) ;MESSAGE 50 A6 9F 001CB CALLS #4, (R10) ;#4, SYS$PUTMSG 6A 04 FB 001CE BRW 22$ ;22$ 0541 00BC 31 001D1 12$: BBC #3, (R6), 15$ ;#3, OP, 15$ 0547 66 03 E1 001D4 ; 1F 001D7 MOVL 12(SP), R0 ;STATUS, ___STATUS 0554 50 0C AE D0 001D8 13$: BLBS R0, 14$ ;___STATUS, 14$ 01 50 E8 001DC RET ; 04 001DF 14$: MOVL #5, 80(R6) ;#5, MESSAGE 0555 50 A6 05 D0 001E0 MOVL #LOCK_RELEASED, 84(R6) ;#LOCK_RELEASED, MESSAGE+4 0556 54 A6 00000000G 8F D0 001E4 MOVQ #3, 88(R6) ;#3, MESSAGE+8 0557 58 A6 03 7D 001EC MOVAB 72(R6), 96(R6) ;DOMODE, MESSAGE+16 0559 60 A6 48 A6 9E 001F0 BRB 19$ ;19$ 0560 73 11 001F5 15$: CMPL 12(SP), #1 ;STATUS, #1 0564 01 0C AE D1 001F7 BNEQ 17$ ;17$ 34 12 001FB BBC #4, (R6), 17$ ;#4, OP, 17$ 66 04 E1 001FD ; 30 00200 MOVL #4, 80(R6) ;#4, MESSAGE 0571 50 A6 04 D0 00201 MOVL #LOCK_WAIT, 84(R6) ;#LOCK_WAIT, MESSAGE+4 0572 54 A6 00000000G 8F D0 00205 MOVQ #2, 88(R6) ;#2, MESSAGE+8 0573 58 A6 02 7D 0020D MOVAB 48(R6), 96(R6) ;DRESOURCE, MESSAGE+16 0575 60 A6 30 A6 9E 00211 BBC #5, (R6), 16$ ;#5, OP, 16$ 0576 66 05 E1 00216 ; 0A 00219 CLRQ -(SP) ;-(SP) 7E 7C 0021A CLRL -(SP) ;-(SP) 7E D4 0021C PUSHAB 80(R6) ;MESSAGE 50 A6 9F 0021E CALLS #4, (R10) ;#4, SYS$PUTMSG 6A 04 FB 00221 16$: PUSHAB 12(R6) ;LKSTAT 0580 0C A6 9F 00224 PUSHL 5(R6) ;OP+5 05 A6 DD 00227 CALLS #2, G^SYS$SYNCH ;#2, SYS$SYNCH 00000000G 00 02 FB 0022A 17$: BLBC (R6), 18$ ;OP, 18$ 0589 21 66 E9 00231 MOVL #6, 80(R6) ;#6, MESSAGE 0592 50 A6 06 D0 00234 MOVL #LOCK_CONVERTED, 84(R6) ;#LOCK_CONVERTED, MESSAGE+4 0593 54 A6 00000000G 8F D0 00238 MOVQ #4, 88(R6) ;#4, MESSAGE+8 0594 58 A6 04 7D 00240 MOVAB 72(R6), 96(R6) ;DOMODE, MESSAGE+16 0596 60 A6 48 A6 9E 00244 MOVAB 48(R6), 100(R6) ;DRESOURCE, MESSAGE+20 0597 64 A6 30 A6 9E 00249 MOVAB 64(R6), 104(R6) ;DMODE, MESSAGE+24 0598 68 A6 40 A6 9E 0024E BRB 20$ ;20$ 0589 1A 11 00253 18$: MOVL #5, 80(R6) ;#5, MESSAGE 0602 50 A6 05 D0 00255 MOVL #LOCK_OBTAINED, 84(R6) ;#LOCK_OBTAINED, MESSAGE+4 0603 54 A6 00000000G 8F D0 00259 MOVQ #3, 88(R6) ;#3, MESSAGE+8 0604 58 A6 03 7D 00261 MOVAB 64(R6), 96(R6) ;DMODE, MESSAGE+16 0606 60 A6 40 A6 9E 00265 19$: MOVAB 48(R6), 100(R6) ;DRESOURCE, MESSAGE+20 0607 64 A6 30 A6 9E 0026A 20$: BBC #5, (R6), 21$ ;#5, OP, 21$ 0610 66 05 E1 0026F ; 0A 00272 CLRQ -(SP) ;-(SP) 7E 7C 00273 CLRL -(SP) ;-(SP) 7E D4 00275 PUSHAB 80(R6) ;MESSAGE 50 A6 9F 00277 CALLS #4, (R10) ;#4, SYS$PUTMSG 6A 04 FB 0027A 21$: CLRL -(SP) ;-(SP) 0611 7E D4 0027D PUSHAB W^U.4 ;U.4 FCE5 CF 9F 0027F CALLS #2, G^SYS$CMKRNL ;#2, SYS$CMKRNL 00000000G 00 02 FB 00283 BLBC R0, 23$ ;___STATUS, 23$ 0C 50 E9 0028A BICB2 #2, (R6) ;#2, OP 0617 66 02 8A 0028D 22$: BISL3 #268435456, 84(R6), R0 ;#268435456, MESSAGE+4, R0 0618 54 A6 10000000 8F C9 00290 ; 50 00298 23$: RET ; 0619 04 00299 24$: .WORD ^M<> ;Save nothing 0432 0000 0029A CLRL -(SP) ;-(SP) 7E D4 0029C PUSHL SP ;SP 5E DD 0029E MOVQ 4(AP), -(SP) ;4(AP), -(SP) 7E 04 AC 7D 002A0 CALLS #3, G^LIB_CLI_SIG_TO_RET ;#3, LIB_CLI_SIG_TO_RET 00000000G 00 03 FB 002A4 RET ; 04 002AB ; Routine Size: 684 bytes, Routine Base: _LIB_CODE + 029C ; 0620 1 ; 0621 1 END ; 0622 0 ELUDOM ; PSECT SUMMARY ; ; Name Bytes Attributes ; ; _LIB_DATA 120 NOVEC, WRT, RD ,NOEXE,NOSHR, LCL, REL, CON, PIC,ALIGN(0) ; _LIB_CODE 1352 NOVEC,NOWRT, RD , EXE, SHR, LCL, REL, CON, PIC,ALIGN(0) Symbol Type Defined Referenced ... ------------------ -------- ----- ---------------- $$KEY_ENTRY Macro Lib02 158 162 $$KEY_INIT Macro Lib02 158 162 $CMKRNL KeyWMacr Lib01 201 524 611 $CRELNM KeyWMacr Lib01 377 $DCLEXH KeyWMacr Lib01 442 $DELLNM KeyWMacr Lib01 365 $DEQ KeyWMacr Lib01 258 313 $ENQ KeyWMacr Lib01 316 $EXIT KeyWMacr Lib01 219 $KEY_TABLE Macro Lib02 151 159 $PUTMSG KeyWMacr Lib01 218 504 540 576 610 $SYNCH KeyWMacr Lib01 580 $TRNLNM KeyWMacr Lib01 459 %CHECK Macro Lib02 201 442 443 444 467 483 491 513 514 516 517 554 611 BBLOCK Structur Lib02 124 126 363 432 433 435 CLI$GET_VALUE ExtRout 65 443c 513c 516c CLI$PRESENT ExtRout 66 492c 493c 512c DESCR KeyWMacr Lib02 134 135 136 137 138 DLNAME Own 136 136= 323a 369a 386a 444a 464a DMODE Own 137 137= 374. 376. 513a 514a 598a 606a DOMODE Own 138 138= 483a 559a 596a DRESOURCE Own 135 135= 217a 443a 444a 503a 539a 560a 575a 597a 607a DSC$A_POINTER Macro Lib01 134 135 136 137 138 376 DSC$B_CLASS Macro Lib01 134 135 136 137 138 DSC$B_DTYPE Macro Lib01 134 135 136 137 138 DSC$K_CLASS_A Unbound 134 135 136 137 138 DSC$K_CLASS_D Literal Lib01 134 135 136 137 138 DSC$K_CLASS_S Unbound 134 135 136 137 138 DSC$K_CLASS_Z Unbound 134 135 136 137 138 DSC$K_DTYPE_T Unbound 134 135 136 137 138 DSC$K_DTYPE_V Unbound 134 135 136 137 138 DSC$K_DTYPE_Z Literal Lib01 134 135 136 137 138 DSC$W_LENGTH Macro Lib01 134 135 136 137 138 374 DSCR Own 134 134= 516a 517a EBLOCK Own 128 130= 131= 132= 442a ENQFLAGS Local 305 305= 308= 308. 309= 309. 310= 310. 311= 311. 323. ESTATUS Own 127 132a EXIT_HANDLER Routine 164 55f 130a INTERNAL_CALL Macro Lib02 55 56 57 58 164 222 265 329 KD_AF Bind 150 483a KD_LNAME Bind 148 444a KD_LOG Bind 147 492a KD_LTABLE Bind 149 369a 386a 464a KD_MODE Bind 144 513a KD_P1 Bind 142 443a KD_RELEASE Bind 145 493a KD_SCOPE Bind 143 516a KD_WAIT Bind 146 512a KERNEL_CANCEL Routine 222 56f 201a KERNEL_ENQ Routine 265 57f 524a KERNEL_POST Routine 329 58f 208c 611a KR_MODES Bind 151 514a KR_SCOPES Bind 159 517a LCK$K_CRMODE Literal Lib01 158 LCK$K_CWMODE Literal Lib01 158 LCK$K_EXMODE Literal Lib01 158 LCK$K_NLMODE Literal Lib01 158 LCK$K_PRMODE Literal Lib01 158 LCK$K_PWMODE Literal Lib01 158 LCK$M_CANCEL Literal Lib01 262 LCK$M_CONVERT Literal Lib01 311 LCK$M_NOQUEUE Literal Lib01 309 LCK$M_SYNCSTS Literal Lib01 308 LCK$M_SYSTEM Literal Lib01 310 LIB$GET_EF ExtRout 67 491c LIB$LOOKUP_KEY ExtRout 68 514c 517c LIB$SYS_FAO ExtRout 69 444c 483c LIB_CLI_SIG_TO_RET ExtRout 70 438h LKSB_K_LENGTH Literal Lib02 126 370 373 472 477 LKSB_L_LOCKID Macro Lib02 259 313 LKSTAT Own 126 262. 313. 323a 372a 477= 580a LNM$M_CONFINE Literal Lib01 386 LNM$M_NO_ALIAS Literal Lib01 386 LNM$_INDEX Literal Lib01 453 LNM$_STRING Literal Lib01 371 375 449 456 LNMEQV Local 433 450a 477. LNMLEN Local 434 451a 472. LNMLST Local 363 363= 370= 371= 372= 373= 374= 375= 376= 386a Local 432 432= 448= 449= 450= 451= 452= 453= 454= 455= 456= 457= 458= 464a LNMMLEN Local 436 458a 483. LNMOMODE Local 435 457a 483a LOCK GlobRout 389 LOCK_CANCELLED ExtLit 77 214a LOCK_CONVERTED ExtLit 75 593a LOCK_NOTLOCKED ExtLit 78 501a LOCK_NOWAIT ExtLit 79 536a LOCK_OBTAINED ExtLit 73 603a LOCK_RELEASED ExtLit 74 556a LOCK_WAIT ExtLit 76 572a MDL_BIT Macro Lib02 99 MDL_CONSTANT Macro Lib02 110 MDL_END Macro Lib02 111 MDL_FIELD Macro Lib02 98 108 109 MDL_LENGTH Macro Lib02 110 MDL_STRUCT Macro Lib02 97 MDL__BIT Macro Lib02 107 MDL__CLEANUP Unbound 97 Macro 97 111u MDL__DEFINE Macro Lib02 110 MDL__ERASE_SAVED Unbound 97 111 Macro Lib02 111 MDL__MACRO Macro Lib02 98 107 108 109 MDL__NULL1 Unbound 97 Macro 97 111u MDL__NULL2 Unbound 97 Macro 97 107 110 111u MDL__NULLN Unbound 97 Macro 97 111u MDL__PARM1 Unbound 97 Macro 97 111u MDL__PARM2 Unbound 97 107 Macro 97 107 110 111u MDL__PARMN Unbound 97 Macro 97 111u MESSAGE Own 139 213= 214= 215= 216= 217= 218a 219. 500= 501= 502= 503= 504a 505. 535= 536= 537= 538= 539= 540a 541. 555= 556= 557= 558= 559= 560= 571= 572= 573= 574= 575= 576a 592= 593= 594= 595= 596= 597= 598= 602= 603= 604= 605= 606= 607= 610a 618. OP Unbound 97 Own 124 125= 200. 307. 310. 311. 312. 323. 324= 364. 484= 491a 492= 493= 498. 510. 512= 515= 518= 547. 564. 576. 580. 589. 610. 617= OP_B_MODE Macro 108 318 515 OP_C_LENGTH Literal 110 OP_K_LENGTH Literal 110 124 125 OP_L_EF Macro 109 317 491 580 OP_L_FLAGS Macro 98 OP_M_CONVERT Literal 107 OP_M_LOG Literal 107 OP_M_QUEUED Literal 107 OP_M_RELEASE Literal 107 OP_M_SYSLOCK Literal 107 OP_M_WAIT Literal 107 OP_V_CONVERT Macro 107 311 484 498 589 OP_V_LOG Macro 107 492 576 610 OP_V_QUEUED Macro 107 200 324 617 OP_V_RELEASE Macro 107 312 364 493 498 510 547 OP_V_SYSLOCK Macro 107 310 518 OP_V_WAIT Macro 107 307 512 564 P1 MacrForm 97 97 MacrForm 97 MacrForm 97 MacrForm 97 97 MacrForm 97 MacrForm 97 P2 MacrForm 97 MacrForm 97 97 MacrForm 97 MacrForm 97 MacrForm 97 97 MacrForm 97 PSL$C_KERNEL Literal Lib01 369 386 464 PSL$C_SUPER Literal Lib01 262 313 323 RTL_PSECTS KeyWMacr Lib02 117 SDL$STARLET_CONCAT Macro Lib01 201 218 219 262 313 323 369 386 442 464 504 524 540 576 580 610 611 SDL$STARLET_REQ Macro Lib01 201 218 323 386 442 464 504 524 540 576 610 611 SS$_BUGCHECK Literal Lib01 472 SS$_CANCELGRANT Literal Lib01 208 SS$_NOLOGNAM Literal Lib01 465 SS$_NORMAL Literal Lib01 200 564 SS$_NOTQUEUED Literal Lib01 533 STATUS Unbound 201 442 443 444 483 491 513 514 516 517 611 Local 199 201= 208. Local 306 313= 316= 326. Local 437 459= 465. 467. 514a 515. 517a 518. 524= 533. 554. 564. STRUCT_BIT Unbound 97 Comptime 97 107 111u STRUCT_BITWIDTH Unbound 97 107 Comptime 97 107 111u STRUCT_BYTE Unbound 97 Comptime 97 98 108 109 110 111u STRUCT_INCR_K Unbound 97 Comptime 97 111u STRUCT_K_ Unbound 97 Literal 97 111u STRUCT_K_A Unbound 97 Literal 97 111u STRUCT_K_B Unbound 97 Literal 97 108 111u STRUCT_K_G Unbound 97 Literal 97 111u STRUCT_K_L Unbound 97 Literal 97 98 109 111u STRUCT_K_Q Unbound 97 Literal 97 111u STRUCT_K_R Unbound 97 Literal 97 111u STRUCT_K_T Unbound 97 Literal 97 111u STRUCT_K_W Unbound 97 Literal 97 111u STRUCT_MASK Unbound 97 Comptime 97 111u STRUCT_NAME Unbound 97 98 108 109 111 Macro 97 98 107 108 109 110 111u STRUCT_NEXT_K Unbound 97 110 Comptime 97 111u STRUCT_PREFIX Unbound 97 Macro 97 111u STRUCT_SAVED Unbound 97 Comptime 97 111u STRUCT_SCRATCH Unbound 97 98 108 109 111 Comptime 97 107 111u STRUCT_SIZE_ Unbound 97 Literal 97 111u STRUCT_SIZE_A Unbound 97 Literal 97 111u STRUCT_SIZE_B Unbound 97 Literal 97 108 111u STRUCT_SIZE_G Unbound 97 Literal 97 111u STRUCT_SIZE_L Unbound 97 Literal 97 98 109 111u STRUCT_SIZE_Q Unbound 97 Literal 97 111u STRUCT_SIZE_R Unbound 97 Literal 97 111u STRUCT_SIZE_T Unbound 97 Literal 97 111u STRUCT_SIZE_W Unbound 97 Literal 97 111u STRUCT_SUBBYTE Unbound 97 Comptime 97 98 107 108 109 111u STS$M_INHIB_MSG Literal Lib01 219 505 541 618 SYS$CMKRNL ExtRout 201 201c 524e 524c 611e 611c SYS$CRELNM ExtRout 386 386c SYS$DCLEXH ExtRout 442 442c SYS$DELLNM ExtRout 369 369c SYS$DEQ ExtRout 262 262c 313e 313c SYS$ENQ ExtRout 323 323c SYS$EXIT ExtRout 219 219c SYS$PUTMSG ExtRout 218 218c 504e 504c 540e 540c 576e 576c 610e 610c SYS$SYNCH ExtRout 580 580c SYS$TRNLNM ExtRout 464 464c _CODE KeyWMacr Lib02 117 _DATA KeyWMacr Lib02 117 _LKSB Macro Lib02 126 ___STATUS Local 201 201= 201. Local 442 442= 442. Local 443 443= 443. Local 444 444= 444. Local 467 467= 467. Local 483 483= 483. Local 491 491= 491. Local 513 513= 513. Local 514 514= 514. Local 516 516= 516. Local 517 517= 517. Local 554 554= 554. Local 611 611= 611. CROSS REFERENCE MAP Line # Event File ... ----- --------------- --------- 1 Source (start) KEN_01:[COAR.SOURCE.BLISS]LOCK.B32;23 2 Module LOCK 47 Library #1 KEN_01:[COAR.VMS.SYSLIB]LIB.L32;1 48 Library #2 KEN_01:[COAR.VMS.SYSLIB]KENLIB.L32;101 622 Eludom LOCK KEY TO REFERENCE TYPE FLAGS . Fetch = Store c Routine call a Address use @ Indirect use e External, external routine, or external literal declaration f Forward or forward routine declaration h Condition handler enabling m Map declaration u Undeclare declaration ; Library Statistics ; ; -------- Symbols -------- Pages Processing ; File Total Loaded Percent Mapped Time ; ; KEN_01:[COAR.VMS.SYSLIB]LIB.L32;1 19280 41 0 1036 00:01.5 ; KEN_01:[COAR.VMS.SYSLIB]KENLIB.L32;101 ; 1010 23 2 78 00:00.8 ; COMMAND QUALIFIERS ; BLISS/DEBUG/TRACEBACK/CROSS_REFERENCE/TERMINAL=STATISTICS/LIST=LIS_/OBJECT=OBJ_/SOURCE_LIST=NOHEADER/MACHINE_CODE_LIST=(A ; SSEMBLER,UNIQUE_NAMES) LOCK ; COMPILER INTERNAL TIMING ; Phase Faults Cpu-time Elapsed-time ; LEXSYN 831 00:10.5 00:16.1 ; FLOWAN 19 00:00.9 00:01.2 ; DELAY 15 00:00.6 00:01.0 ; TNBIND 31 00:00.5 00:00.6 ; CODE 48 00:00.9 00:01.9 ; FINAL 188 00:04.7 00:06.6 ; Total 1132 00:18.1 00:27.4 ; Compilation Complete .END LOCK