.TITLE HELLO - MCR LOGON COMMAND .IDENT /01.22X/ ; ; COPYRIGHT (C) 1976, 1977 ; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. ; ; THIS SOFTWARE IS FURNISHED UNDER A LICENSE FOR USE ONLY ON A ; SINGLE COMPUTER SYSTEM AND MAY BE COPIED ONLY WITH THE ; INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE, OR ; ANY OTHER COPIES THEREOF, MAY NOT BE PROVIDED OR OTHERWISE ; MADE AVAILABLE TO ANY OTHER PERSON EXCEPT FOR USE ON SUCH ; SYSTEM AND TO ONE WHO AGREES TO THESE LICENSE TERMS. TITLE ; TO AND OWNERSHIP OF THE SOFTWARE SHALL AT ALL TIMES REMAIN ; IN DEC. ; ; THE INFORMATION IN THIS DOCUMENT IS SUBJECT TO CHANGE WITHOUT ; NOTICE AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL ; EQUIPMENT CORPORATION. ; ; DEC ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ; ITS SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DEC. ; ; ; VERSION: 01 ; BY: H. LEV ; DATE: 7/15/75 ; ; MODIFIED: ; ; EB033 23-MAR-77 TREAT A GROUP NUMBER OF 10 AS PRIVILEGED ; AND PREVENT THE ABORTING OF HEL BY A PARTIALLY ; LOGGED IN USER ; ; JGD MODIFIED HELP COMMAND TO ALLOW DISPLAYING OF ; JGD07 A TEXT FILE "NAME.TXT" WHEN THE COMMAND ; HELP $NAME IS GIVEN. ; ; JGD01 STORE TERMINAL NUMBER IN RSX11.SYS AT LOGON ; CHECK TO BE SURE NOT LOGGED ONTO OTHER TERMINAL, ; PUT PROTECTION WORD INTO TI:'S UCB(IN U.CW3 ; FOR NOW BUT EVENTUALLY IN U.PRV1=U.LUIC-2). ; THIS ALLOWS LOGIN TIME ACCOUNTING TO BE DONE ; AND ENABLES SELECTIVE PROTECTION FEATURES TO ; BE USED. ; ; JGD02 PRINT TEXT FILE NOLOG.TXT IF LOGONS DISABLED ; ; JGD03 IF BIT 2 IN THE TERMINAL PRIVLEGE MASK IS SET ; (IN U.PRV1), THEN RUN XXX AS HELLO EXITS. ; ALSO IF BIT 2 IS SET THE PRINTING OF LOGIN.TXT ; IS SUPRESSED. FINALLY, IF THE REQUESTED TASK ; CAN NOT BE RUN(ERROR RETURN), A WARNING MESSAGE ; IS PRINTED AND THE TERMINAL IS LOGGED OFF. ; ; JGD04 WARN THE USER THAT THE NUMBER OF DISK BLOCKS HE HAS IN USE ; EXCEEDS THE NUMBER OF BLOCKS ALLOCATED TO HIM. ; IF BIT 15 IN THE PRIVLEGE MASK IS SET THE TERMINAL ; AND USER IS LOGGED ON AS PRIVLEGED REGARDLESS OF ; THE TERMINAL UIC ; ; JGD05 IF BIT 3 IN THE TERMINAL PRIVLEGE MASK IS SET, LOG THE ; TERMINAL ON AS SLAVED. ; ; JGD06 CHANGE ALL REFERENCES TO U.CW3 TO U.PRV1=U.LUIC-2 SO THAT ; THE ACCOUNTING PACKAGE MAY BE USED WITH TERMINAL MULTIPLEXERS ; ; JGD08 MODIFICATIONS TO ALLOW USE OF VIRTUAL TERMINAL TO SIMULATE ; A BATCH PROCESS. ; 1) IF TERMINAL A VT DO NOT ENTER ACCOUNT FLAG ; 2) IF REQUEST FOR LOGON IS FROM A 'USER' ON VT0, ; THEN MULTIPLE LOGINS LEGAL ; ; JGD09 MODIFY HELP CODE SO THAT IF FIRST KEYWORD IS NOT ; FOUND, HELP.TXT IS CLOSED AND KEYWORD.TXT IS SEARCHED ; FOR THE REMAINING KEYWORDS. OPERATION IS IDENTICAL ; TO THE HELP $NAME KEYWORD PROCESSING EXCEPT THAT ; THE '$' IS NO LONGER REQUIRED. IF HELP.TXT IS ; A LONG FILE USING THE HELP $NAME WILL STILL PROVIDE ; A FASTER SEARCH. ; ; JGD10 MODIFY HELP CODE TO ALLOW FOR THE EXISTANCE OF ; SYNONYM KEYWORDS. A '$' IN PLACE OF THE LEVEL DIGIT ; IS TAKEN TO MEAN THAT THE LEVEL STAYS THE SAME ; AND THE KEYWORD IN THE FILE IS A SYNONYM FOR THE ; PREVIOUSLY FOUND KEYWORD/LEVEL IDENTIFIER. ; IN ADDITION THE MATCHALL LEVEL IDENTIFIER IS ADDED. ; IF A '#' IS IN COLUMN 1 OF THE HELP FILE, ALL KEYWORD PHRASES ; ARE RETURNED AS A MATCH. THIS FACILITATES USING THE LAST ; HELP RECORD IN A SPECIALIZED NAME.TXT FILE , AS AN INDEX TO ; REMIND THE USER AS TO WHAT KEYWORDS ARE AVAILABLE. ; ; JGD11 MCR HAS BEEN MODIFIED TO WORK WITH A /NOLI SWITCH ; WITH ...AT. THIS CHANGES SOMEWHAT WHEN MCR SHOOTS ; OUT A PROMPT. IN ORDER FOR BATCH TO WORK, HELLO ; MUST PROMPT ON EXIT. SO SET T3.MCR IN T.ST3 ON EXIT. ; BOY IS BATCH/VT: DUMB! ; ; JGD12 FIX 2 BUGS AT LOGCMD:. 1) CHANGE U.PRV1(R2) TO U.PRV1(R1). ; RUNCHK CLOBBERED R2., 2) AFTER MODIFYING MCRDIS TO REMOVE ; EXCESS MCRPROMPTING, NEED TO ADD A <15><12>/>/ FOR THE PRINTOUT ; OF @LOGCMD SO THAT IT WON'T OVERPRINT.. ; ; JGD13 FIX HELP %, SO THAT THIS SYNTAX ALSO WILL LOOK FOR HELP ; IN NAME.TXT IF THE HELP INFORMATION IS NOT IN HELP.TXT ; ; ; WB001 3-APR-77 EXECUTE USER'S LOGIN.TXT IF IT EXISTS ; EB040 23-APR-77 MAP LOWER-CASE TO UPPER-CASE WHEN NAME ; IS PROMPTED FOR ; HJL065 11-MAY-77 ALWAYS DISPLAY LAST MESSAGE IN LOGIN.TXT FILE ; NO MATTER IF CTRL/O WAS TYPED OR NOT ; EB051 21-MAY-77 LOOK FOR [1,2]HELP.TXT, [1,2]LOGIN.TXT AND ; [0,0]RSX11.SYS ON LB:. LOOK FOR [G,M]LOGIN.CMD ON SY:. ; EB056 29-MAY-77 ALLOW LOGIN.TXT LINES OF 132 CHARACTERS ; BLS010 7-JUN-77 ONLY FORCE FIRST PART OF LOGIN.TXT TO ; USER 1/DAY OR EACH TIME FILE CREATE DATE ; CHANGES. ALSO LOG LOGIN ON CO: UNLESS ; LOGGING IN ON CO:. DISABLE CHECKPOINTING ; WHILE DOING OUTPUT TO CO: AND TI: SO WE ; GET IT OUT QUICKER. ; BLS014 20-JUN-77 DISALLOW ALTMODE (33) IN PASSWORD ; BLS024 11-AUG-77 SET TERMINAL SLAVED AS SOON AS PASSWORD ; IS READ. UNSLAVE TERMINAL AT ERROR ; HANDLER. THIS PATCH SUPERCEDES PART ; OF PATCH EB033. ; EB077 22-AUG-77 ALLOW HELP TO HANDLE QUALIFIERS (DCLS STYLE) ; EB079 28-AUG-77 ALLOW ACCESSING OF SY:[CURRENT UIC]HELP.TXT ; EB100 14-NOV-77 ALLOW "-" AS A LEGAL CHARACTER FOR A NAME ; ; MRJ002 23-MAR-78 NOTIFY USER IF MAIL WAITING FOR HIM. MAIL UTILITY ; COURTISY OF MARK JOHNSON, ALBERTA HAIL PROJECT ; .MCALL QIO$,DIR$,GMCR$,WTSE$S,OPEN$U,CLOSE$,READ$ .MCALL EXIT$S,GTIM$S,MRKT$,GET$,OPEN$R,FINIT$ .MCALL GLUN$S,RQST$S,UCBDF$ ; JGD01 UCBDF$ ; JGD01 .IFNDF D$$H11&D$$J11&D$$M11&D$$ZMD&D$$Z11 ; JGD01 U.PRV1=U.CW3 ; FOR SYSTEMS WITH ONLY DL11'S ; JGD01 .IFF ; JGD01 U.PRV1=U.LUIC-2 ; FOR SYSTEMS WITH MULTIPLEXERS ; JGD01 .ENDC ; JGD01 ; ; CONSTANTS ; LUN1 = 1 ; TI LUN LUN2 = 2 ; ACCOUNT FILE LUN EFN1 = 1 ; EVENT FLAG FOR ALL I/O EFN2 = 2 ; EVENT FLAG FOR MARKTIME ; JGD03 ; ; ; LOCAL DATA ; .NLIST BEX TSK: .ASCII / / ; JGD03 TSK1: .BLKW 2 ; JGD03 BYE: .RAD50 /...BYE/ ; JGD03 ASSN: .ASCIZ %ASN XXNN:=SY:/LOGIN%<15> ACCT: .ASCIZ /ACCOUNT OR NAME: / PSWD: .ASCIZ /PASSWORD: / MS1: .ASCII <15><12>% RSX-11M BL% MS1A: .ASCIZ % MULTI-USER SYSTEM%<12> MS2: .BLKB 16. .ASCII /LOGGED ON TERMINAL / MS2A: .ASCIZ /XXXX:/ MS3: .ASCIZ /GOOD MORNING/ MS4: .ASCIZ /GOOD AFTERNOON/ MS5: .ASCIZ /GOOD EVENING/ MS6: .ASCIZ /GOOD NIGHT, WHAT ARE YOU DOING UP AT THIS HOUR?/ MS7: .ASCIZ <15><12>/HEL -- LOGGED ONTO OTHER TERMINAL ALSO?/<15><12><7> ; JGD01 MS8: .ASCII <15><12>/>> YOU ARE USING MORE THAN YOUR ALLOCATED DISK SPACE/ ; JGD04 .ASCII <15><12>/>> PLEASE CLEAN UP YOUR UIC OR REQUEST MORE STORAGE SPACE/; JGD04 .ASCIZ <15><12><7> LGNMSG: .ASCIZ /LOGIN USER / ;BLS010 MAIMSG: .ASCII <15><12><7>/>>>>YOU HAVE MAIL<<<<12><7><0> ;MRJ002 ; ; ERROR MESSAGES ; ER1: .ASCIZ <15>/HEL -- SYNTAX ERROR/ ER2: .ASCIZ <15>/HEL -- INVALID ACCOUNT/ ER3: .ASCIZ <15>/HEL -- TERMINAL ALLOCATED TO OTHER USER/ ER4: .ASCIZ <15>/HEL -- COMMAND INPUT ERROR/ ER5: .ASCIZ <15>/HEL -- OTHER USER LOGGED ON/ ER6: .ASCIZ <15>/HEL -- ACCOUNT FILE OPEN FAILURE/ ER7: .ASCIZ <15>/HEL -- LOGINS ARE DISABLED/ ER8: .ASCII <15>/HEL -- MESSAGE FILE ERROR / ER8NUM: .ASCIZ /-NNNNN/ ER9: .ASCIZ <15>/HEL -- AMBIGUOUS QUALIFIER/ ; EB077 ER10: .ASCIZ <15>/HEL -- IMPROPER HELP FILE FORMAT/ ; EB077 ER11: .ASCIZ <15>/HEL -- UNKNOWN QUALIFIER/ ; EB077 ER12: .ASCIZ <15>/HEL -- MULTIPLE LOGINS ILLEGAL/ ; JGD01 ER13: .ASCIZ <15>/HEL -- REQUESTED TASK NOT FOUND -- LOGGING OFF/ ; JGD03 .LIST BEX .EVEN PSWDBF: .WORD 0 ; ADDRESS OF PASSWORD BUFFER GRP: .WORD 0 ; GROUP CODE MEM: .WORD 0 ; MEMBER CODE .BLKB 4 ; UIC: .ASCII /000000/ ; UIC NAME: .BLKB 14. ; LAST NAME AREA IF NAME SPECIFIED VS ACCOUNT .EVEN ODPB: QIO$ IO.WVB,LUN1,EFN1,,,, ; OUTPUT DPB IDPB: QIO$ IO.RVB,LUN1,EFN1,,IOSB,, ; INPUT DPB FDPB: QIO$ IO.RVB,LUN2,EFN1,,IOSB,,<$ACTBF,$BFLEN,,,1> RATDPB: QIO$ IO.RAT,LUN2,EFN1,,IOSB,,<$ACTFL+F.FNB,RWATPT> ;BLS010 IOSB: .BLKW 2 ; I/O STATUS BLOCK ; ;MRJ002 ; MAIL FILE DESCRIPTOR ;MRJ002 ; ;MRJ002 MAIDSP: .WORD 4 ;MRJ002 .WORD MAIDEV ;MRJ002 .WORD 6 ;MRJ002 .WORD MAIDIR ;MRJ002 .WORD 10. ;MRJ002 .WORD MAIFIL ;MRJ002 MAIDEV: .ASCII /LB1:/ ;MRJ002 MAIDIR: .ASCII /[10,3]/ ;MRJ002 MAIFIL: .ASCII /000000.TXT/ ;MRJ002 ; ; LOGIN MESSAGE FILE DESCRIPTOR ; MSGDSP: .WORD 4 ; .WORD DEVNAM ; .WORD 5 ; .WORD DIRNAM ; .WORD 9. ; .WORD FILNAM ; NLGDSP: .WORD 4. ; ; JGD02 .WORD DEVNAM ; ; JGD02 .WORD 5. ; ; JGD02 .WORD DIRNAM ; ; JGD02 .WORD 9. ; ; JGD02 .WORD NLGNAM ; ; JGD02 HLPDSP: .WORD 4. ; .WORD DEVNAM ; .WORD 5. ; .WORD DIRNAM ; .WORD 8. ; .WORD HELP ; HLPFIL: .WORD 4 ; JGD07 .WORD DEVNAM ; JGD07 .WORD 5 ; JGD07 .WORD DIRNAM ; JGD07 CHRNUM: .WORD 13. ; JGD07 .WORD HLPNAM ; JGD07 ; WB001 LOGDSP: .WORD 4 ; ; WB001 .WORD LOGNAM ; ; EB051 .WORD 9. ; ; WB001 .WORD LOGINU ; ; WB001 .WORD 9. ; ; WB001 .WORD LOGINN ; ; WB001 ; WB001 .NLIST BEX ; WB001 HLPNAM: .ASCII / / ; JGD07 LOGNAM: .ASCII /SY0:/ ; DEVICE FOR [G,M]LOGIN.CMD ; EB051 DEVNAM: .ASCII /LB1:/ ; DEVICE FOR [1,2]HELP.TXT AND LOGIN.TXT ; EB051 DIRNAM: .ASCII /[1,2]/ ;**-1 FILNAM: .ASCII /LOGIN.TXT/ ; HELP: .ASCII /HELP.TXT/ ; LOG: .ASCII <15><12>/>/ ; JGD12 LOGINC: .ASCIZ /@LOGIN.CMD/<15> ; ; WB001 NLGNAM: .ASCII /NOLOG.TXT/ ; JGD02 LOGINN=LOGINC+1 ; WB001 LOGINU: .ASCII /[000,000]/ ; USER LOGIN.CMD UFD TEMPLATE ; WB001 MONTH: .ASCII /JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC/ .LIST BEX ; WB001 .EVEN FILOPN: .WORD 0 ; FILE OPEN FLAG 0-NO, 1-YES ENTRY: .WORD 0 ; ADDRESS OF ACCOUNT ENTRY OPNERR: .WORD 0 ; ACCOUNT FILE OPEN ERROR FLAG NAMFLG: .WORD 0 ; NAME FLAG 0-ACCOUNT, 1-NAME TXTFLG: .WORD 0 ; PRINT LOGIN.TXT FLAG 0=YES, 1=NO BLKFLG: .WORD 0 ; DISPLAY TOO MANY DISK BLOCKS IN USE MSG IF SET ; JGD04 INDEX: .WORD 0 ; TEMP STORAGE ; JGD BYEFLG: .WORD 0 ; IF =1, LOG OFF AND EXIT. USED ONLY IF A ; JGD03 ; TASK REQUESTED TO RUN CAN NOT BE FOUND ; JGD03 VTFLG: .WORD 0 ; IF TERMNAL 'VT', DON' T PRINT OUT LOGIN HEADER; JGD08 PASFLG: .WORD 0 ; IF =0, ON FIRST PASS TROUGH HELP PROCESSOR ; JGD09 ; IF CAN'T FIND KEYWORD, TRY OPENING FILE ; JGD09 ; NAME.TXT FOR A SECOND PASS. IF GT 1, SECOND ; JGD09 ; PASS DONE, SO EXIT IF CAN'T FIND KEYWORD ; JGD09 SYNFLG: .WORD 0 ; IF =0, NOT A SYNONYM, IF >0 A SYNONYM ; JGD10 MTCHAL: .WORD 0 ; IF =1, MATCHES ALL KEYWORDS,ALL LEVELS ; JGD10 TIMBUF: .BLKW 8. ; TIME BUFFER FRCFLG: .WORD 0 ; FORCE LOGIN.TXT MESSAGE FLAG ;HJL065 ; FRCFLG = 0 TO FORCE FIRST MESSAGE ;BLS010 ; FRCFLG <> 0 TO NOT FORCE FIRST MESSAGE ;BLS010 ; FRCFLG (BIT15=1) TO CHECK IF USER ;BLS010 ; DESERVES TO SEE MESSAGE. THEN ;BLS010 ; ZERO CHECK APPLIES. ;BLS010 GLNBUF: .BLKW 6. ; BUFFER FOR GET LUN DIRECTIVE ; JGD001 GMCR: GMCR$ BUF = GMCR+2 ; BUFFER FOR TI I/O .BLKB 132.-80.+2 ; EXPAND BUFFER FOR 132. CHARACTER LINES ; EB056 HLPBUF: .BLKB 132. ; HOLDS ONE RECORD OF THE HELP FILE ; EB077 MKT: MRKT$ EFN2,100.,1 ; WAIT FOR ONE HUNDRED TICS ; EB033 ; SLP PATCH MADE NO PROVISION FOR CLOCKS ; JGD03 ; WITH OTHER THAN 60 TICS/SEC ; JGD03 RWATPT: .BYTE -13.,35. ; ARGUMENT BLOCK TO READ CREATE DATE ;BLS010 .WORD RATBUF ; PTR TO BUFFER ;BLS010 .WORD 0 ; END OF ARG BLOCK ;BLS010 TDATBF: ;BLS010 MARKSV: ; STORAGE FOR SAVING .POINT REGISTERS ; EB077 ; (OVERLAPS RATBUF) ; EB077 DEPTH=6*2+MARKSV ; ONE MORE OVERLAPPED WORD FOR HELPP ; EB077 RATBUF: .BLKB 35. ; 35 BYTES OF CREATE/UPDATE DATE/TIMES ;BLS010 SAVLGT: .BLKB 3 ; SAVE LAST LOGIN TIME ;BLS010 .EVEN ;BLS010 FIRSTF: .WORD 0 ; 0 IF NOT FIRST TIME LOGGED IN TODAY ;BLS010 ; NON-0 IF FIRST TIME ;BLS010 .SBTTL MAIN LINE CODE ;+ ; $HELEP - HELLO AND HELP COMMAND PROCESSOR ; ; FORMAT OF COMMAND ; ; HELLO [GRP,MEM] ; HELLO [GRP/MEM] - DISPLAY THE LOGIN.TXT FILE UNTIL A % IS FOUND ;HJL065 ; IN COLUMN 1, THEN DO NOT DISPLAY THE REMAINDER ;HJL065 ; OF THE FILE ;HJL065 ; HELLO GRP,MEM ;**-1 ; HELLO GRP/MEM - DISPLAY THE LOGIN.TXT FILE UNTIL A % IS FOUND ;HJL065 ; IN COLUMN 1, THEN DO NOT DISPLAY THE REMAINDER ;HJL065 ; OF THE FILE ;HJL065 ; HELLO [GRP,MEM]/PASSWORD ;**-1 ; HELLO NAME ; HELLO NAME/PASSWORD ; ; HELP - DISPLAY FIRST SECTION OF LB1:[1,2]HELP.TXT ; EB077 ; HELP KEY1 KEY2 ... KEY9 - DISPLAY A SECTION OF LB1:[1,2]HELP.TXT ; EB077 ; (SEE COMMENT BEFORE HELPP) ; EB077 ; HELP % - DISPLAY FIRST SECTION OF SY:[CURRENT UIC]HELP.TXT ; EB079 ; HELP % KEY1 KEY2 ... KEY9 - DISPLAY A SECTION OF ; EB079 ; SY:[CURRENT UIC]HELP.TXT (SEE COMMENT BEFORE HELPP) ; EB079 ; HELP $NAME - DISPLAY FILE NAME.TXT ON [1,2] OF USER'S SY: ; JGD07 ; ;**-1 ; WHERE: ; [GRP,MEM] IS UIC TYPE OF ACCOUNT ; PASSWORD IS OPTIONAL PASSWORD, IF NOT SPECIFIED, ; TASK WILL PROMPT FOR IT ; NAME - USER NAME ;- ; ; GET COMMAND LINE ; $HELEP: DIR$ #GMCR ; GET MCR COMMAND LINE BCC 3$ ;IF CC, OK CALL ERR4 ; ERROR, NONE THERE JMP EXIT ; ; ; ATTACH TO TI: ; 3$: MOV #ODPB,R4 ; GET OUTPUT DPB ADDRESS MOV #IO.ATT,2(R4) ; ATTACH CALL QIO ; TO TI: MOV #IO.WVB,2(R4) ; RESET FUNCTION CODE ; ;**-4 ; IF COMMAND IS HELP PRINT HELP FILE ; 4$: MOV $TKTCB,R1 ; GET OUR TCB ADDRESS ; EB079 MOV T.UCB(R1),R1 ; GET TI: UCB ADDRESS ; EB079 MOV #BUF+3,R0 ; POINT AT FOURTH CHAR OF COMMAND ; EB079 CMPB #'P,(R0)+ ; IS THIS THE HELP COMMAND? ; EB079 BNE 5$ ; NO ;**-1 MOV R0,R4 ; POINT AT FIFTH CHAR OF COMMAND ; EB079 MOV #HLPDSP,-(SP) ; ASSUME ACCESS TO LB:[1,2]HELP.TXT ; EB079 BIT #U2.LOG,U.CW2(R1) ; IS THE USER ALREADY LOGGED IN? ; EB079 BNE 4020$ ; NO, MUST ACCESS LB:[1,2]HELP.TXT ; EB079 CMPB #40,(R0)+ ; CAN COMMAND BE HELP %? ; EB079 BNE 4020$ ; NO ; EB079 CMPB #'$,(R0) ; MAYBE A $? ; JGD07 BEQ 4050$ ; YES, PROCESS THIS SPECIAL HELP COMMAND ; JGD07 ; CMPB #'%,(R0)+ ; ; EB079 CMPB #'%,(R0) ; IS FIRST INPUT A % ; JGD10 BNE 4020$ ; NO ; EB079 MOVB #40,(R0) ; YES, SO MAKE THE %, A SPACE ; JGD10 MOV R0,R4 ; POINT PAST % IN COMMAND ; EB079 MOV #LOGDSP,(SP) ; ACCESS SY:[CURRENT UIC]HELP.TXT ; EB079 MOV #10,LOGDSP+10 ; SAY HELP.TXT IS 8 CHARS LONG ; EB079 MOV #HELP,LOGDSP+12 ; FILE NAME IS HELP.TXT, NOT LOGIN.TXT ; EB079 MOV R1,R5 ; SAVE POINTER TO TI: UCB ; EB079 MOV #LOGINU+1,R0 ; POINT AT UIC STRING ; EB079 MOVB U.UIC+1(R5),R1 ; GET CURRENT GROUP NUMBER ; EB079 CALL UICCON ; CONVERT GROUP NUMBER TO ASCII ; EB079 INC R0 ; SKIP PAST COMMA ; EB079 MOVB U.UIC(R5),R1 ; GET CURRENT MEMBER NUMBER ; EB079 CALL UICCON ; CONVERT MEMBER NUMBER TO ASCII ; EB079 MOV #LOGNAM,HLPFIL+2 ; SET UP FOR USE IF KEYWORD NOT IN HELP.TXT ; JGD13 MOV #9.,HLPFIL+4 ; SET UP CHAR. CNT FOR UIC STRING ; JGD13 MOV #LOGINU,HLPFIL+6 ; SET UP LOGIN UIC STRING ; JGD13 4020$: MOV (SP)+,R1 ; GET FILE DESCRIPTOR BLOCK ; EB079 MOV #1,FRCFLG ; DISABLE FORCE OF FIRST MESSAGE ;HJL065 CALL HELPP ; DISPLAY THE DESIRED PART OF HELP FILE ; EB077 4030$: JMP EXIT ; ; EB077 4050$: TSTB (R0)+ ; BUMP TO FIRST CHARACTER OF FILE NAME ; JGD07 MOV #HLPNAM,R3 ; GET ADRESS OF PLACE TO PUT NAME ; JGD07 CLR CHRNUM ; ASSUME ZERO LENGTH TO START WITH ; JGD07 4060$: MOV R0,R4 ; SAVE LOCATION IN BUFFER IN CASE OF ; JGD07 CMPB (R0),#15 ; IS IT A RETURN? ; JGD07 BEQ 4080$ ; YES, GO DISPLAY HELP FILE ; JGD07 CMPB (R0),#40 ; IS IT A SPACE ; JGD07 BEQ 4080$ ; YES, GO DISPLAY HELP FILE ; JGD07 MOVB (R0)+,(R3)+ ; NO, MOVE IN FILE NAME(UP TO 9 CHARACTERS) ; JGD07 INC CHRNUM ; AND INCREMENT CHARACTER COUNT ; JGD07 CMP #9.,CHRNUM ; ARE WE AT 9 CHARACTERS YET? ; JGD07 BNE 4060$ ; NO, WE DON'T HAVE FILE NAME ; JGD07 ; SO BRANCH BACK AND LOOK FOR EOL, SP, OR CHAR. ; JGD07 ; ; JGD07 ; YES, WE HAVE FILE NAME ; JGD07 ; HOWEVER, >9 CHAR. FILENAMES TRUNCATED AND ; JGD07 ; KEYWORDS AFTER >9 CHAR FILE NAME WILL FAIL ; JGD07 4070$: MOV R0,R4 ; SAVE POINTER IN BUFFER AFTER FILE NAME ; JGD07 4080$: MOVB #'.,(R3)+ ; MOVE IN "." ; JGD07 MOVB #'T,(R3)+ ; MOVE IN "T" ; JGD07 MOVB #'X,(R3)+ ; MOVE IN "X" ; JGD07 MOVB #'T,(R3) ; MOVE IN "T" ; JGD07 ADD #4.,CHRNUM ; UPDATE THE CHARACTER COUNT IN THE FILE STRING ; JGD07 MOV #HLPFIL,R1 ; POINT TO FILE DESCRIPTOR BLOCK ; JGD07 MOV #1,FRCFLG ; FORCE FILE TO BE PRINTED ; JGD07 CALL HELPP ; CALL HELP PROCESSOR ; JGD07 JMP EXIT ; AND EXIT ; JGD07 ; ;**-3 ; CHECK IF OKAY TO LOGIN USER ; 5$: BIT #FE.MUP,$FMASK ; MULTIUSER PROTECTION SUPPORTED? ; EB077 BEQ 4030$ ; NO, JUST EXIT ; EB077 MOV #44,Q.IOPL+4(R4) ; SET TO PROMPT ; EB077 MOV $TKTCB,R0 ; GET OUR TCB ADDRESS ; EB077 BIT #U2.LOG,U.CW2(R1) ; IS A USER ALREADY LOGGED ON? ;**-2 BNE 7$ ; NO CALL ERR5 ; YES, ERROR JMP EXIT ; 7$: CLR FILOPN ; SET FILE NOT OPEN CLR ENTRY ; ZERO ENTRY CLR TXTFLG ; SET TO PRINT LOGIN.TXT BIT #FE.NLG,$FMASK ; ARE LOGINS DISABLED? BEQ 701$ ; NO MOV #ER7,R0 ; GET SET TO PRINT WARNING MESSAGE ; JGD02 MOV #40,ODPB+Q.IOPL+4 ; SET NORMAL CARRIAGE RETURN ; JGD02 CALL WRIT ; WRITE OUT THE LOGON DISABLED MESSAGE ; JGD02 MOV #NLGDSP,R1 ; GET READY TO PRINT NOLOG.TXT ; JGD02 CALL DSPFIL ; PRINT IT ; JGD02 MOV #ODPB,R4 ; GET OUTPUT DPB ADRESS ; JGD02 MOV #IO.DET,2(R4) ; SET FUNCTION TO DETACH ; JGD02 CALL QIO ; DETACH TERMINAL ; JGD02 JMP ERROR1 ; AND EXIT ; JGD02 ; JMP ERR7 ; YES 701$: TST U.OWN(R1) ; IS TERMINAL ALLOCATED? BEQ 8$ ; NO JMP ERR3 ; YES, ERROR 8$: MOV #BUF,R0 ; GET BUFFER ADDRESS ; ; GET ACCOUNT ; 10$: CALL $GNBLK ; GET NEXT NON-BLANK BCS 20$ ; EOL TST R1 ; ANY BLANKS SEEN? BEQ 10$ ; NO, CONTINUE SCAN BR 30$ ; YES, GET ACCOUNT NUMBER 20$: MOV #ACCT,R0 ; MUST PROMPT FOR ACCOUNT NUMBER CALL WRIT ; PROMPT FOR ACCOUNT MOV #BUF,R0 ; POINT TO INPUT BUFFER MOV #20.,R1 ; SET COUNT OF CHARACTERS CALL READ ; READ IN ACCOUNT NUMBER BR 40$ ; 30$: DEC R0 ; BACK UP BUFFER POINTER TO FIRST DIGIT 40$: CALL ACCNT ; GET ACCOUNT NUMBER BCC 41$ ; OKAY JMP ERR1 ; NO, SYNTAX ERROR ; ; GET PASSWORD ; 41$: CMPB -1(R0),#'/ ; PASSWORD COMMING? BNE 42$ ; NO, SYNTAX ERROR MOV R0,PSWDBF ; SAVE PASSWORD ADDRESS BR 46$ ; 42$: MOV #PSWD,R0 ; SET TO PROMPT FOR PASSWORD CALL WRIT ; WRITE OUT PROMPT MOV #BUF,R0 ; GET INPUT BUFFER ADDRESS MOV #6.,R1 ; SET COUNT OF BYTES TO ZERO MOV R0,R2 ; COPY ADDRESS 45$: CLRB (R2)+ ; ZERO IT OUT DEC R1 ; DONE ? BGT 45$ ; NO, LOOP MOV #BUF,R0 ; POINT TO BUFFER MOV #7.,R1 ; SET COUNT OF CHARACTERS CALL READAL ; READ PASSWORD BCC 451$ ; OKAY JMP ERR1 ; SYNTAX ERROR 451$: MOV #BUF,PSWDBF ; SAVE PASSWORD BUFFER ADDRESS ; ; OPEN ACCOUNT FILE ; 46$: CALL $SWSTK,461$ ; SWITCH TO SYSTEM STATE ;BLS024 MOV $TKTCB,R1 ; GET MY TCB ADDRESS ;BLS024 MOV T.UCB(R1),R1 ; GET TERMINAL UCB ADDRESS ;BLS024 BIS #U2.SLV,U.CW2(R1) ; SET TERMINAL AS SLAVED ;BLS024 RETURN ; RETURN TO USER STATE ;BLS024 461$: ; REF LABEL ;BLS024 CLR OPNERR ; SET NO OPEN ERROR 47$: CALL OPEN ; OPEN ACCOUNT FILE BCC 48$ ; OPEN SUCCESSFUL CMP OPNERR,#5 ; FIVE FAILURES? BLT 472$ ; NO 471$: JMP ERR6 ; YES 472$: DIR$ #MKT ; NO, WAIT ONE SECONDS BCS 471$ ; ERROR WTSE$S #1 ; WAIT FOR TIME INC OPNERR ; INCREMENT TIME TRIED BR 47$ ; TRY AGAIN ; ; SEARCH FOR ACCOUNT IN FILE ; 48$: CALL SEARCH ; SEARCH FOR ACCOUNT NUMBER BCC 481$ ; OKAY JMP ERR2 ; ACCOUNT NOT FOUND ; ; LOG IN USER ; 481$: MOV ENTRY,R0 ; GET ADDRESS OF ENTRY ADD #A.GRP,R0 ; INT TO GROUP CODE MOV #UIC,R1 ; GET ADDRESS OF UIC MOV #MAIFIL,R5 ; WE'LL USE IT FOR MAIL TOO ;MRJ002 MOV #6.,R2 ; SET COUNT OF BYTES TO MOVE 482$: MOVB (R0),(R1)+ ; MOVE THEM ;MRJ002 MOVB (R0)+,(R5)+ ; SET UP MAIL FILE NAME(IN CASE IT EXISTS) ;MRJ002 DEC R2 ; DONE? BGT 482$ ; NO, LOOP MOV #UIC,R0 ; POINT AT START OF UIC STRING ; WB001 MOV #LOGINU+1,R1 ; POINT AT LOGIN.CMD UFD TEMPLATE ; WB001 484$: MOVB (R0)+,(R1)+ ; COPY GROUP OR MEMBER DIGITS ; WB001 MOVB (R0)+,(R1)+ ; ; WB001 MOVB (R0)+,(R1)+ ; ; WB001 CMPB #',,(R1)+ ; COPIED GROUP OR MEMBER? ; WB001 BEQ 484$ ; IF EQ GROUP -- COPY MEMBER ; WB001 MOV #UIC+3,R0 ; GET ADDRESS OF MEMBER CLRB 3(R0) ; SET END OF MEMBER CALL $COTB ; CONVERT TO BINARY MOVB R1,MEM ; STORE IT MOV #UIC,R0 ; GET GROUP CODE CLRB 3(R0) ; SET OF GROUP CALL $COTB ; CONVERT TO BINARY MOVB R1,GRP ; STORE IT MOV ENTRY,R0 ; POINT TO ADDRESS OF ACCOUNT ENTRY ; JGD04 ADD #A.UBLK,R0 ; POINT TO USED BLOCKS ENTRY ; JGD04 MOV (R0),R1 ; SAVE USED BLOCKS IN R1 ; JGD04 MOV ENTRY,R0 ; POINT TO ENTRY ADDRESS OF ACCOUNT ; JGD04 ADD #A.ABLK,R0 ; POINT TO ALLOWED BLOCKS ENTRY ; JGD04 MOV (R0),R2 ; ALLOCATED BLOCKS IN R2 ; JGD04 CMP R2,R1 ; IS ALLOWED BLOCKS>=USED BLOCKS ; JGD04 BGE 485$ ; YES, SKIP SETTING WARNING FLAG ; JGD04 INC BLKFLG ; NO, SET FLAG ; JGD04 485$: MOV ENTRY,R0 ; GET ADDRESS OF ACCOUNT ENTRY AGAIN ; JGD01 ADD #A.PRIV,R0 ; POINT TO ADDRESS OF PRIVLEDGE MASK WORD ; JGD01 MOV (R0),INDEX ; SAVE THE MASK WORD ; JGD01 BIT #4,INDEX ; CHECK TO SEE IF TASK TO BE RUN ON EXIT ; JGD04 BEQ 490$ ; NO, ITS OK TO PRINT LOGIN.TXT ; JGD04 INC TXTFLG ; YES, DON'T PRINT LOGIN.TXT ; JGD03 INC FRCFLG ; YES, DON'T PRINT LOGIN.TXT ; JGD03 MOV ENTRY,R0 ; GET ADDRESS OF ACCOUNT ENTRY ; JGD03 ADD #A.TNAM,R0 ; POINT TO TASK NAME TO RUN IF ANY ; JGD03 MOVB (R0)+,TSK ; INSERT FIRST LETTER INTO TASK NAME ; JGD03 MOVB (R0)+,TSK+1 ; INSERT SECOND LETTER INTO TASK NAME ; JGD03 MOVB (R0)+,TSK+2 ; INSERT THIRD LETTER INTO RUN COMMAND ; JGD03 MOVB (R0)+,TSK+3 ; INSERT FOURTH LETTER INTO TASK NAME ; JGD03 MOVB (R0)+,TSK+4 ; INSERT FIFTH LETTER INTO TASK NAME ; JGD03 MOVB (R0),TSK+5 ; INSERT LAST LETTER INTO TASK NAME ; JGD03 490$: ; BRANCHING LABEL ; JGD03 CALL $SWSTK,60$ ; SWITCH TO SYSTEM STACK MOV $TKTCB,R0 ; GET TCB ADDRESS MOV T.UCB(R0),R5 ; GET TI UCB ADDRESS BIS #U2.PRV,U.CW2(R5) ; SET TERMINAL AS PRIVILEGED ; EB033 ; (TEMPORARY)TI: SLAVED EARLIER ; EB033 BIC #U2.LOG,U.CW2(R5) ; SET TERMINAL LOGGED ON MOVB GRP,U.UIC+1(R5) ; STORE GROUP ;**-1 MOVB MEM,U.UIC(R5) ; STORE MEMBER MOV U.UIC(R5),U.LUIC(R5) ; SET LOGIN PROTECTION UIC MOV INDEX,U.PRV1(R5); INSERT THE PROTECTION MASK INTO THE UNUSED ; JGD01 ; CHARACTERISTICS WORD U.PRV1 IN TERMINAL UCB ; JGD01 MOV U.LUIC(R5),INDEX ; SAVE THE PROTECTION UIC FOR LATER ; JGD01 50$: RETURN ; RETURN TO USER STATE 60$: CALL LOGON ; LOG IN ACCOUNT FILE ; ; SET UP DEVICE TO BE USED FOR SY: ; MOV ENTRY,R0 ; GET ADDRESS OF ACCOUNT ENTRY ADD #A.SYDV,R0 ; POINT TO DEFAULT SYSTEM DEVICE MOV (R0)+,ASSN+4 ; STORE IT IN ASSIGN COMMAND MOV (R0)+,ASSN+6 ; CLOSE$ #$ACTFL ; CLOSE ACCOUNT FILE CLR FILOPN ; SET FILE CLOSED TST VTFLG ; IS BATCH TRYING TO LOG ONTO A VIRTUAL TERMINAL ; JGD08 BEQ 65$ ; IF EQ, NO PRINT OUT ALL HEADERS ; JGD08 JMP 120$ ; IF NE, YES, SKIP PRINTING HEADER ; JGD08 65$: ; REF LABLE ; JGD08 ; ; PRINT OUT SYSTEM ID AND TI: TERMINAL NUMBER ; MOV #40,ODPB+Q.IOPL+4 ; SET LF BEFORE, CR AFTER MOV #MS1,R0 ; SET MESSAGE ADDRESS MOV #MS1A,R2 ; GET ADDRESS OF BASE LEVEL BUFFER MOV #$SYSID,R1 ; GET ADDRESS OF BASE LEVEL MOVB (R1)+,(R2)+ ; MOVE IN BASE LEVEL MOVB (R1)+,(R2)+ ; MOVB (R1)+,(R2)+ ; MOVB (R1)+,(R2)+ ; CALL WRIT ; WRITE IT OUT MOVB TIMBUF+6,R1 ; GET HOUR OF THE DAY MOV #MS6,R0 ; DEFAULT TO 0-6AM CMP R1,#6. ; IS IT 0-6AM? BLT 70$ ; YES MOV #MS3,R0 ; NO, DEFAULT TO 6-12AM CMP R1,#12. ; IS IT 6-12AM? BLT 70$ ; YES MOV #MS4,R0 ; NO, DEFAULT TO 0-6PM CMP R1,#18. ; IS IT 0-6PM? BLT 70$ ; YES MOV #MS5,R0 ; NO, DEFAULT TO 6-12PM 70$: CALL WRIT ; PRINT OUT MESSAGE MOV #MS2,R0 ; GET ADDRESS FOR DATE AND TIME CALL DATTIM ; GET DATE AND TIME MOV $TKTCB,R0 ; GET TCB ADDRESS MOV T.UCB(R0),R3 ; GET TI UCB ADDRESS MOV #MS2A,R0 ; POINT TO AREA FOR TERMINAL NAME CALL $FMTDV ; FORMAT DEVICE NAME MOVB #15,(R0)+ ; PUT IN CR MOVB #12,(R0)+ ; AND LF CLRB (R0) ; SET END OF LINE MOV #MS2,R0 ; POINT TO BUFFER CALL WRIT ; WRITE IT OUT CALL MAIL ; NOTIFY USER IF THERE IS MAIL FOR HIM/HER ;MRJ002 TST BLKFLG ; IS THE USER USING TOO MANY BLOCKS ; JGD04 BEQ 100$ ; NO , SKIP OVER ; JGD04 MOV #MS8,R0 ; YES, PRINT WARNING MESSAGE ; JGD04 CALL WRIT ; AT TERMINAL ; JGD04 JMP 100$ ; SKIP OVER PRINTING JUNK TO CO: ; JGD04 ;*****>>>>WE CAN NEVER GET TO THIS SECTION OF CODE ; JGD07 ; LOG THIS LOGIN ON CO: ;BLS010 ; ;BLS010 MOV $HEADR,R0 ; GET MY HEADER ADDRESS ;BLS010 MOV H.LUN+<*4>(R0),R0 ; GET UCB ADDR FOR CO: ;BLS010 ; ($COLOG USES LUN 3 FOR CO:) ;BLS010 MOV $TKTCB,R3 ; GET MY TCB ADDRESS ;BLS010 MOV T.UCB(R3),R3 ; GET MY TI: UCB ADDRESS ;BLS010 CMP U.RED(R0),R3 ; IS CO: REDIRECTED TO THIS TI:? ;BLS010 BNE 700$ ; IF NE NO ;BLS010 MOV #1,-(SP) ; YES--FAKE AN ERROR FROM COLOG ;BLS010 BR 790$ ; SKIP THE LOGGING ;BLS010 700$: MOV #$COBUF,R0 ; POINT AT THE BUFFER ;BLS010 MOV #LGNMSG,R1 ; GET THE MSG FIRST PART ;BLS010 710$: MOVB (R1)+,(R0)+ ; COPY TO BUFFER ;BLS010 BNE 710$ ; WATCH FOR THE ZERO ;BLS010 DEC R0 ; BE SURE TO OVERWRITE THE NULL ;BLS010 MOV ENTRY,R1 ; POINT TO ENTRY ;BLS010 ADD #A.LNM,R1 ; POINT TO LAST NAME ;BLS010 MOV #14.,R2 ; COPY 14. BYTES ;BLS010 720$: MOVB (R1)+,(R0)+ ; COPY TO BUFFER ;BLS010 DEC R2 ; DO ALL ;BLS010 BNE 720$ ;BLS010 MOVB #'[,(R0)+ ; START UIC ;BLS010 CLR R1 ; PREPARE TO GET GROUP CODE ;BLS010 BISB GRP,R1 ; PICKUP THE GROUP CODE ;BLS010 CLR R2 ; SUPPRESS LEADING ZEROES ;BLS010 CALL $CBOMG ; CONVERT ;BLS010 MOVB #',,(R0)+ ; SEPARATE GRP AND MEM ;BLS010 CLR R1 ; SET TO GET MEMBER CODE ;BLS010 BISB MEM,R1 ; GET IT ALREADY ;BLS010 CLR R2 ; SUPPRESS LEADING ZEROES ;BLS010 CALL $CBOMG ; CONVERT ;BLS010 MOVB #'],(R0)+ ; FINISH UIC ;BLS010 MOVB #40,(R0)+ ; SET SPACE IN ;BLS010 CALL $FMTDV ; FORMAT DEVICE NAME ;BLS010 CLRB (R0) ; MARK END OF MSG ;BLS010 CALL $COLOG ; WRITE TO CO: ;BLS010 ROL -(SP) ; SAVE C-BIT FOR LATER ;BLS010 ; TO SEE IF WE SHOULD WAIT FOR QIO ;BLS010 790$: ; REF LABEL ;BLS010 ; ; PRINT OUT LOGIN MESSAGE FILE ; 100$: ; REF LABLE ; JGD04 MOV #100000,FRCFLG ; FORCE FIRST MESSAGE IN LOGIN.TXT FILE ;HJL065 MOV #IO.WBT,ODPB+Q.IOFN ; SET FUNCTION CODE ;HJL065 MOV #MSGDSP,R1 ; GET ADDRESS OF LOGIN.TXT FILE NAME ;**-2 CALL DSPFIL ; DISPLAY FILE ; ; ASSIGN CORRECT DEVICE TO SY: ; 120$: CALL $SWSTK,150$ ; SWITCH TO SYSTEM STATE MOV #84.,R1 ; SET LENGTH OF AN MCR BUFFER CALL $ALOCB ; GET A BUFFER BCS 140$ ; COULDN'T GET ONE MOV $TKTCB,R1 ; GET OUR TCB ADDRESS MOV T.UCB(R1),R2 ; GET TI UCB ADDRESS MOV R2,2(R0) ; SET TI UCB ADDRESS BIS #U2.AT.,U.CW2(R2) ; SET MCR SYNCHRONIZATION FLAG MOV R0,R1 ; COPY BUFFER ADDRESS CMP (R1)+,(R1)+ ; SKIP LINK AND UCB ADDRESS MOV #ASSN,R2 ; GET ADDRESS OF ASSIGN COMMAND 130$: MOVB (R2)+,(R1)+ ; MOVE MESSAGE INTO BUFFER BNE 130$ ; LOOP UNTIL ALL MOVED IN MOV R0,R1 ; GET ADDRESS OF BUFFER CALL $QMCRL ; LINK INTO MCR LIST 140$: RETURN ; RETURN TO USER STATE 150$: MOV #10,MKT+M.KTMG ; CHANGE WAIT MAGNITUDE TO 10 TICS ; EB033 ; JGD03 152$: CALL RUNCK ; CHECK OUT TO SEE IF RUN TASK ON EXIT ; JGD03 BCC 155$ ; IF CARRY IS CLEAR CONTINUE ; JGD03 DIR$ #MKT ; IF CARRY SET, WAIT ONE TENTH SECOND ; JGD03 BR 152$ ; AND TRY AGAIN ; JGD03 155$: MOV #ODPB,R4 ; GET TERMINAL DPB ADDRESS ; JGD03 MOV #IO.DET,2(R4) ; SET TO DETACH TERMINAL CALL QIO ; DETACH IT MOV $TKTCB,R0 ; GET OUR TCB ADDRESS MOV T.UCB(R0),R1 ; GET TI UCB ADDRESS ; MOV #10.,MKT+M.KTMG ; CHANGE WAIT MAGNITUDE ; EB033 160$: BIT #U2.AT.,U.CW2(R1) ; ASN DONE? BEQ 170$ ; YES DIR$ #MKT ; NO, WAIT FOR 1/6 OF A SECOND ; EB033 BCS 175$ ; ;**-1 WTSE$S #1 ; WAIT BCS 175$ ; BR 160$ ; LOOP 170$: CMPB U.LUIC+1(R1),#10 ; IS UIC PRIVILEGED? BLOS 180$ ; YES ; EB033 BIT #100000,U.PRV1(R1) ; IS BIT 15 SET, IF YES SET TI: PRIVLEGED ; JGD03 BNE 180$ ; YES, TI: SHOULB BE PRIVLEGED ; JGD03 175$: BIC #U2.PRV,U.CW2(R1) ; NO, CLEAR PRIV FLAG ;**-1 ;180$: BIC #U2.SLV,U.CW2(R1) ; ALLOW TERMINAL INPUT AGAIN ; WB001 180$: BIC #T3.MCR,T.ST3(R0) ; INHIBIT MCR PROMPT BIT #10,U.PRV1(R1) ; SHOULD TERMINAL BE LEFT SLAVED AT LOGON ; JGD05 BNE 182$ ; YES, LEAVE IT SLAVED ; JGD05 BIC #U2.SLV,U.CW2(R1) ; ALLOW TERMINAL INPUT AGAIN ; EB033 ; ROR (SP)+ ; SHOULD WE WAIT FOR CO: TO FINISH? ;BLS010 ; BCS 185$ ; IF CS NO ;BLS010 ; CALL $COWAT ; YES--WAIT NOW ;BLS010 ;185$: ; REF LABEL ;BLS010 182$: TST BYEFLG ; IF A REQUESTED TASK WAS NOT INSTALLED, THEN ; JGD03 ; LOG OFF ; JGD03 BEQ LOGCMD ; A TASK IF REQUESTED WAS INSTALLED ; JGD03 ; SO CONTINUE WITH LOGIN ; JGD03 RQST$S #BYE ; REQUESTED TASK NOT FOUND, LOG OFF ; JGD03 BIS #U2.SLV,U.CW2(R1) ; SET TI SLAVE UNTIL BYE CAN RUN ; JGD03 JMP EXIT ; ; JGD03 RUNCK: MOV $TKTCB,R1 ; GET OUR TCB ADRESS ; JGD03 CLC ; CLEAR CARRY FLAG EACH PASS THROUGH ; JGD03 MOV T.UCB(R1),R2 ; GET TI UCB ADDRESS ; JGD03 BIT #4,U.PRV1(R2) ; IS RUN TASK ON EXIT BIT SET ; JGD03 BNE 5$ ; YES, BRANCH ; JGD03 RETURN ; NO, THEN RETURN ; JGD03 5$: BIT #U2.AT.,U.CW2(R2) ; IS MCR STILL BUSY ? ; JGD03 BEQ 6$ ; NO ,THEN CONVERT TSK TO RAD50 ; JGD03 SEC ; YES SET CARRY AND RETURN ; JGD03 RETURN ; ; JGD03 6$: MOV #TSK,R0 ; MOVE ADRESS OF TASK NAME INTO R0 ; JGD03 INC R1 ; R1 NE 0 -> PERIOD A R50 CHARACTER ; JGD03 ; AFTER SETTING UP R0, AND R1 WE CAN USE THE ; JGD03 ; SUPPLIED ASCII TO RAD50 CONVERSION ROUTINE ; JGD03 CALL $CAT5 ; CALL RAD50 SUBROUTINE ; JGD03 MOV R1,TSK1 ; R1 HAS RAD50 TASK NAME, SO PUT IT IN TSK1 ; JGD03 CLR R1 ; R1 =0 -> PERIOD A TERMINATOR ; JGD03 MOV #TSK+3,R0 ; GET ADDRESS OF 2ND HALF OF TASK NAME ; JGD03 CALL $CAT5 ; CALL RAD50 SUBROUTINE ; JGD03 MOV R1,TSK1+2 ; MOVE SECOND HALF OF RAD50 NAME INTO TSK1 ; JGD03 RQST$S #TSK1 ; REQUEST THE TASK TO RUN ; JGD03 BCS 7$ ; IF CARRY SET DIRECTIVE IS REJECTED ; JGD03 RETURN ; ; JGD03 7$: JMP ERR13 ; GO WARN THAT TASK WAS NOT FOUND ; JGD03 ; ;WB001 ; EXECUTE USER'S LOGIN.CMD IF IT EXISTS ;WB001 ; ;WB001 LOGCMD: ;BIT #4,U.PRV1(R2) ; IS A TASK TO BE REQUESTED AT LOGON ; JGD07 BIT #4,U.PRV1(R1) ; IS A TASK TO BE REQUESTED AT LOGON ; JGD07 BNE 210$ ; YES, SKIP @LOGIN.CMD ; JGD07 TST VTFLG ; IS THIS A 'BATCH' LOGIN? ; JGD11 BNE 210$ ; IF NE, YES, DON'T PROCESS @LOGIN.CMD ; JGD11 MOV #$ACTFL,R0 ; FDB ADDRESS ;WB001 MOV #<$ACTFL+F.FNB>,R1 ; FILE NAME BLOCK ADDRESS ;WB001 MOV #LOGDSP,R2 ; DATA SET POINTER ;WB001 CLR R3 ; NO DEFAULT NAME BLOCK ;WB001 CALL .PARSE ; SET UP DIRECTORY AND DEVICE ;WB001 BCS 210$ ; THIS IS STRANGE ERROR ;WB001 CALL .FIND ; NOW LOOK FOR THAT FILE ;WB001 BCS 210$ ; BR IF NOT FOUND ;WB001 MOV #IO.WVB,ODPB+2 ; SET FUNCTION ;WB001 MOV #'+,ODPB+Q.IOPL+4 ; SET CARRAIGE CONTROL ;WB001 ; MOV #LOGINC,R0 ; SET COMMAND ADDRESS ;WB001 MOV #LOG,R0 ; SET COMMAND ADDRESS ; JGD12 CALL WRIT ; PRINT COMMAND ;WB001 CALL $SWSTK,210$ ; SWITCH TO SYSTEM STATE ;WB001 MOV #84.,R1 ; SET LENGTH OF AN MCR BUFFER ;WB001 CALL $ALOCB ; GET A BUFFER ;WB001 BCS 200$ ; COULDN'T GET ONE ;WB001 MOV $TKTCB,R1 ; GET OUR TCB ADDRESS ;WB001 MOV T.UCB(R1),2(R0) ; SET UCB IN MESSAGE ;WB001 MOV R0,R1 ; COPY BUFFER ADDRESS ;WB001 CMP (R1)+,(R1)+ ; SKIP LINK AND UCB ADDRESS ;WB001 MOV #LOGINC,R2 ; GET ADDRESS OF ASSIGN COMMAND ;WB001 190$: MOVB (R2)+,(R1)+ ; MOVE MESSAGE INTO BUFFER ;WB001 BNE 190$ ; LOOP UNTIL ALL MOVED IN ;WB001 MOV R0,R1 ; GET ADDRESS OF BUFFER ;WB001 CALL $QMCRL ; GIVE IT TO MCR ;WB001 200$: RETURN ; BACK TO TASK LEVEL ;WB001 210$: MOV $TKTCB,R0 ; GET MY TCB ;WB001 ; BIC #T3.MCR,T.ST3(R0) ; INHIBIT MCR PROMPT ;WB001 BIS #T3.MCR,T.ST3(R0) ; SET MCR TO PROMPT ; JGD11 BR EXIT ; ;**-1 .SBTTL ERROR PROCESSING ERR1: MOV #ER1,R0 ; SYNTAX ERROR BR ERROR ; ERR2: MOV #ER2,R0 ; INVALID ACCOUNT BR ERROR ; ERR3: MOV #ER3,R0 ; INVALID PASSWORD BR ERROR ; ERR4: MOV #ER4,R0 ; COMMAND INPUT ERROR BR ERROUT ; ERR5: MOV #ER5,R0 ; OTHER USER LOGGED ON BR ERROUT ; ERR6: MOV #ER6,R0 ; ACCOUNT FILE OPEN ERROR BR ERROR ; ERR7: MOV #ER7,R0 ; LOGINS ARE DISABLED ; BR ERROR ; BR ERROUT ; PRINT WARNING AND GO DISPLAY NOLOGIN.TXT ; JGD02 ERR8: MOV #ER8,R0 ; LOGIN MESSAGE FILE ERROR BR ERROUT ; ERR12: MOV #ER12,R0 ;MULTIPLE LOGINS FOR NON PRIVLEDGED USERS ; JGD01 BR ERROR ; ARE ILLEGAL ; JGD01 ERR13: MOV #ER13,R0 ; REQUESTED TASK NOT FOUND ; JGD03 CALL WRIT ; WRITE OUT WARNING MESSAGE ; JGD03 INC BYEFLG ; SET BYE FLAG SO TERMINAL WILL LOG OFF AT EXIT ; JGD03 RETURN ; FINISH LOGGING ON ; JGD03 ERROUT: MOV #40,ODPB+Q.IOPL+4 ; SET NORMAL CARRIAGE RETURN CALL WRIT ; WRITE OUT ERROR MESSAGE DETACH: MOV #ODPB,R4 ; GET OUTPUT DPB ADDRESS ; EB077 MOV #IO.DET,2(R4) ; SET FUNCTION TO DETACH ;**-1 CALLR QIO ; DETACH TERMINAL ERROR: CALL ERROUT ; PRINT OUT ERROR MESSAGE ERROR1: MOV $TKTCB,R0 ; GET OUR TCB ADDRESS MOV T.UCB(R0),R0 ; GET TI UCB ADDRESS BIS #U2.LOG,U.CW2(R0) ; BE SURE HE'S LOGGED OFF BIC #U2.SLV,U.CW2(R0) ; UN-SLAVE THE TERMINAL ;BLS024 CLR U.LUIC(R0) ; SET LOGIN UIC TO ZERO CLR U.UIC(R0) ; ZERO DEFAULT UIC EXIT: TST FILOPN ; IS ACCOUNT FILE OPEN? BEQ 10$ ; NO CLOSE$ #$ACTFL ; YES, CLOSE IT 10$: EXIT$S ; AND EXIT .SBTTL SUBROUTINES ;+ ; *** - WRIT - WRITE OUT BUFFER ; ; INPUT: ; R0 - MESSAGE ADDRESS ; ;- WRIT: MOV R0,R1 ; COPY BUFFER ADDRESS 10$: TSTB (R1)+ ; END OF MESSAGE? BNE 10$ ; NO, LOOP TILL END SUB R0,R1 ; COMPUTE LENGTH WRIT2: MOV #ODPB,R4 ; GET OUTPUT DPB ADDRESS ; EB077 MOV R0,Q.IOPL(R4) ; SET BUFFER ADDRESS ;**-1 MOV R1,Q.IOPL+2(R4) ; SET BUFFER LENGTH CALLR QIO ; WRITE IT OUT ;+ ; *** - READ - READ A LINE FROM TERMINAL ; ; INPUT: ; R0 - BUFFER ADDRESS ; R1 - LENGTH TO READ ; ; OUTPUT: ; R0 - BUFFER ADDRESS ;- READ: MOV #IDPB,R4 ; GET INPUT DPB ADDRESS MOV #IO.RVB,2(R4) ; SET READ VIRTUAL MOV R0,Q.IOPL(R4) ; SET BUFFER ADDRESS MOV R1,Q.IOPL+2(R4) ; SET BUFFER LENGTH CALL QIO ; READ MOV R0,R1 ; GET BUFFER ADDRESS ADD IOSB+2,R1 ; ADD NUMBER OF CHARACTERS READ MOVB IOSB+1,(R1) ; STORE TERMINATOR RETURN ; ;+ ; *** - READAL - READ PASS ALL AND NO ECHO ; ; INPUT: ; R0 - BUFFER ADDRESS ; R1 - MAX CHARACTERS TO READ ; ; OUTPUT: ; R0 - UNCHANGED ;- READAL: MOV R0,R2 ; GET BUFFER ADDRESS MOV R1,-(SP) ; SAVE BYTES TO READ MOV #IDPB,R4 ; GET INPUT DPB ADDRESS MOV #IO.RST!IO.RNE!IO.RLB,2(R4) ; SET READ ALL FUNCTION CODE 10$: MOV R1,Q.IOPL+2(R4) ; SET TO READ ONE CHARACTER AT A TIME MOV R2,Q.IOPL(R4) ; SET BUFFER ADDRESS CALL QIO ; READ MOVB IOSB+1,R3 ; GET TERMINATING CHARACTER ADD IOSB+2,R2 ; BUMP BUFFER POINTER BY CHARACTERS READ SUB IOSB+2,R1 ; COMPUTE CHARACTERS LEFT TO READ CMPB R3,#15 ; EOL? BEQ 30$ ; YES CMPB R3,#33 ; ESC? BEQ 30$ ; YES CMPB R3,#177 ; RUBOUT? BNE 15$ ; NO CMP R2,R0 ; YES, AT START OF BUFFER? BLOS 10$ ; YES, NO NEED TO RUBOUT MORE CLRB -(R2) ; NO, RUBOUT CHARACTER INC R1 ; SET ROOM FOR MORE BR 10$ ; AND TRY AGAIN 15$: CMPB R3,#25 ; CTRL/U? BNE 17$ ; NO MOV (SP)+,R1 ; SET CHARACTERS TO READ BR READAL ; AND LOOP 17$: SEC ; SET ERROR BR 60$ ; 30$: SUB R0,R2 ; COMPUTE CHARACTERS IN BUFFER BEQ 55$ ; IF ZERO, BLANK LINE 40$: MOVB (R0),R1 ; GET NEXT CHARACTER CMPB R1,#140 ; IS IT UPPER CASE? BLOS 50$ ; NO CMPB R1,#172 ; MAYBE BHI 50$ ; NO BICB #40,R1 ; CONVERT TO LOWER CASE 50$: MOVB R1,(R0)+ ; STORE CHARACTER DEC R2 ; ANY MORE CHARACTERS BGT 40$ ; YES, LOOP 55$: MOVB #15,(R0) ; SET END OF LINE CLC ; SET SUCCESS 60$: MOV (SP)+,R1 ; CLEAR STACK RETURN ; ;+ ; *** - ACCNT - GET ACCOUNT NUMBER OR USER NAME ; ; INPUT: ; R0 - BUFFER POINTER ; ; OUTPUT: ; R0 - UPDATED ; GRP - GROUP CODE ; MEM - MEMBER CODE ; UIC - 6 DIGIT ASCII UIC CODE ; OR IF NAME SPECIFIED ; NAME - 14 CHARACATER NAME OF USER ; CARRY SET - SYNTAX ERROR ; CARRY CLEAR - OKAY ;- ACCNT: CLR NAMFLG ; SET NO NAME SPECIFIED CALL $GNBLK ; GET NEXT NON-BLANK BCS 40$ ; EOL IS ERROR CMPB R2,#'[ ; BRACKET IS OPTIONAL BNE 1$ ; NOT BRACKET MOV R0,-(SP) ; SAVE BUFFER ADDREES DEC (SP) ; BACK IT UP TO BRACKET BR 101$ ; SKIP 1$: DEC R0 ; NO, BACKUP TO FIRST CHARACTER MOV R0,-(SP) ; SAVE BUFFER ADDRESS 101$: CALL $GTNUM ; GET GROUP CODE MOV R1,GRP ; STORE IT BNE 2$ ; NON-ZERO IS GOOD MOV (SP)+,R0 ; RESTORE BUFFER POINTER BR 10$ ; TRY IT AS NAME 2$: TST (SP)+ ; POP OFF OLD BUFFER ADDRESS CMP R1,#377 ; VALID GROUP CODE? BHI 40$ ; NO CMPB R2,#', ; TERMINATOR? BEQ 3$ ; YES CMPB R2,#'/ ; SLASH - DON'T PRINT LOGIN.TXT? BNE 40$ ; NO, SYNTAX ERROR INC TXTFLG ; YES, SET FLAG TO SUPPRESS LOGIN.TXT 3$: CALL $GTNUM ; GET MEMBER CODE MOV R1,MEM ; STORE IT CMP R1,#377 ; VALID MEMBER CODE? BHI 40$ ; NO CALL $NNBLK ; GET TERMINATOR BCS 5$ ; EOL IS OKAY CMPB R2,#'] ; IS IT BRACKET? BNE 4$ ; NO, ERROR CALL $GNBLK ; YES, GET NEXT BCS 5$ ; EOL, GOOD 4$: CMPB R2,#'/ ; PASSWORD COMMING? BNE 40$ ; NO, ERROR 5$: MOV R0,-(SP) ; SAVE BUFFER ADDRESS MOV PC,R2 ; SET TO GENERATE LEADING ZEROES MOV #UIC,R0 ; POINT TO AREA FOR MEMBER MOV MEM,R1 ; RETRIEVE MEMBER CODE CALL $CBOMG ; CONVERT MEMBER TO ASCII MOV #UIC-3,R0 ; POINT TO AREA FOR GROUP CODE MOV GRP,R1 ; GET GROUP CODE CALL $CBOMG ; CONVERT GROUP TO ASCII MOV (SP)+,R0 ; RESTORE BUFFER ADDRESS BR 45$ ; 10$: MOV #NAME,R3 ; GET ADDRESS OF NAME AREA MOV #14.,R4 ; SET LENGTH OF NAME 20$: MOVB #40,(R3)+ ; BLANK IT OUT DEC R4 ; DONE? BGT 20$ ; NO, LOOP INC NAMFLG ; YES, SET NAME IS SPECIFIED MOV #14.,R4 ; SET LENGTH OF NAME MOV #NAME,R5 ; SET ADDRESS 30$: CALL $GNBLK ; GET NEXT NON-BLANK CHARACTER BCS 45$ ; EOL, END TST R1 ; ANY BLANKS? BNE 35$ ; YES, ONLY SLASH IS VALID CALL TSTCHR ; IS IT A VALID CHARACTER? BCC 37$ ; YES 35$: CMPB R2,#'/ ; NO, PASSWORD COMMING? BEQ 50$ ; YES BR 40$ ; NO 37$: MOVB R2,(R5)+ ; STORE CHARACTER DEC R4 ; ROOM FOR MORE? BGT 30$ ; YES, TRY TO STORE IT 40$: SEC ; ERROR BR 50$ ; 45$: CLC ; SET SUCCESS 50$: RETURN ; ;+ ; *** - OPEN - OPEN FILE ; ;- OPEN: OPEN$U #$ACTFL,,,#FD.RWM ; OPEN FILE BCS 10$ ; ERROR INC FILOPN ; SET FILE IS OPEN 10$: RETURN ; ;+ ; *** - QIO - ISSUE QIO ; ; INPUT: ; R4 - DPB ADDRESS ;- QIO: DIR$ R4 ; ISSUE QIO BCS 10$ ; ERROR MOVB Q.IOEF(R4),R5 ; GET EVENT FLAG TO WAIT ON WTSE$S R5 ; AND WAIT 10$: RETURN ; ;+ ; *** - TSTCHR - TEST CHARACTER FOR VALID SYMBOL IN NAME. ; VALID CHARACTERS ARE A-Z, 0-9, $, ', !, -, AND . ; EB100 ; LOWER-CASE CHARS ARE CONVERTED TO UPPER-CASE. ; EB040 ; ;**-1 ; INPUT: ; R2 - CHARACTER TO BE CHECKED ; OUTPUT: ; R2 - UNCHANGED UNLESS LOWER-CASE CONVERTED TO UPPER-CASE ; EB040 ; CARRY CLEAR - GOOD ;**-1 ; CARRY SET - ERROR ;- TSTCHR: CMPB R2,#'A ; ALPHABETIC? BLO 10$ ; NO CMPB R2,#'Z ; MAYBE BLOS 40$ ; YES 10$: CMPB R2,#'0 ; NUMERIC? BLO 20$ ; NO CMPB R2,#'9 ; MAYBE BLOS 40$ ; YES 20$: CMPB R2,#'$ ; NO, DOLLAR? BEQ 40$ ; YES CMPB R2,#'' ; NO, APOSTROPHE? BEQ 40$ ; YES CMPB R2,#'! ; NO, EXCLAMATION BEQ 40$ ; YES CMPB R2,#'- ; NO, HYPHEN? ; EB100 BEQ 40$ ; YES ; EB100 CMPB R2,#'. ; NO, PERIOD? BEQ 40$ ; YES CMPB R2,#140 ; IS IT UPPER CASE? ; EB040 BLOS 30$ ; NO ; EB040 CMPB R2,#172 ; MAYBE ; EB040 BLOS 35$ ; YES ; EB040 30$: SEC ; NO, SET ERROR BR 50$ ; 35$: BICB #40,R2 ; CONVERT TO UPPER CASE ; EB040 40$: CLC ; SET SUCCESS 50$: RETURN ; ; EB079 ;+ ; EB079 ; *** - UICCON - CONVERT A BYTE TO THREE ASCII OCTAL DIGITS ; EB079 ; ; EB079 ; INPUTS: ; EB079 ; R0 - ADDRESS OF WHERE TO PUT FIRST ASCII DIGIT ; EB079 ; R1 - BYTE TO CONVERT ; EB079 ; ; EB079 ; OUTPUTS: ; EB079 ; R0 - ADDRESS+1 OF THIRD ASCII DIGIT ; EB079 ; R2, R3, R4, R5 - PRESERVED ; EB079 ;- ; EB079 ; EB079 UICCON: SWAB R1 ; POSITION BYTE TO BE CONVERTED AND ; EB079 ; CLEAR C-BIT ; EB079 CALL UICDIG ; CONVERT THREE DIGITS ; EB079 CALL UICDIG ; ; EB079 ; EB079 ;+ ; EB079 ; *** - UICDIG - CONVERT ONE OCTAL DIGIT TO THE EQUIVALENT ASCII ; EB079 ; CHARACTER ; EB079 ; ; EB079 ; INPUTS: ; EB079 ; R0 - ADDRESS OF WHERE TO PUT ASCII CHARACTER ; EB079 ; C-BIT - MOST SIGNIFICANT BIT OF OCTAL DIGIT ; EB079 ; R1 - RIGHT JUSTIFIED NEXT MOST SIGNIFICANT BITS OF OCTAL DIGIT ; EB079 ; ; EB079 ; OUTPUTS: ; EB079 ; R0 - ADDRESS+1 OF EQUIVALENT ASCII CHARACTER ; EB079 ; C-BIT - MOST SIGNIFICANT BIT OF NEXT OCTAL DIGIT ; EB079 ; R1 - ROTATED LEFT THREE BITS ; EB079 ;- ; EB079 ; EB079 UICDIG: ROL R1 ; PUT THREE BITS IN LOW BYTE ; EB079 ROL R1 ; ; EB079 ROL R1 ; ; EB079 BIC #370,R1 ; CLEAR EXCESS BITS ; EB079 MOVB #'0,(R0) ; CONVERT THREE BITS TO ASCII DIGIT ; EB079 BISB R1,(R0)+ ; ; EB079 RETURN ; ; EB079 ;+ ; *** - SEARCH - SEARCH FILE FOR ACCOUNT NUMBER ; ; OUTPUT: ; R0 - ADDRESS OF ACCOUNT ENTRY ; CARRY CLEAR - ACCOUNT FOUND ; CARRY SET - ACCOUNT NOT FOUND ;- SEARCH: MOV #FDPB,R4 ; GET FILE DPB ADDRESS MOV #1,Q.IOPL+10(R4) ; SET TO START AT VBN 1 CLR Q.IOPL+6(R4) ; 5$: CALL QIO ; READ NEXT BLOCK MOV IOSB+2,R2 ; GET COUNT OF WORDS READ BEQ 25$ ; ZERO, NO WORDS READ MOV #$ACTBF,R0 ; GET BUFFER ADDRESS 10$: TST NAMFLG ; IS NAME SPECIFIED? BEQ 15$ ; NO MOV R0,ENTRY ; YES, SAVE ENTRY ADDRESS MOV R1,-(SP) ; SAVE BYTES LEFT MOV R2,-(SP) ; ADD #A.LNM,R0 ; GET ADDRESS OF LAST NAME MOV #NAME,R1 ; GET ADDRESS OF NAME ENTERED MOV #14.,R2 ; SET LENGTH OF NAME 12$: CMPB (R0)+,(R1)+ ; NAMES THE SAME? BEQ 14$ ; YES SEC ; NO BR 18$ ; 14$: DEC R2 ; SO FAR BGT 12$ ; CONTINUE TILL END MOV ENTRY,R0 ; RESTORE ENTRY ADDRESS BR 17$ ; NAME IS THE SAME 15$: CMP UIC,A.GRP(R0) ; GROUP CODES MATCH BNE 20$ ; NO CMP UIC+2,A.GRP+2(R0) ; MAYBE BNE 20$ ; NO CMP UIC+4,A.MBR+1(R0) ; YES, MEMBER CODES MATCH? BNE 20$ ; NO MOV R0,ENTRY ; SAVE ENTRY POINTER MOV R1,-(SP) ; SAVE R1 AND R2 MOV R2,-(SP) ; 17$: CALL TPSWD ; CHECK PASSWORD 18$: MOV (SP)+,R2 ; RESTORE R1 AND R2 MOV (SP)+,R1 ; MOV ENTRY,R0 ; RESTORE ENTRY POINTER BCC 40$ ; PASSWORD CHECKS OUT 20$: ADD #A.LEN,R0 ; POINT TO NEXT ENTRY SUB #A.LEN,R2 ; COMPUTE WORDS LEFT IN BUFFER BHI 10$ ; LOOP, MORE LEFT 25$: CMPB #IE.EOF,IOSB ; END OF FILE? BEQ 30$ ; YES TSTB IOSB ; ANY ERRORS? BMI 30$ ; YES ADD #$BFLEN/512.,Q.IOPL+10(R4) ; NO, POINT TO NEXT VBN ADC Q.IOPL+6(R4) ; BR 5$ ; READ IN NEXT BUFFER 30$: SEC ; ERROR, ACCOUNT NOT FOUND 40$: RETURN ; ;+ ; *** - TPSWD - TEST PASSWORD ; ; CARRY SET - INVALID PASSWORD ; CARRY CLEAR - GOOD PASSWORD ; ;- TPSWD: ADD #A.PSWD,R0 ; POINT TO PASSWORD IN FILE MOV PSWDBF,R1 ; POINT TO PASSWORD TYPED IN MOV #6.,R2 ; SET SIZE OF PASSWORD 2$: CMPB (R1),#15 ; EOL? BEQ 4$ ; YES CMPB (R1),#33 ; NO, ALTMODE? ;BLS014 BEQ 4$ ; YES ;BLS014 CMPB (R1)+,(R0)+ ; NO, MATCH? BNE 10$ ; NO, ERROR DEC R2 ; ALL DONE? BGT 2$ ; NO, LOOP BR 20$ ; YES 4$: CMPB (R0)+,#' ; BLANK FROM HERE ON? BNE 10$ ; NO, ERROR DEC R2 ; DONE? BGT 4$ ; NO, LOOP BR 20$ ; YES 10$: SEC ; SET ERROR 20$: RETURN ; ;+ ; *** - LOGON - LOG THE SIGN ON TIME, UPDATE THE COUNT OF ; LOGONS, AND WRITE ENTRY BACK TO FILE. ; A NON PRIVLEGED USER IS ALLOWED TO LOG ON TO ONLY ; JGD01 ; ONE TERMINAL/ACCOUNT AT A TIME. ADDITIONAL LOGON ; JGD01 ; TO MULTI TERMINALS ARE REJECTED. ; JGD01 ; A PRIVLEGED USER HOWEVER CAN LOG ON TO AS MANY TERMINAS ; JGD01 ; AT ONCE AS HE/SHE DESIRES. ; JGD01 ; ; INPUT: ; ENTRY - ADDRESS OF ACCOUNT ENTRY ; ; OUTPUT: ;BLS010 ; ACCOUNT ENTRY MODIFIED IN FILE. FIRSTF FLAG SET TO 0 ;BLS010 ; IF NOT FIRST LOGIN TODAY, ELSE NON-ZERO IF FIRST LOGIN. ;BLS010 ;- LOGON: GTIM$S #TIMBUF ; GET TIME BCS 10$ ; ERROR MOV ENTRY,R0 ; GET ADRESS OF ENTRY ; JGD01 ADD #A.TERM,R0 ; UPDATE TO POINT AT TERMINAL # ; JGD01 GLUN$S #LUN1,#GLNBUF ; GET TERMINAL NUMBER ; JGD01 CMP GLNBUF,#"VT ; IS USER TRYING TO LOG ONTO "VT" FOR BATCH ; JGD08 BNE 101$ ; IF NE, NO, SO SKIP OVER ; JGD08 INC VTFLG ; SET VIRTUAL TERMINAL FLAG ; JGD08 BR 10$ ; AND SO DON'T FIDDLE WITH ACCOUNT FILE ; JGD08 101$: TST (R0) ; IS USER IS STILL LOGGED ONTO SOME ; JGD01 ; TERMINAL, ; JGD01 BNE 20$ ; HE IS, SO DON'T FIDDLE WITH ACCOUNT ; JGD01 MOV GLNBUF,(R0)+ ; HE ISN'T,INSERT 'TT' INTO FILE ; JGD01 MOV GLNBUF+2,(R0) ; INSERT FLAG BYTE AND TERM.# INTO FILE ; JGD01 MOV ENTRY,R0 ; GET ADDRESS OF ENTRY ADD #A.LDAT,R0 ; UPDATE TO POINT TO LOGON TIME MOV #SAVLGT,R1 ; POINT TO STORAGE FOR LAST LOGIN TIME ;BLS010 CLR R2 ; ASSUME NOT FIRST LOGIN TODAY ;BLS010 CMPB TIMBUF+4,(R0) ; IS THE DAY THE SAME? ;BLS010 BEQ 1$ ; IF EQ YES ;BLS010 INC R2 ; NO--FLAG FIRST LOGIN TODAY ;BLS010 1$: MOVB TIMBUF+4,(R0)+ ; SET DAY ;BLS010 CMPB TIMBUF+2,(R0) ; IS THE MONTH THE SAME? ;BLS010 BEQ 2$ ; IF EQ YES ;BLS010 INC R2 ; NO--FIRST LOGIN TODAY ;BLS010 2$: MOVB TIMBUF+2,(R0)+ ; SET MONTH ;BLS010 CMPB TIMBUF,(R0) ; IS THE YEAR THE SAME? ;BLS010 BEQ 3$ ; IF EQ YES ;BLS010 INC R2 ; NO--FIRST LOGIN TODAY ;BLS010 3$: MOVB TIMBUF,(R0)+ ; SET YEAR ;BLS010 MOVB (R0),(R1)+ ; COPY LAST LOGON TIME ;BLS010 MOVB TIMBUF+6,(R0)+ ; SET NEW LOGON TIME ;BLS010 MOVB (R0),(R1)+ ; COPY OLD MINUTES ;BLS010 MOVB TIMBUF+10,(R0)+ ; SET NEW MINUTES ;BLS010 MOVB (R0),(R1)+ ; COPY OLD SECONDS ;BLS010 MOVB TIMBUF+12,(R0)+ ; SET NEW SECONDS ;BLS010 MOV R2,FIRSTF ; SAVE FIRST LOGIN TODAY FLAG ;BLS010 INC (R0) ; BUMP UP THE LOGON COUNT ;**-6 MOV #FDPB,R4 ; GET FILE DPB ADDRESS MOV #IO.WVB,2(R4) ; SET WRITE FUNCTION CODE MOV IOSB+2,Q.IOPL+2(R4) ; SET COUNT OF BYTES TO WRITE CALL QIO ; WRITE OUT ACCOUNT ENTRY MOV #IO.RVB,2(R4) ; RESTORE DPB MOV #$BFLEN,Q.IOPL+2(R4) ; 10$: RETURN ; 20$: MOV INDEX,R1 ; GET TERMINAL GROUP NUMBER ; JGD01 SWAB R1 ; MOVE GROUP NUMBER TO LOWER BYTE ; JGD01 CMPB R1,#10 ; IF THE USER IS NOT PRIVLEDGED, THEN LOGGING ; JGD01 ; ON TO MULTIPLE TERMINALS IS ILLEGAL ; JGD01 BHI 30$ ; NOT PRIVLEDGED, WARN AND LOG OFF ; JGD01 MOV #MS7,R0 ; WARN USER HE IS LOGGED ONTO MULTIPLE ; JGD01 CALL WRIT ; TERMINALS ; JGD01 25$: RETURN ; LEAVE ACCOUNT FILE ALONE ; JGD08 30$: JMP ERR12 ; REPORT ERROR AND LOG OFF ; JGD01 ;+ ; *** - DATTIM - CONVERT DATE AND TIME TO ASCII ; ; INPUT: ; R0 - BUFFER ADDRESS ; TIMBUF - DATA RETURNED BY GTIM$ ; OUTPUT: ; R0 - UPDATED (16. CHARACTERS) ; R1, R2, R3 - USED ;- DATTIM: MOVB TIMBUF+4,R1 ; GET DAY CALL TWODEC ; CONVERT TO TWO DECIMAL DIGITS MOVB #'-,(R0)+ ; MOVB TIMBUF+2,R1 ; GET MONTH CALL GETMON ; CONVERT TO ASCII MOVB #'-,(R0)+ ; MOVB TIMBUF,R1 ; GET YEAR CALL TWODEC ; CONVERT TO TWO DECIMAL DIGITS MOVB #40,(R0)+ ; MOVB TIMBUF+6,R1 ; GET HOUR CALL TWODEC ; CONVERT TO TWO DECIMAL DIGITS MOVB #':,(R0)+ ; MOVB TIMBUF+10,R1 ; GET MINUTE CALL TWODEC ; CONVERT TO TWO DECIMAL DIGITS MOVB #40,(R0)+ ; RETURN ; ;+ ; *** - TWODEC - CONVERT BINARY NUMBER TO TWO DECIMAL DIGITS ; ; INPUT: ; R0 - BUFFER ADDRESS ; R1 - BINARY NUMBER TO BE CONVERTED ; OUTPUT: ; R0 - UPDATED ; R1, R2, AND R3 USED ;- TWODEC: CMP R1,#10. ; >= 10.? BGE 10$ ; YES MOVB #'0,(R0)+ ; NO, PUT IN LEADING ZERO 10$: CLR R2 ; SET TO SUPPRESS LEADING ZEROES CALL $CBDMG ; CONVERT TO DECIMAL RETURN ; ;+ ; *** - GETMON - CONVERT MONTH TO ASCII ; ; INPUT: ; R0 - BUFFER ADDRESS ; R1 - MONTH (1-12) ; OUTPUT: ; R0 - UPDATED ; R1, R2 USED ;- GETMON: DEC R1 ; CONVERT TO INDEX MOV R1,R2 ; COPY IT ADD R2,R1 ; MULTIPLY BY ADD R2,R1 ; THREE ADD #MONTH,R1 ; GET ADDRESS OF MONTH IN ASCII MOVB (R1)+,(R0)+ ; MOVE MONTH MOVB (R1)+,(R0)+ ; INTO BUFFER MOVB (R1)+,(R0)+ ; RETURN ; ;+ ; *** - DSPFIL - DISPLAY FILE ON TERMINAL ; ; INPUT: ; R1 - ADDRESS OF FILE NAME DECRIPTOR ; OUTPUT: ; R0, R1, R2, R3 - USED ;- ; EB077 .ENABL LSB ; EB077 ; EB077 DSPFIL: FINIT$ ; MOV #$ACTFL,R0 ; GET FILE FDB MOV #40,ODPB+Q.IOPL+4 ; SET CARRIAGE CONTROL OPEN$R R0,,R1,#0,#BUF,#132. ; OPEN TEXT FILE FOR READ ; EB056 BCS FILERR ; ERROR ; EB077 INC FILOPN ; SET FILE OPEN FLAG ;**-2 TST FRCFLG ; SHOULD WE DATE/TIME CHECK? ;BLS010 BPL 10$ ; IF PL NO ;BLS010 BIC #100000,FRCFLG ; YES--BUT CLEAR DATE/TIME CHECK FLAG ;BLS010 CALL DATCHK ; SEE IF USER SHOULD SEE MESSAGE ;BLS010 BCS 40$ ; IF CS NO--CLOSE OUT AND RETURN ;BLS010 10$: GET$ #$ACTFL,#BUF,#132. ; READ A LINE FROM THE FILE ; EB056 BCS 20$ ; ;**-1 MOV F.NRBD(R0),R1 ; GET LENGTH OF LINE MOV #BUF,R0 ; GET BUFFER ADDRESS ADD R0,R1 ; GET ADDRESS OF LAST CHARACTER CLRB (R1) ; SET END OF LINE CMPB (R0),#'% ; END OF MESSAGE? ;HJL065 BNE 15$ ; NO, PRINT LINE ;HJL065 TST FRCFLG ; FORCE DISABLED? ;HJL065 BNE 10$ ; YES, SKIP PRINTING "%" ;HJL065 INC FRCFLG ; DISABLE FORCE ;HJL065 MOV #IO.WVB,ODPB+Q.IOFN ; RESET FUNCTION CODE ;HJL065 TST TXTFLG ; SUPPRESS REST OF FILE? ;HJL065 BNE 40$ ; YES ;HJL065 BR 10$ ; NO, LOOP FOR REST OF FILE ;HJL065 15$: CALL WRIT ; WRITE OUT NEXT LINE ;HJL065 BR 10$ ; LOOP UNTIL EOF ;**-1 20$: CMPB F.ERR(R0),#IE.EOF ; END OF FILE? BEQ 40$ ; YES FILERR: MOVB F.ERR(R0),R1 ; GET ERROR CODE ; EB077 MOV #ER8NUM,R0 ; GET ADDRESS OF BUFFER ;**-1 CLR R2 ; SUPPRESS LEADING ZEROES CALL $CBDSG ; CONVERT ERROR CODE MOVB #'.,(R0)+ ; PUT IN DECIMAL POINT CLRB (R0) ; SET END OF LINE CALL ERR8 ; PRINT OUT ERROR MESSAGE 40$: CLOSE$ #$ACTFL ; CLOSE FILE CLR FILOPN ; SET FILE CLOSED FLAG RETURN ; ; EB077 .DSABL LSB ; EB077 .SBTTL HELP ROUTINES ; EB077 ;+ ; EB077 ; *** - HELPP - PRINT OUT THE DESIRED PART OF THE HELP FILE ; EB077 ; ; EB077 ; HELLO RECOGNIZES COMMAND LINES OF THE FORM: ; EB077 ; HELP ; EB077 ; HELP KEY1 KEY2 ... KEY9 ; EB077 ; WHERE KEY1, KEY2, ... KEY9 ARE KEYWORDS (STRINGS OF CHARACTERS ; EB077 ; SEPARATED BY BLANKS OR NULLS). THE EFFECT IS TO DISPLAY A ; EB077 ; SECTION OF [1,2]HELP.TXT ON TI:. IF A KEYWORD BEGINS WITH A /, ; EB077 ; THE / IS IGNORED. WHEN TYPING A KEYWORD, IT IS NECESSARY TO TYPE ; EB077 ; ONLY THE MINIMUM NUMBER OF INITIAL CHARACTERS THAT UNAMBIGUOUSLY ; EB077 ; DIFFERENTIATE THE KEYWORD FROM ALL OTHER KEYWORDS OF LEVEL N IN ; EB077 ; HELP.TXT. ; EB077 ; ; EB077 ; HELP.TXT IS STRUCTURED IN A RIGIDLY NESTED FASHION. IT IS COMPOSED ; EB077 ; OF KEYWORD RECORDS (LINES) AND BLOCKS OF TEXT. A KEYWORD RECORD ; EB077 ; HAS A DIGIT (1-9) AS ITS FIRST CHARACTER, FOLLOWED BY AN ARBITRARY ; EB077 ; NUMBER OF BLANKS AND TABS, FOLLOWED BY A KEYWORD. A KEYWORD IS A ; EB077 ; STRING OF UPPER-CASE LETTERS AND NON-LOWER-CASE CHARACTERS. A BLOCK ; EB077 ; OF TEXT IS A SERIES OF LINES EACH OF WHICH DO NOT BEGIN WITH A DIGIT. ; EB077 ; FOR COMPATIBILITY WITH THE DCLS IMPLEMENTATION, THEY SHOULD BEGIN ONLY ; EB077 ; WITH A TAB OR BLANK. A KEYWORD LINE OR TEXT LINE CAN BE UP TO 132. ; EB077 ; CHARACTERS LONG. IF A KEYWORD BEGINS WITH A $ OR A /, THE $ OR / ; EB077 ; IS IGNORED. ; EB077 ; ; JGD10 ; KEYWORDS MAY HAVE SYNONYMS IN THE HELP FILE. FOLLOWING A VALID KEYWORD ; JGD10 ; AND LEVEL COMBINATION, ANY NUMBER OF LINES PRECEDED WITH A '$' IN PLACE OF ; JGD10 ; THE LEVEL DIGIT, MAY BE PLACED, EACH HAVING A SYNONYM KEYWORD. ; JGD10 ; 1 KEY1 ; JGD10 ; $ SYNONYM1 ; JGD10 ; $ SYNONYM2 ; JGD10 ; $ SYNONYM3... ; JGD10 ; AND SO ON. THIS ALLOWS THE SAME HELP INFORMATION TO BE DISPLAYED FOR A WIDER ; JGD10 ; RANGE OF USER INPUTS. FOR EXAMPLE, HELP PIP DIRECTORY, HELP PIP /LI, AND ; JGD10 ; HELP PIP /FU COULD ALL DISPLAY THE SAME INFORMATION. ; JGD10 ; ; JGD10 ; NORMALLY, VERY LITTLE INFORMATION IS KEPT IN HELP.TXT, EXCEPT FOR BRIEF ; JGD10 ; QUICKIES. IF THE INITIAL KEYWORD IS NOT FOUND IN HELP.TXT , THEN ; JGD10 ; KEYWORD.TXT IS SEARCHED(IF IT EXISTS, OR THE 'UNKNOWN QUALIFIER' MESSAGE IS ; JGD10 ; PRODUCED. IF THE KEYWORDS CAN NOT BE FOUND IN KEYWORD.TXT THE OPTION ; JGD10 ; EXISTS AT THIS POINT TO LET THE USER KNOW EXACTLY WHAT KEYWORDS ARE AVAILABLE ; JGD10 ; IN KEYWORD.TXT. TO ACCOMPLISH THIS, A MATCHALL LEVEL IDENTIFIER HAS BEEN ; JGD10 ; ADDED. A # IN COLLUM 1 WILL MATCH ANY AND ALL STRINGS OF KEYWORDS. TO ; JGD10 ; BE USEFUL, THE MATCHALL LEVEL IDENTIFIER MUST BE THE LAST HELP SECTION OF ; JGD10 ; OF THE SPECIFIED FILE. THIS SECTION OF THE FILE WILL THEN BE DISPLAYED IF THE; JGD10 ; KEYWORDS CAN NOT BE FOUND EARLIER. FOR EXAMPLE AN INDEX OF AVAILABLE KEYWORDS; JGD10 ; MAY BE DISPLAYED. ; ; EB077 ; THE GENERAL HELP.TXT FILE ORGANIZATION IS A BLOCK OF TEXT, WHICH ; EB077 ; BEGINS WITH A LINE THAT WILL NOT BE DISPLAYED (GENERALLY BLANK) AND ; EB077 ; IS DISPLAYED IF THERE ARE NO KEYWORDS, FOLLOWED BY AN ARBITRARY ; EB077 ; NUMBER OF GROUPS COMPOSED OF A KEYWORD RECORD AND A BLOCK OF TEXT. ; EB077 ; THE COMMAND LINE IS SCANNED FOR KEYWORDS. IF KEY1 EXISTS, HELP.TXT ; EB077 ; IS SEARCHED FOR THE KEYWORD RECORD "1 KEY1". IF KEY2 DOES NOT EXIST, ; EB077 ; THE BLOCK OF TEXT AFTER THE KEYWORD RECORD IS DISPLAYED. IF KEY2 ; EB077 ; DOES EXIST, THE GROUPS AFTER "1 KEY1" AND BEFORE THE NEXT LEVEL 1 ; EB077 ; KEYWORD RECORD ARE SEARCHED FOR THE KEYWORD RECORD "2 KEY2". IF KEY3 ; EB077 ; DOES NOT EXIST, THE BLOCK OF TEXT AFTER "2 KEY2" IS DISPLAYED. THE ; EB077 ; PROCESS CONTINUES FOR THE N KEYWORDS. ; EB077 ; ; EB077 ; THE FOLLOWING IS AN EXAMPLE OF THAT GENERAL ORGANIZATION: ; EB077 ; ; EB077 ; BLOCK OF TEXT (BEGINNING WITH A BLANK LINE) ; EB077 ; 1 KEY1 ; EB077 ; BLOCK OF TEXT1 ; EB077 ; 1 KEY2 ; EB077 ; BLOCK OF TEXT 2 ; EB077 ; 2 KEY3 ; EB077 ; BLOCK OF TEXT3 ; EB077 ; 2 KEY4 ; EB077 ; BLOCK OF TEXT4 ; EB077 ; 3 KEY5 ; EB077 ; BLOCK OF TEXT5 ; EB077 ; 2 KEY6 ; EB077 ; BLOCK OF TEXT6 ; EB077 ; ; EB077 ; LEGAL COMMANDS ARE: ; EB077 ; HELP - BLOCK OF TEXT IS DISPLAYED ; EB077 ; HELP KEY1 - BLOCK OF TEXT1 IS DISPLAYED ; EB077 ; HELP KEY2 - BLOCK OF TEXT2 IS DISPLAYED ; EB077 ; HELP KEY2 KEY3 - BLOCK OF TEXT3 IS DISPLAYED ; EB077 ; HELP KEY2 KEY4 - BLOCK OF TEXT4 IS DISPLAYED ; EB077 ; HELP KEY2 KEY4 KEY5 - BLOCK OF TEXT5 IS DISPLAYED ; EB077 ; HELP KEY6 - BLOCK OF TEXT 6 IS DISPLAYED ; EB077 ; ; EB077 ; ; JGD09 ; IF HELP.TXT BECOMES LENGTHY, THE SEARCH TIMES FOR A KEYWORD ARE LONG. ; JGD09 ; TO SPEED UP PROCESSING, IF A KEYWORD IS NOT FOUND IN HELP.TXT, HELP.TXT IS ; JGD09 ; CLOSED, AND A FILE WITH THE NAME 'KEYWORD1.TXT' IS OPENED FOR READ. IF ; JGD09 ; 'KEYWORD1.TXT' IS SUCCESSFULLY OPENED, IT IS SEARCHED FOR KEYWORDS2.....8 ; JGD09 ; IN AN IDENTICAL MANNER TO HELP.TXT. IF 'KEYWORD1.TXT' CAN NOT BE OPENED ; JGD09 ; EITHER BECAUSE IT DOESN'T EXIST OR BECAUSE OF AN FCS ERROR, THE 'UNKNOWN ; JGD09 ; QUALIFIER' ERROR MESSAGE IS DISPLAYED. IF HELP.TXT IS LENGTHY, ; JGD09 ; HELP $KEYWORD1,KEYWORD2...., WILL FIND THE INFORMATION MORE SPEEDLY ; JGD09 ; AS THE INITIAL OPENING, SEARCHING, AND CLOSING OF HELP.TXT IS NOT REQUIRED. ; JGD09 ; ; JGD09 ; NOTE THAT TWO KEYWORDS CAN BE IDENTICAL (E.G., KEY2 AND KEY3) AS ; EB077 ; LONG AS THEY DO NOT HAVE THE SAME LEVEL NUMBER (E.G., KEY3 AND KEY6). ; EB077 ; ; EB077 ; ; EB077 ; INPUT: ; EB077 ; R1 - ADDRESS OF DATASET DESCRIPTOR OF HELP FILE ; EB077 ; R4 - ADDRESS OF FIRST CHARACTER PAST "HELP" IN COMMAND LINE ; EB077 ; ; EB077 ; OUTPUT: ; EB077 ; THE DESIRED PART OF THE HELP FILE IS COPIED TO TI: ; EB077 ; SOME ERRORS TERMINATE HELLO WITHOUT RETURNING ; EB077 ; ALL REGISTERS ARE DESTROYED ; EB077 ;- ; EB077 ; EB077 HELPP: FINIT$ ; INITIALIZE FILE SYSTEM ; EB077 HELP2: MOV #$ACTFL,R0 ; POINT AT FDB WE WILL USE FOR HELP FILE ; EB077 OPEN$R R0,,R1,#FD.PLC,#HLPBUF,#132. ; OPEN IT FOR READ ; EB077 BCC 10$ ; IF CC, NO ERROR ; JGD09 TST PASFLG ; IF SECOND PASS THROUGH, AND CAN'T FIND FILE ; JGD09 BGT 90$ ; REPORT OPEN ERROR AS UNKNOWN QUALIFIER ; JGD09 JMP FILERR ; IF EQ 0, (1ST PASS) REPORT FCS ERROR ; JGD09 ; THIS DIVISION OF ERRORS IS NOT QUIET RIGHT ; JGD09 ; BUT IT IS SERVICIBLE ; JGD09 ; BCS FILERR ; REPORT FILE SYSTEM PROBLEM ; EB077 10$: ; REF LABLE ; JGD09 INC FILOPN ; SHOW THAT THE FILE IS OPEN ; EB077 GET$ #$ACTFL,,,GETEOF ; GET THE FIRST RECORD ; EB077 CALL MARK1 ; MARK ITS POSITION ; EB077 MOV #'0,DEPTH ; START LOOKING FOR LEVEL 1 KEYWORDS ; EB077 20$: CMPB #15,(R4) ; FOUND LAST KEYWORD? ; EB077 BEQ TEXT ; COPY HELP FILE TO TI: UNTIL A ; EB077 ; KEYWORD RECORD IS FOUND ; EB077 CMPB #40,(R4)+ ; COULD THERE BE A KEYWORD? ; EB077 BEQ 30$ ; YES ; EB077 MOV #ER1,R0 ; NO, SYNTAX ERROR ; EB077 25$: MOV R4,R3 ; SAVE R4 ; EB077 27$: CALL WRIT ; PRINT ERROR MESSAGE ; EB077 MOV #BUF,R0 ; PRINT THE LINE UP TO THE PLACE ; EB077 MOV R3,R1 ; OF ERROR ; EB077 SUB R0,R1 ; FORM NUMBER OF CHARS TO ERROR ; EB077 JMP HLPERR ; PRINT LINE IN ERROR AND GET OUT ; EB077 30$: INC DEPTH ; NEW KEYWORD IMPLIES A NEW DEPTH ; EB077 31$: CMPB #40,(R4) ; IS NEXT CHARACTER A SPACE? ; JGD10 BNE 40$ ; IF NE, NO, SO ASSUME A VALID KEYWORD ; JGD10 INC R4 ; BUMP TO NEXT CHARACTER ; JGD10 BR 31$ ; AND LOOP ; JGD10 40$: CALL NXTREC ; DOES A KEYWORD RECORD WITH THAT ; EB077 ; LEVEL (DEPTH) EXIST? ; EB077 BCS 90$ ; NO, THE KEYWORD IS UNKNOWN ; EB077 CALL COMPAR ; COMPARE RECORD KEYWORD AND USER KEYWORD ; EB077 BCS 40$ ; NO MATCH. TRY ANOTHER RECORD. ; EB077 CALL MARK2 ; MARK THIS RECORD. IF USER KEYWORD IS ; EB077 ; NOT AMBIGUOUS, WANT TO COPY IT TO TI: ; EB077 CALL NXTREC ; DOES ANOTHER KEYWORD RECORD EXIST? ; EB077 BCS 60$ ; NO, MAY WANT TO PRINT THE LAST SECTION ; EB077 CALL COMPAR ; FOUND A DUPLICATE KEYWORD? ; EB077 ; BCC 100$ ; YES, KEYWORD IS AMBIGUOUS ; EB077 BCS 60$ ; NO, KEYWORD NOT AMBIGUOUS ; JGD10 TST MTCHAL ; IS AMBIGUOUS, BUT IS IT THE MATCHALL ; JGD10 BEQ 100$ ; NO, IT IS AMBIGUOUS ; JGD10 60$: MOV #MARKSV,R1 ; REMEMBER WHERE TEXT STARTS THAT IS ; EB077 MOV #3*2+MARKSV,R2 ; ASSOCIATED WITH THIS KEYWORD RECORD. ; EB077 MOV (R2)+,(R1)+ ; ; EB077 MOV (R2)+,(R1)+ ; ; EB077 MOV (R2),(R1) ; ; EB077 CALL POINT ; START NEXT KEYWORD SEARCH AFTER ; EB077 ; LAST GOOD KEYWORD RECORD ; EB077 CALL PUSH ; POINT PAST MATCHED USER KEYWORD ; EB077 BR 20$ ; SEE IF MORE KEYWORDS ; EB077 90$: ; REF LABLE ; JGD09 TST PASFLG ; IS THIS THE FIRST PASS THROUGH ; JGD09 BGT 92$ ; IF GT, NO, REALY CAN'T FIND KEYWORD, EXIT ; JGD09 INC PASFLG ; SET FLAG, AND LOOK FOR INFO IN NAME.TXT ; JGD09 JMP HELP1 ; PARSE COMMAND LINE, AND SET UP FDB ; JGD09 92$: ; REF LABLE ; JGD09 MOV #ER11,R0 ; UNKNOWN KEYWORD ; JGD09 CALL PUSH ; POINT AFTER UNKNOWN KEYWORD ; EB077 BR 25$ ; PRINT ERROR MESSAGE AND KEYWORD ; EB077 100$: MOV #ER9,R0 ; AMBIGUOUS KEYWORD ; EB077 BR 27$ ; ; EB077 TEXT: CALL POINT ; POINT AT FIRST RECORD TO COPY TO TI: ; EB077 CLR ODPB+Q.IOPL+4 ; WE WILL HANDLE CARRIAGE CONTROL ; EB077 10$: MOV #MS1,R0 ; WRITE A CARRIAGE RETURN AND LINE ; EB077 MOV #2,R1 ; FEED TO TI: ; EB077 CALL WRIT2 ; ; EB077 GET$ #$ACTFL,,,GETEOF ; GET THE NEXT HELP FILE RECORD ; EB077 MOV F.NRBD(R0),R1 ; GET LENGTH OF RECORD ; EB077 BEQ 10$ ; ALREADY PUT OUT CR/LF ; EB077 MOV F.NRBD+2(R0),R0 ; POINT AT FIRST CHARACTER OF RECORD ; EB077 CALL ISREC ; IS THIS A KEYWORD RECORD? ; EB077 BCC 40$ ; YES, DONE COPYING RECORDS TO TI:(MAYBE) ; EB077 30$: CALL WRIT2 ; COPY THE RECORD TO TI: ; EB077 BCC 10$ ; IF EVERYTHING WENT OKAY, SEE IF ; EB077 ; THE NEXT LINE SHOULD BE COPIED ; EB077 ;40$: RETURN ; ; EB077 40$: ; REFERENCE LABLE ; JGD10 TST SYNFLG ; COULD THE KEYWORD BE A SYNANYM ; JGD10 BNE 10$ ; IF NE, YES, SO SKIP PRINTING IT AND CHECK NEXT; JGD10 RETURN ; ALL DONE PRINTING HELP ; JGD10 ; EB077 GETEOF: TST (SP)+ ; POP OFF RETURN ADDRESS FROM JSR ; EB077 RETURN ; ; EB077 ; EB077 HELP1: CLOSE$ #$ACTFL ; MUST CLOSE OLD FILE BEFORE TRYING AGAIN ; JGD09 MOV #BUF+4,R0 ; POINT TO 5TH PLACE IN COMMAND BUFFER ; JGD09 4050$: TSTB (R0)+ ; BUMP TO FIRST CHARACTER OF FILE NAME ; JGD09 CMPB #40,(R0) ; COULD IT BE A %? ; JGD13 BEQ 4050$ ; IF EQ, KEEP LOOKING FOR FILE NAME ; JGD13 MOV #HLPNAM,R3 ; GET ADRESS OF PLACE TO PUT NAME ; JGD09 CLR CHRNUM ; ASSUME ZERO LENGTH TO START WITH ; JGD09 4060$: MOV R0,R4 ; SAVE LOCATION IN BUFFER IN CASE OF ; JGD09 CMPB (R0),#15 ; IS IT A RETURN? ; JGD09 BEQ 4080$ ; YES, GO DISPLAY HELP FILE ; JGD09 CMPB (R0),#40 ; IS IT A SPACE ; JGD09 BEQ 4080$ ; YES, GO DISPLAY HELP FILE ; JGD09 MOVB (R0)+,(R3)+ ; NO, MOVE IN FILE NAME(UP TO 9 CHARACTERS) ; JGD09 INC CHRNUM ; AND INCREMENT CHARACTER COUNT ; JGD09 CMP #9.,CHRNUM ; ARE WE AT 9 CHARACTERS YET? ; JGD09 BNE 4060$ ; NO, WE DON'T HAVE FILE NAME ; JGD09 ; SO BRANCH BACK AND LOOK FOR EOL, SP, OR CHAR. ; JGD09 ; ; JGD09 ; YES, WE HAVE FILE NAME ; JGD09 ; HOWEVER, >9 CHAR. FILENAMES TRUNCATED AND ; JGD09 ; KEYWORDS AFTER >9 CHAR FILE NAME WILL FAIL ; JGD09 4070$: MOV R0,R4 ; SAVE POINTER IN BUFFER AFTER FILE NAME ; JGD09 4080$: MOVB #'.,(R3)+ ; MOVE IN "." ; JGD09 MOVB #'T,(R3)+ ; MOVE IN "T" ; JGD09 MOVB #'X,(R3)+ ; MOVE IN "X" ; JGD09 MOVB #'T,(R3) ; MOVE IN "T" ; JGD09 ADD #4.,CHRNUM ; UPDATE THE CHARACTER COUNT IN THE FILE STRING ; JGD09 MOV #HLPFIL,R1 ; POINT TO FILE DESCRIPTOR BLOCK ; JGD09 MOV #1,FRCFLG ; FORCE FILE TO BE PRINTED ; JGD09 JMP HELP2 ; CALL HELP PROCESSOR ; JGD09 ;+ ; EB077 ; *** - NXTREC - GET THE NEXT HELP FILE RECORD OF THE SAME LEVEL ; EB077 ; AS THE USER KEYWORD ; EB077 ; ; EB077 ; INPUT: ; EB077 ; DEPTH - USER KEYWORD LEVEL ; EB077 ; ; EB077 ; OUTPUT: ; EB077 ; CARRY CLEAR - NEXT HELP FILE RECORD OF THE SAME LEVEL AS THE ; EB077 ; USER KEYWORD IS IN HLPBUF ; EB077 ; R0 - ADDR OF FIRST CHAR IN NEXT HELP FILE RECORD OF ; EB077 ; THE SAME LEVEL AS THE USER KEYWORD ; EB077 ; R3 - SIZE OF THE RECORD ; EB077 ; CARRY SET - NO MORE RECORDS IN FILE OR FOUND A RECORD WITH A ; EB077 ; LEVEL NUMBER LESS THAN THAT OF THE USER KEYWORD ; EB077 ; R1, R2, R4, R5 - PRESERVED ; EB077 ;- ; EB077 ; EB077 NXTREC: GET$ #$ACTFL ; GET NEXT RECORD ; EB077 BCS 20$ ; SOME SORT OF ERROR FROM GET$. TREAT ; EB077 ; IT AS END OF FILE. ; EB077 MOV F.NRBD(R0),R3 ; SAVE LENGTH OF RECORD ; EB077 BEQ NXTREC ; IGNORE ZERO LENGTH RECORDS ; EB077 MOV F.NRBD+2(R0),R0 ; POINT AT FIRST BYTE OF RECORD ; EB077 CALL ISREC ; IS THIS RECORD A KEYWORD RECORD? ; EB077 BCS NXTREC ; NO, IGNORE THE RECORD ; EB077 TST MTCHAL ; IS IT THE ULTIMATE MATCH ; JGD10 BGT 20$ ; IF GT 0, YES ; JGD10 TST SYNFLG ; IS THIS A SYNONYM RECORD? ; JGD10 BGT 20$ ; YES, SO TREAT IT AS RECORD WITH SAME DEPTH ; JGD10 CMPB (R0),DEPTH ; COMPARE IT WITH USER KEYWORD LEVEL ; EB077 BHI NXTREC ; IT IS GREATER THAN DEPTH (C=0) ; EB077 20$: RETURN ; ; EB077 ; EB077 ;+ ; EB077 ; *** - COMPAR - COMPARE USER KEYWORD WITH HELP FILE KEYWORD ; EB077 ; ; EB077 ; INPUT: ; EB077 ; R0 - POINTS TO LEVEL (FIRST CHARACTER) OF HELP FILE KEYWORD ; EB077 ; RECORD ; EB077 ; R3 - LENGTH OF HELP FILE KEYWORD RECORD ; EB077 ; R4 - POINTS AT FIRST CHARACTER OF CURRENT USER KEYWORD ; EB077 ; ; EB077 ; OUTPUT: ; EB077 ; CARRY CLEAR - USER KEYWORD AND HELP FILE KEYWORD MATCH ; EB077 ; CARRY SET - USER KEYWORD AND HELP FILE KEYWORD DO NOT MATCH ; EB077 ; R3 - ADDRESS OF CHARACTER IN USER KEYWORD WHERE SCAN STOPPED ; EB077 ; R1, R4, R5 - PRESERVED ; EB077 ;- ; EB077 ; EB077 .ENABL LSB ; EB077 ; EB077 20$: CMP (SP)+,(SP)+ ; POP RETURN ADDR AND SAVED R4 ; EB077 MOV #ER10,R0 ; IMPROPER HELP FILE FORMAT ; EB077 CALL WRIT ; ; EB077 MOV #$ACTFL,R0 ; WRITE OUT THE OBJECTIONABLE LINE ; EB077 MOV F.NRBD(R0),R1 ; ; EB077 MOV F.NRBD+2(R0),R0 ; ; EB077 HLPERR: CALL WRIT2 ; ; EB077 CALL DETACH ; DETACH TI: AND SET ERROR STATUS ; EB077 JMP EXIT ; ; EB077 COMPAR: ; REFERENCE LABLE ; JGD10 TST MTCHAL ; IS IT A MATCHALL? ; JGD10 BGT 70$ ; IF GT 0, YES A PERFECT MATCH ; JGD10 MOV R4,-(SP) ; SAVE R4 ; EB077 30$: INC R0 ; POINT PAST RECORD LEVEL CHARACTER ; EB077 DEC R3 ; REDUCE COUNT OF CHARS LEFT IN RECORD ; EB077 BEQ 20$ ; NO MORE CHARACTERS ; EB077 CMPB #40,(R0) ; SKIP BLANKS AND TABS IN HELP FILE ; EB077 BEQ 30$ ; ; EB077 CMPB #11,(R0) ; ; EB077 BEQ 30$ ; ; EB077 CMPB #'$,(R0) ; IS FIRST NONBLANK CHAR OF RECORD ; EB077 ; KEYWORD A $? ; EB077 BEQ 35$ ; YES, IGNORE IT ; EB077 CMPB #'/,(R0) ; IS FIRST NONBLANK CHAR OF RECORD ; EB077 ; KEYWORD A /? ; EB077 BNE 40$ ; NO ; EB077 35$: INC R0 ; IGNORE THE $ OR / ; EB077 DEC R3 ; ANY CHARACTERS LEFT IN RECORD? ; EB077 BEQ 20$ ; NO, IMPROPER HELP FILE FORMAT ; EB077 40$: CMPB #'/,(R4) ; IS FIRST CHAR OF USER KEYWORD A /? ; EB077 BNE 45$ ; YES ; EB077 INC R4 ; NO, IGNORE THE / ; EB077 45$: CMPB (R0)+,(R4)+ ; ARE THE NEXT TWO CHARS THE SAME? ; EB077 BNE 50$ ; NO ; EB077 CALL TSTER1 ; SEEN ALL OF USER KEYWORD? ; EB077 BCC 60$ ; YES, DECLARE A MATCH ; EB077 DEC R3 ; ALL OF HELP FILE KEYWORD SEEN? ; EB077 BNE 45$ ; NO, KEEP TRYING ; EB077 50$: SEC ; SHOW NO MATCH ; EB077 60$: MOV R4,R3 ; SAVE HOW FAR WE GOT INTO USER KEYWORD ; EB077 MOV (SP)+,R4 ; RESTORE R4 ; EB077 70$: RETURN ; ; EB077 ; EB077 .DSABL LSB ; EB077 ; EB077 ;+ ; EB077 ; *** - TSTER1 - TEST IF A CHARACTER IS A TERMINATOR ; EB077 ; ; EB077 ; INPUT: ; EB077 ; R4 - ADDRESS OF CHARACTER TO BE TESTED ; EB077 ; ; EB077 ; OUTPUT: ; EB077 ; SAME AS TSTERM EXCEPT R2 IS DESTROYED ; EB077 ;- ; EB077 ; EB077 TSTER1: MOVB (R4),R2 ; GET CHARACTER TO TEST ; EB077 ; EB077 ;+ ; EB077 ; *** - TSTERM - TEST IF A CHARACTER IS A TERMINATOR ; EB077 ; ; EB077 ; INPUT: ; EB077 ; R2 - CHARACTER TO BE TESTED ; EB077 ; ; EB077 ; OUTPUT: ; EB077 ; CARRY CLEAR - R2 DOES CONTAIN A TERMINATOR ; EB077 ; CARRY SET - R2 DOES NOT CONTAIN A TERMINATOR ; EB077 ; R0, R1, R2, R3, R4, R5 - PRESERVED ; EB077 ;- ; EB077 ; EB077 TSTERM: CMPB #15,R2 ; R2 = CARRIAGE RETURN? ; EB077 BEQ 10$ ; YES, IT IS A TERMINATOR ; EB077 CMPB #40,R2 ; R2 = BLANK? ; EB077 BEQ 10$ ; YES, IT IS A TERMINATOR ; EB077 SEC ; SHOW NO TERMINATOR IN R2 ; EB077 10$: RETURN ; ; EB077 ; EB077 ;+ ; EB077 ; *** - MARK1 - MARK THE POSITION OF THE PART OF THE HELP FILE THAT ; EB077 ; MAY BE COPIED TO TI: (POINT RESTORES THESE VALUES) ; EB077 ; *** - MARK2 - TEMPORARILY MARK THE PRESENT HELP FILE POSITION ; EB077 ; ; EB077 ; INPUT: ; EB077 ; NONE ; EB077 ; ; EB077 ; OUTPUT: ; EB077 ; THE REGISTERS FROM A .MARK ARE STORED IN MARKSV ; EB077 ; R4 - PRESERVED ; EB077 ;- ; EB077 ; EB077 .ENABL LSB ; EB077 ; EB077 MARK1: MOV #MARKSV,R5 ; POINT AT THE SAVE BLOCK ; EB077 BR 10$ ; ; EB077 MARK2: MOV #3*2+MARKSV,R5 ; POINT AT THE SAVE BLOCK ; EB077 10$: MOV #$ACTFL,R0 ; MARK THE CURRENT FILE POSITION ; EB077 CALL .MARK ; ; EB077 MOV R1,(R5)+ ; SAVE THE REGISTERS ; EB077 MOV R2,(R5)+ ; ; EB077 MOV R3,(R5) ; ; EB077 RETURN ; ; EB077 ; EB077 .DSABL LSB ; EB077 ; EB077 ;+ ; EB077 ; *** - POINT - POINT AT THE FILE POSITION SAVED BY MARK1 ; EB077 ; ; EB077 ; INPUT: ; EB077 ; NONE ; EB077 ; ; EB077 ; OUTPUT: ; EB077 ; THE HELP FILE IS POSITIONED ACCORDING TO THE SAVED REGISTER ; EB077 ; VALUES IN MARKSV, MARKSV+2, MARKSV+4 ; EB077 ; R4, R5 - PRESERVED ; EB077 ;- ; EB077 ; EB077 .ENABL LSB ; EB077 ; EB077 POINT: MOV #MARKSV,R0 ; POINT AT THE REGISTER SAVE BLOCK ; EB077 MOV (R0)+,R1 ; RESTORE THE REGISTERS ; EB077 MOV (R0)+,R2 ; ; EB077 MOV (R0),R3 ; ; EB077 MOV #$ACTFL,R0 ; POINT AT FDB FOR HELP FILE ; EB077 CALL .POINT ; REPOSITION THE FILE ; EB077 20$: RETURN ; ; EB077 ; EB077 ;+ ; EB077 ; *** - PUSH - MOVE R4 PAST THE CURRENT USER KEYWORD ; EB077 ; ; EB077 ; INPUT: ; EB077 ; R4 - ADDRESS OF SOME CHARACTER IN CURRENT USER KEYWORD ; EB077 ; OR ADDRESS OF TERMINATOR OF CURRENT USER KEYWORD ; EB077 ; ; EB077 ; OUTPUT: ; EB077 ; R4 - ADDRESS OF FIRST TERMINATOR AFTER CURRENT USER KEYWORD ; EB077 ;- ; EB077 ; EB077 PUSH: CALL TSTER1 ; R4 POINTS AT A TERMINATOR? ; EB077 BCC 20$ ; YES ; EB077 INC R4 ; POINT AT NEXT CHARACTER ; EB077 BR PUSH ; ; EB077 ; EB077 .DSABL LSB ; EB077 ; EB077 ;+ ; EB077 ; *** - ISREC - IS THE CURRENT RECORD A KEYWORD RECORD (I.E., BEGINS ; EB077 ; WITH A DECIMAL DIGIT)? ; EB077 ; ; EB077 ; INPUT: ; EB077 ; R0 - ADDRESS OF FIRST CHARACTER OF CURRENT RECORD ; EB077 ; ; EB077 ; OUTPUT: ; EB077 ; CARRY CLEAR - THE CURRENT RECORD IS A KEYWORD RECORD ; EB077 ; CARRY SET - THE CURRENT RECORD IS NOT A KEYWORD RECORD ; EB077 ; R0, R1, R2, R3, R4, R5 - PRESERVED ; EB077 ;- ; EB077 ; EB077 ISREC: ; REF LABLE ; JGD10 CLR MTCHAL ; RESET MATCHALL FLAG ; JGD10 CLR SYNFLG ; RESET SYNONYM FLAG ; JGD10 CMPB (R0),#'$ ; IS IT A SYNONYM($ INSTEAD OF DIGIT) ; JGD10 BNE 5$ ; NO, LOOK FOR MATCHALL ; JGD10 INC SYNFLG ; YES, SET SYNONYM ; JGD10 BR 20$ ; AND RETURN WITH CARRY CLEAR ; JGD10 5$: CMPB (R0),#'# ; IS IT THE MATCHALL ; JGD10 BNE 10$ ; NO, LOOK FOR A DIGIT ; JGD10 INC MTCHALL ; SO SET FLAG TO SHOW IT MATCHES EVERYTHING ; JGD10 BR 20$ ; RETURN TO MAINLINE ; JGD10 10$: CMPB (R0),#'1 ; IS THE FIRST CHARACTER A DIGIT? ; EB077 BLO 20$ ; NO, CARRY IS SET ; EB077 CMPB #'9,(R0) ; IS THE FIRST CHARACTER A DIGIT? ; EB077 20$: RETURN ; ; EB077 .SBTTL MORE SUBROUTINES ;+ ;BLS010 ; *** - DATCHK - CHECK USER LAST LOGIN TIME AGAINST FILE ;BLS010 ; ;BLS010 ; INPUT: ;BLS010 ; FIRSTF CLEAR IF NOT FIRST LOGIN TODAY, SET OTHERWISE ;BLS010 ; TXTFLG CLEAR IF USER TYPED 'GRP,MEM', SET IF 'GRP/MEM' ;BLS010 ; $ACTFL FDB OF OPEN FILE TO DATE/TIME CHECK ;BLS010 ; ;BLS010 ; OUTPUT: ;BLS010 ; CC GO AHEAD AND PRINT THE FILE ;BLS010 ; CS DON'T PRINT--USER HAS SEEN IT AT LEAST ONCE ;BLS010 ;- ;BLS010 ;BLS010 DATCHK: TST FIRSTF ; TEST FIRST LOGIN TODAY FLAG ;BLS010 BNE 100$ ; IF NE MUST SEE THE FILE AT LEAST ONCE ;BLS010 ; TST TXTFLG ; SEE IF COMMA OR SLASH LOGIN ;BLS010; JGD ; BEQ 100$ ; IF EQ COMMA--TYPE THE FILE ;BLS010; JGD MOV #RATDPB,R4 ; SET UP TO READ ATTRIBUTES ;BLS010 CALL QIO ; READ 35 BYTES OF ATTRIBUTES ;BLS010 BCS 100$ ; IF ERROR TRY TO TYPE NOTICE ;BLS010 DECB IOSB ; CHECK FOR I/O ERRORS ;BLS010 BNE 100$ ; IF NE ERRORS--TRY TO TYPE FILE ;BLS010 MOV #RATBUF+15.,R2 ; POINT TO CREATION DATE/TIME ;BLS010 MOV #TDATBF,R3 ; AND TEMP BUFFER TO STORE INTO ;BLS010 CALL CVF11D ; CONVERT FILES-11 DATE ;BLS010 MOV #TDATBF+3,R1 ; POINT TO END OF CONVERTED DATE ;BLS010 CMPB TIMBUF+4,-(R1) ; CHECK FOR CREATION TODAY ;BLS010 BNE 90$ ; IF NOT TODAY HE'S ALREADY SEEN IT ;BLS010 CMPB TIMBUF+2,-(R1) ; ;BLS010 BNE 90$ ; ;BLS010 CMPB TIMBUF,-(R1) ; ;BLS010 BNE 90$ ;BLS010 MOV #RATBUF+22.,R2 ; POINT TO CREATION TIME ;BLS010 MOV #SAVLGT,R3 ; POINT TO SAVED LAST LOGIN TIME ;BLS010 CALL CV2DEC ; GET THE HOURS ;BLS010 CMPB R1,(R3)+ ; SEE IF MSG CHANGED LATELY ;BLS010 BNE 80$ ; IF NE SEE IF NEED TO TYPE ;BLS010 CALL CV2DEC ; GET A 2-DIGIT DECIMAL NUMBER (MIN) ;BLS010 CMPB R1,(R3)+ ; IS IT .GT. LAST LOGIN ELEMENT? ;BLS010 BNE 80$ ; IF NE GO SEE IF NEED TO TYPE ;BLS010 CALL CV2DEC ; GET SECONDS ;BLS010 CMPB R1,(R3)+ ; CHECK SECONDS ;BLS010 BGE 100$ ; IF GE SHOW FILE ;BLS010 BR 90$ ; IF LT DO NOT SHOW FILE ;BLS010 80$: BGT 100$ ; IF GT TYPE FILE ;BLS010 90$: SEC ; FLAG NOT TO TYPE FILE ;BLS010 RETURN ;BLS010 100$: CLC ; FLAG TO TYPE FILE ;BLS010 RETURN ;BLS010 ;BLS010 ;+ ;BLS010 ; *** CV2DEC - CONVERT 2 DECIMAL DIGITS ;BLS010 ; ;BLS010 ; INPUTS: ;BLS010 ; R2 POINTS TO INPUT ASCII STRING ;BLS010 ; ;BLS010 ; OUTPUT: ;BLS010 ; R1 CONTAINS CONVERTED DECIMAL NUMBER ;BLS010 ;- ;BLS010 ;BLS010 CV2DEC: MOVB (R2)+,R0 ; GET TENS DIGIT ;BLS010 SUB #'0,R0 ; TRIM TO 0-9 ;BLS010 MOV #10.,R1 ; SET MULTIPLIER ;BLS010 CALL $MUL ; MULT. BY TEN ;BLS010 MOVB (R2)+,R0 ; GET ONES DIGIT ;BLS010 SUB #'0,R0 ; TRIM TO RANGE ;BLS010 ADD R0,R1 ; FORM RESULT ;BLS010 RETURN ;BLS010 ;BLS010 ;+ ;BLS010 ; *** - CVF11D - CONVERT FILES-11 DATE STRING TO INTERNAL FORMAT ;BLS010 ; ;BLS010 ; THIS ROUTINE TAKES A CREATION DATE STRING FROM A FILE ;BLS010 ; HEADER AND CONVERTS IT INTO THE SAME FORMAT AS ;BLS010 ; RETURNED BY THE GTIM$ EXEC CALL (EXCEPT IN BYTES INSTEAD OF ;BLS010 ; WORDS). THERE IS NO SYNTAX CHECKING DONE. ;BLS010 ; ;BLS010 ; INPUTS: ;BLS010 ; R2 IS A POINTER TO THE ASCII DATE STRING ;BLS010 ; R3 IS A POINTER TO THE 3-BYTE BLOCK TO STORE RESULT ;BLS010 ; ;BLS010 ; OUTPUTS: ;BLS010 ; ;BLS010 ; R0-R3 ARE DESTROYED ;BLS010 ; THE BLOCK POINTED TO BY R3 ON ENTRY IS FILLED IN ;BLS010 ; ;BLS010 ;- ;BLS010 ;BLS010 CVF11D: ADD #3,R3 ; POINT TO END OF 3 BYTES ;BLS010 CALL CV2DEC ; GET THE DAY ;BLS010 MOVB R1,-(R3) ; STORE DAY ;BLS010 CALL CVBMON ; GET MONTH (1-12) ;BLS010 MOVB R1,-(R3) ; STORE MONTH ;BLS010 CALL CV2DEC ; GET YEAR ;BLS010 MOVB R1,-(R3) ; STORE IT ;BLS010 RETURN ;BLS010 ;BLS010 ;+ ;BLS010 ; *** - CVBMON - CONVERT ASCII MONTH STRING TO (1-12) ;BLS010 ; ;BLS010 ; INPUTS: ;BLS010 ; ;BLS010 ; R2 IS POINTING AT FIRST CHARACTER OF MONTH ;BLS010 ; ;BLS010 ; OUTPUTS: ;BLS010 ; ;BLS010 ; R2 IS UPDATED (UNLESS ERROR-THEN LOOSE BIG) ;BLS010 ; R1 HOLDS NUMBER OF MONTH (1-12) OR 0 IF ERROR ;BLS010 ; ;BLS010 ;- ;BLS010 ;BLS010 CVBMON: MOV #MONTAB,R1 ; ADDRESS MONT TABLE ;BLS010 MOV #1,-(SP) ; SET COUNT ON STACK ;BLS010 MOV R2,-(SP) ; SAVE R2 ALSO ;BLS010 20$: CMPB (R1)+,(R2)+ ; THE SAME? ;BLS010 BNE 40$ ; IF NE NO ;BLS010 TSTB (R1) ; YES--END OF MONTH? ;BLS010 BNE 20$ ; IF NE NO ;BLS010 TST (SP)+ ; YES--CLEAR OLD R2 ;BLS010 MOV (SP)+,R1 ; SET 1-12 IN R1 ;BLS010 RETURN ;BLS010 ;BLS010 40$: TSTB (R1)+ ; FIND END OF MONTH ;BLS010 BNE 40$ ; ENDS WITH A ZERO ;BLS010 MOV (SP),R2 ; RESET PTR ;BLS010 INC 2(SP) ; BUMP MONTH COUNTER ;BLS010 TSTB (R1) ; HAVE WE LOOKED AT ALL MONTHS? ;BLS010 BNE 20$ ; IF NE NO ;BLS010 CMP (SP)+,(SP)+ ; YES--CLEAR STACK ;BLS010 CLR R1 ; SAY NO MONTH ;BLS010 RETURN ;BLS010 ;BLS010 MONTAB: .ASCII /JAN/<0>/FEB/<0>/MAR/<0>/APR/<0>/MAY/<0>/JUN/<0> ;BLS010 .ASCII /JUL/<0>/AUG/<0>/SEP/<0>/OCT/<0>/NOV/<0>/DEC/<0><0> ;BLS010 .EVEN ;BLS010 ;+ ; *** - MAIL - CHECK FOR MAIL FOR THIS USER ;MRJ002 ; ; INPUT: ; MAIFIL - FILE NAME ENCODED AS GGGMMM.TXT ;MRJ002 ; ;MRJ002 ; THE PRESENCE OF MAIL IS INDICATED BY A FILE ;MRJ002 ; CONTAINING IT ON "MAIDEV"(LB1:) UNDER UIC ;MRJ002 ; "MAIDIR"([10,3]) ;MRJ002 ; ;MRJ002 ;- ;MRJ002 MAIL: FINIT$ ;MRJ002 CLR ODPB+Q.IOPL+4 ; SET CARRIAGE CONTROL ;MRJ002 MOV #MAIDSP,R1 ; SET UP MAIL FILE NAME TO LOOK FOR ;MRJ002 MOV #$ACTFL,R0 ; GET FDB ;MRJ002 OPEN$R R0,,R1,#0,#BUF,#80. ; TRY AND OPEN FILE FOR READ ;MRJ002 MOV F.ERR(R0),R0 ; SAVE ERROR ;MRJ002 BCS 1$ ; IF ERROR NO FILE ;MRJ002 MOV #MAIMSG,R0 ; GET READY TO PRINT MAIL AVAILABLE MESSAGE ;MRJ002 CALL WRIT ; AND PRINT IT ;MRJ002 1$: CLOSE$ #$ACTFL ; CLOSE FILE NO MATTER WHAT ;MRJ002 RETURN ;MRJ002 .END $HELEP