.TITLE CCL .IDENT /V5.1/ .SBTTL INTRODUCTION ;+ ; JAMES G. DOWNWARD ; KMS FUSION, INC ; 3941 RESEARCH PARK DR. ; ANN ARBOR, MICH ; 313-769-8500 ; ; THIS PROGRAM IS THE COMPOSIT OF TWO PROGRAMS. ONE PART USES A LIST OF PRE- ; DEFINED COMMANDS(LIST, TYPE, DELETE...ETC.) AND TURNS THEM INTO MCR COMMANDS ; TO THE UTILITIES. THIS PART WAS PATERNED AFTER DEC'S TDX OR CATCHALL TASK. ; IT IS INCLUDED IN THE SECTION 'DCL' WHICH COMPRISES THE LATER PART OF CCL.MAC. ; THE SECOND PART OF THE PROGRAM CONSISTS OF CODE TO OPEN A FILE ; (USERCCL.CCL OR SYSCCL.CCL) AND SEE IF THE COMMAND ENTERED CORRESPONDS ; TO A COMMAND ENTERED IN THE FILE. FIRST THE FILE USERCCL.CCL ; ON THE USER'S UIC AND SY: IS TRIED. IF EITHER THE FILE DOES NOT EXIST ; OR THE COMMAND IS NOT FOUND, THE SCAN IS REPEATED USING SYSCCL.CCL. ; THE PROGRAM LOGIC IS SOMEWHAT TANGLED SINCE THIS IS A MELANGE OF ; VARIOUS PROGRAMING STYLES, EDITS, AND CONVERSIONS FROM F4P. WITHOUT ; A SINGLE DOUBT, IT SHOULD BE REWRITTEN INTO A SINGLE COHERENT ; PROGRAM. THE PROGRAM STARTS OUT BY SEEING IF IT GOT A VALID ; COMMAND LINE FROM MCR. IF IT DID, IT CALLS THE DCL SUBROUTINE ; WHICH CHECKS TO SEE IF IT MATCHES THE COMMAND IN THE COMMAND TABLE. ; NOTE THAT IF THE FIRST THREE LETTERS MATCH, DCL ASSUMES IT IS A MATCH, ; AND WILL FIELD THE COMMAND, SO COMMANDS WHICH HAVE THE FIRST THREE ; LETTERS MATCHING IN A .CCL FILE WILL DO NO GOOD AT ALL. IF A MATCH IS ; FOUND THE COMMAND IS SPAWNED TO MCR, AND ...CA. WILL STOP ITSELF UNTIL ; THE COMMAND IS EXECUTED AND THEN WILL EXIT WITH THE APPROPRIATE STATUS. ; IF DCL DOES NOT FIND THE COMMAND A DIRECT RETURN IS MADE TO CCL ; WHICH PROCEEDS TO OPEN THE .CCL FILES, AND SEARCH FOR A COMMAND WHICH ; MATCHES UP TO THE FIRST 9 LETTERS. IF A MATCH IS FOUND, THE PROTOTYPE ; COMMAND LINE IN THE FILE IS DECODED, FLESHED OUT, AND SPAWNED TO MCR. ; IF THE COMMAND PROTOTYPE ENDS WITH A %$% (SIGNIFYING ESC) THE CCL WILL EXIT ; WITHOUT WAITING FOR THE MCR COMMAND TO FINISH EXECUTING. OTHERWISE CCL WILL ; HANG AROUND UNTIL THE COMMAND SPAWNED TO MCR HAS FINISHED. ;- .SBTTL THE ORIGIONAL CCL ; R. J. KIRKMAN ; this program is converted from a fortran 4 plus assembly listing ; and therefore I apologise for the wierd names involved ; ; The main routine also requires GETMCR from F4POTS, PUTMCR, LOOKUP & FIXUP ; ; MODIFIED BY: ; 15-MAR-79 J. DOWNWARD ADD VARIOUS ERROR MESSAGES, TEST FOR ; LINES TOO LONG, AND FOR SPEED BUILD IN ; ALL KINDS OF DCL-LIKE COMMANDS. ; (EG. LIST, DIR, SPOOL, TRUNCATE, ; PURGE, DELETE., ETC.) ; ; 24-SEP-79 J. DOWNWARD ADD %U,'G%,%G,%T TO DECODED VARIABLES ; ADD MULTIPLE LINE CCL COMMANDS AND ABILITY ; FOR CCL TO WAIT FOR A SPECIFIC TASK ; TO EXIT ; .MCALL GET$,OPEN$R,FDBDF$,FDRC$A,CLOSE$,EXIT$S,QIOW$S .MCALL FDOP$A,FSRSZ$,DIR$,EXST$S,GTSK$S,GLUN$ .MCALL QIOW$C,CNCT$,STSE$S,CLEF$S F0=%0 F1=%1 F2=%2 F3=%3 F4=%4 F5=%5 ; the program reads inturn the user file SY:USERCCL.CCL ; and then the system file (SY:) SYSCCL.CCL in a specific directory ; LUN 1 IS used for the files and lun 2 for error reporting and ; for asking for parameters FSRSZ$ 1 ; ONE FILE ONLY! ; note this was fortran common - this is shared by ALL routines .PSECT .$$$$.,rw,d,con,ovr,gbl PARAMS: .WORD 0 ;max # params to prompt for MCRL: .WORD 0 ;length of mcr line KEYL: .WORD 0 ;length of keyword MCR: .BLKB 80. ;mcr buffer as input KEYB: .ASCII / / ;initial state of keyword buffer P: .BLKB 416 ;30.*9. 9 parameters @ 30. chars @ CMD: .BLKB 80. ;output new command line PMIN: .WORD 0 ;min # params to accept EXSTAT: .WORD 1 ; ASSUME SUCESSFUL EXIT DUIC: .WORD 0 ; FOR TERMINAL UIC ; JGD03 GLBUF: .BLKB 12. ; FOR TERMINAL UNIT ; JGD03 .BLKW 7 ; TO COMPLETE THE REST OF EXIT STATUS BLOCK .PSECT $VARS,RW,D,CON,LCL ; ; ERROR MESSAGES AND PROMPTS ; STATUS: .BLKW 8. ; FOR EXIT STATUS ; JGD03 SAVTYP: .WORD 0 ; SAVE DATA TYPE ; JGD03 MSG1: .ASCIZ <15><12>/>/ MSG2: .ASCIZ <15><12>/...CCL -- ERROR READING SYSTEM FILE/<15><12>/>/; JGD01 MSG3: .ASCIZ <15><12>/...CCL -- NO COMMAND LINE !/<15><12>/>/ ; JGD01 MSG4: .ASCII <15><12>/? ?/<15><12> ; JGD01 .ASCIZ /CCL -- MCR SYNTAX ERROR OR UNKNOWN COMMAND/<15><12>/>/ MSG5: .ASCIZ <15><12>/CCL -- CCL COMMAND TOO LONG/<15><12> ; JGD02 MSG6: .ASCIZ <15><12>/CCL -- SPAWN FAILURE TO MCR/<15><12>/>/ EM2: .ASCIZ <15><12>/CCL -- COMMAND LINE TOO LONG/<15><12>/>/ EM3: .ASCIZ <15><12>/CCL -- SYNTAX ERROR/<15><12>/>/ EM4: .ASCII <15><12>/CCL -- TASK / ; JGD03 TSKNAM: .ASCII /XXXXXX/ ; JGD03 .ASCIZ / NOT ACTIVE OR NOT FOUND/<15><12>/>/ ; JGD03 LBDEV: .ascii /LB:/ ;dev for system file SYDEV: .ASCII /SY:/ ;dev for userccl file SYUIC: .ASCII /[1,5]/ ;uic for my system file SYFIL: .ASCII /SYSCCL.CCL/ ;name of my system file USRFIL: .ASCII /USERCCL.CCL/ ;name of users files .EVEN $LNGFL: .WORD -1 ; CLEARED ON COMMAND NOT TOO LONG NOBYTE: .WORD 0 ; INCREMENT IF NOT DIR COMMAND AND NO SPACES ; FOLLOW COMMAND CMDNAM: .WORD 0 ; TO KEEP TRACK OF COMMAND NAME ; ; PIP COMMANDS FOR DIR,LIST, DELETE, SPOOL, PURGE, TRUNCATE, UNLOCK ; TYPMSG: .ASCIZ /PIP TI:=/ PIPHD: .ASCIZ /PIP / DELMSG: .ASCIZ \/DE\ DIRMSG: .ASCIZ \/LI\ PURMSG: .ASCIZ \/PU\ SPOMSG: .ASCIZ \/SP\ TRUMSG: .ASCIZ \/TR\ SORMSG: .ASCIZ \SRD \ CREMSG: .ASCIZ \=TI:\ FREMSG: .ASCIZ \/FR\ .EVEN ; fdb for out ccl spec file FDB:: FDBDF$ FDRC$A ,INBF,80. FDOP$A 1,,,FO.RD!FA.SHR ; input buffer for spec lines INBF:: .BLKB 80. FIXPRM: .WORD 2,I,J ;prl for calls of fixup INUIC: .WORD 0 L: .WORD 0 K: .WORD 0 J: .WORD 0 I: .WORD 0 N120: .WORD 117 ; ONLY 79 BYTES IN BUFFER PMCR: .WORD 2,N120,CMD ;prl for calls of PUTMCR QNMRK: .ASCII /? / ;buffer for error text $TEMPS: .WORD 0 SYSDST: .WORD 3,LBDEV,5,SYUIC,10.,SYFIL USRDST: .WORD 3,SYDEV,,,11.,USRFIL GTBUF: .BLKW 20 GLUN: GLUN$ 2,GLBUF CNCT: CNCT$ XX,4,,STATUS ; CONNECT TO TASK ; ; .PSECT $CODE1,RW,I,CON,LCL ; startup point for program ; get our startup command line CCL: GTSK$S #GTBUF ; GET OUR TASK PARAMETERS ; JGD DIR$ #GLUN ; GET OUR TERMINAL LUN INFORMATION ; JGD MOV GTBUF+14.,DUIC ; GET OUT DEFAULT UIC ; JGD MOV (PC)+,R1 .BYTE 127.,41. ; SETTING UP FOR DIR$ GMCR MOV R1,KEYL ; DIR$ #KEYL MOV @#$DSW,MCRL CLR KEYL ;was there any command line TST MCRL BGT .1000 ;here if there wasnt type 'NO COMMNAD LINE ' & exit MOV #MSG3,R0 JMP EREXIT ; GO WRITE OUT ERROR AND EXIT ; JSR PC,MSG ; back in mainline ; and with real command line ; Search for spaces or CR, ie end of keyword .1000: CALL DCL ; IS IT A BUILT-IN COMMAND ; WE GET A RETURN ONLY IF BUILT IN COMMAND NOT FOUND MOV #1,R0 L$HAPL: CMPB MCR-1(R0),#40 ; IS IT A SPACE OR CONTROL CHAR(CR, ESC, ETC) BLE .1002 ;store in keyword buffer and in error print buffer ; as we loop MOVB MCR-1(R0),MSG4+2(R0) ; 0018 MOVB MCR-1(R0),KEYB-1(R0) INC R0 CMP R0,#10 BLE L$HAPL ; LOOP IF NOT GOT 8 CHAR YET 10$: CMPB MCR-1(R0),#40 ; COMMAND 8 CHAR OR MORE LONG, FIND SPACE OR CR BLE .1002 ; GOT IT INC R0 ; BUMP US UP ONE CHAR BR 10$ ; LOOP TILL WE GET IT ; got to end of keyword or 8 chars which is enough for most people .1002: DEC R0 MOV R0,KEYL ; store correct keyword length .1003: ;now try for user file, if not found go 7$ to try system file MOV #7$,R2 MOV #USRDST,R1 JSR PC,OPEN ; found a user file , lookup the keyword in there JSR PC,LOOKUP TST R0 BMI .1005 ; -ve is fortran success so we found the keyword go 1005 ; in line if we didnt , close this file, then try ; the system file CALL CLOS 7$: ; back with was no userfile as well ; error message must appear if no system file MOV #OPNFL,R2 MOV #SYSDST,R1 JSR PC,OPEN JSR PC,LOOKUP TST R0 BMI .1005 ; if found in system file deal in exactly same way as user file ;.if not then close file and check was last char of keyword ; a "?" in which case see if "? name" is defined, cheats and uses ; error message buffer CALL CLOS MOV KEYL,R0 CMPB KEYB-1(R0),#77 ; deal with "?" BEQ .1010 MOV #MSG4,R0 JMP ERROR ; above deal with unknown keyword go print "?NAME" ; here lookup error message on both files as a type of help request .1010: MOVB #40,MCR-1(R0) MOV #-1,KEYL ; use fpp to move 8 chars for us ( sorry its fortran!) SETD LDD QNMRK,F0 STD F0,KEYB BR .1003 ; here on being given a valid keyword found in file ; params,pmin are set up ; say at start of line for parameter 1 char 1 and not in a uic spec .1005: CLR INUIC MOV #1,J MOV #1,L MOV #1,I ; set all parameter strings empty ( clear 1st byte of each) L$EBIF: MOV I,R1 MUL #36,R1 CLRB P-36(R1) INC I CMP I,#11 BLE L$EBIF ; is it keyword alone , if so go to are there enough params MOV KEYL,R0 INC R0 CMP R0,MCRL BGE .2008 ; start after keyword +1 char MOV KEYL,R0 ADD #2,R0 MOV R0,I MOV MCRL,R0 INC R0 MOV R0,$TEMPS L$EBOH: ; if next character is "[" set INUIC MOV I,R0 CMPB MCR-1(R0),#133 BNE L$EBLJ MOV #-1,INUIC L$EBLJ: ; if it is "]" set not in uic CMPB MCR-1(R0),#135 BNE L$EBBK CLR INUIC L$EBBK: ; is character ' ', '=' or '<' '<-' or ',' ( allowed separators) ; if ',' then check if in uic CMPB MCR-1(R0),#40 BLE L$JBGH CMPB MCR-1(R0),#75 BEQ L$JBGH CMPB MCR-1(R0),#74 BEQ L$JBGH CMPB MCR-1(R0),#137 BEQ L$JBGH CMPB MCR-1(R0),#54 BNE L$EBHK TST INUIC BMI L$EBHK L$JBGH: ; here it is a separator set up next param BR .2002 L$EBHK: ; here char is not a separator, stuff in parameter MOV L,R1 MUL #36,R1 ADD J,R1 MOVB MCR-1(R0),P-37(R1) INC J ; go back for more BR .2001 .2002: ; here with a separator ; insert a null and add 1 to parameter # (in L) ; check I ( text pointer) still in mcr line text MOV L,R1 MUL #36,R1 ADD J,R1 CLRB P-37(R1) MOV #1,J INC L ; check if still in the line .2001: INC I CMP I,$TEMPS BLE L$EBOH .2008: ; check have we enough for min params yet? DEC L CMP L,PMIN BGE .2010 ; if yes skip asking for more .2009: ; have we the max asked for if so no more to do CMP PARAMS,L BLE .2010 .2004: ; get a parameter line ?n text ; give syserr message if not found since he guaranteed it GET$ #FDB BCC 1$ JMP OPNFL 1$: ; 0064 CMPB INBF,#77 ; ; if it doesnt start ? then its anither keyword line, go and try ; again for more BNE .2004 CALL PRMPT ; get a parameter in response BR .2009 .2010: ; here with sufficient parameters ; get an action or skeleton line ; which begins "*" MOV L,PARAMS ; 0076 .NCMD: ; COME BACK HERE IF MULTI LINE CCL COMMAND GET$ #FDB CMPB INBF,#'- ; IS IT A COMMAND TO WAIT FOR TASK TO EXIT? BNE 1$ ; IF NE , NO CALL WAITCK ; IF EQ, YES, STOP UNTIL IT EXITS BR .NCMD ; AND GET ANOTHER COMMAND 1$: CMPB INBF,#'+ ; IS IT A CONTINUATION LINE BEQ 2$ ; YES, CMPB INBF,#'* ; IS IT THE FINAL COMMAND BNE .NCMD ; NO, MUST BE GARBAGE, SKIP OVER 2$: MOVB INBF,SAVTYP ; SAVE THE COMMAND TYPE MOV #120,R0 MOV #CMD,R2 MOV #MCR,R1 ; clear out work buffers 11$: MOVB #' ,(R1)+ MOVB #' ,(R2)+ SOB R0,11$ MOV FDB+F.NRBD,R0 DEC R0 MOV #INBF+1,R1 MOV #MCR,R2 ; copy skeleton into old MCR buffer 12$: MOVB (R1)+,(R2)+ SOB R0,12$ ; CALL CLOS ; we have now finished with all files MOV #1,I MOV #1,J .2030: ; scan skeleton transferring files, when hits "%" call fixup MOV I,R0 CMPB MCR-1(R0),#45 BEQ .2031 MOV J,R1 MOVB MCR-1(R0),CMD-1(R1) INC I INC J BR .2032 .2031: MOV #FIXPRM,R5 JSR PC,FIXUP .2032: ; done our 80 byte line CMP I,#120 BGE L$JBEG CMP J,#117 BLT .2030 ; run out of one or other buffer L$JBEG: CMPB #40,CMD+111 ; SHOULD BE A SPACE, ELSE COMMAND TOO LONG BNE TOLONG ; ; add a CR to end of buffer and send it MOV #PMCR,R5 JSR PC,PUTMCR BCC ENDDUP ; ANY ERRORS MOV #MSG6,R0 ; WARN USER SPAWN FAILED JMP ERROR ; EXIT WITH ERROR ENDDUP: CLR NOSTOP ; RESET THIS IN CASE NEEDED NEXT TIME ; JGD03 CMP #1,R0 ; IS IT SUCCESS ; JGD03 BNE EREXIT ; IF NE, ERROR - BAD STATUS ; JGD03 CMPB SAVTYP,#'* ; IS THIS THE FINAL COMMAND? ; JGD03 BEQ FINISH ; FINISH UP AND EXIT ; JGD03 JMP .NCMD ; MORE COMMANDS COMMING ; JGD03 ; here when user types ctrl/Z for a prompt response as abort .4000: MOV #MSG1,R0 CALL ERROR ; EXIT WITH SEVERE ERROR MSG: CALL TYPEIT ; FINISH: MOV R0,EXSTAT ; CALL CLOS ; CLOSE FILE EXST$S EXSTAT ; EXIT AND SHOW SUCCESS EXIT$S ; IF EXIT WITH STATUS FAILS, TRY EXIT TOLONG: MOV R0,EXSTAT ; MOV #MSG5,R0 ; WARNING MESSAGE CALL TYPEIT MOVB #0,CMD+116 ; WRITE OUT COMMAND CAUSING PROBLEM MOV #CMD,R0 ; WRITE OUT THE TRUNCATED COMMAND CALL TYPEIT ; WRITE IT OUT MOV #MSG1,R0 ; FINISH UP WITH CR,LF, > ERROR: CALL TYPEIT ; CALL CLOS ; EREXIT: EXST$S EXSTAT ; EXIT WITH SEVERE ERROR EXIT$S ; IF EXIT WITH STATUS FAILS TRY THIS ;+ ; ; DCL ; THIS SUBROUTINE IMPLEMENTS THE FOLLOWING COMMANDS AS THOUGH THEY WERE ; PART OF MCR: ; ; BEL[L] Ring terminal bell. ; PAG[E] Erase screen on VT100/TEK 4014 ; ERA[SE] Erase screen of VT52 ; HOL[D] SET /HOLD =TI: ; NOH[OLD] SET /NOHOLD =TI: ; SCR[OLL] Set VT100 to slow scroll. ; NOS[CROLL] Set VT100 to normal mode. ; LIS[T] FILESPEC,FILESPEC,.... List files at user's TI: ; TYP[E] FILESPEC,FILESPEC,.... Type files at user's TI: ; DEL[ETE] FILESPEC,FILESPEC,... Delete the specified files ; DIR[ECTORY] FILESPEC,FILESPEC,... Display a directory listing ; PUR[GE] FILESPEC, FILESPEC,.... Purge a directory of files ; SPO[OL] FILESPEC,FILESPEC,... Send files to line printer ; TRU[NCATE] FILESPEC,FILESPEC,.... Truncate list of files ; FRE[E] DDn: Display free blocks on DDn: ; SOR[T] filespec/switches SRD [filespec/switches]/LI ; CREATE FILENAME PIP filename=TI: ; POOL SET /POOL ; UIC ={ grp, mem} SET OR DISPLAY UIC ; CHD SET OR DISPLAY UIC ; ATS or ATS TI: List all active tasks or only those on TI: ; SHQ Show full spool queue ; SHW Show spool queue waiting list ; DLG Display logged in terminals ; SYS Show current System UIC ; DLY NNNU Delay 'NNN' U units of time ; HEY taskname Connect to task and notify when exits ; ; ; THE SYNTAX OF MOST OF THE COMMANDS IS: ; ; COMMAND [FILES] ; ; THE DIRECTORY COMMAND MAY BE MODIFIED BY USING THE SWITCHES ; "/BR", OR "/FU" ; .SBTTL DCL PROCESS DCL-LIKE PIP COMMANDS .MACRO MVZ,RA,RB,?A,?B ; MOVE ASCIZ STRING WITHOUT TRAILING ZERO A: TSTB (RA) BEQ B MOVB (RA)+,(RB)+ BR A B: .ENDM EFN1=1 EF1=1 EF2=2 LUN2=2 ; LUN FOR TI: SPA=40 ESC=33 CR=15 BELL=7 .MCALL STSE$S,QIOW$,SPWN$S,MRKT$S,DIR$,SPWN$ .MCALL CNCT$ CNNECT: CNCT$ ,EF1,,EXTBLK QIOW: QIOW$ IO.WVB,5,31,,,,<0,0,40> QIO: QIOW$ IO.WVB,LUN2,EF2,,ISB,, SPWN: SPWN$ MCR...,,,,,1 ;SPWN: SPWN$ ...MCR,,,,,1 ; ; ERROR MESSAGES ; .NLIST BEX EMM2: .ASCII /MCR -- TASK NOT IN SYSTEM/ EMM2L=.-EMM2 EMM3: .ASCII /MCR -- SYNTAX ERROR/ EMM3L=.-EMM3 EMM4: .ASCII /CCL -- COMMAND PARSING ERROR AFTER PIP:/ EMM4L=.-EMM4 .LIST BEX ; ; STRING MESSAGES (USED IN SPAWNED COMMANDS) ; .EVEN CMDTBL: .RAD50 /DIR/ ; LIST DIRECTORY ON TI: .RAD50 /PUR/ ; PURGE DIRECTORY .RAD50 /SPO/ ; SPOOL FILES VIA PIP /SP .RAD50 /FRE/ ; DISPLAY NUMBER OF FREE BLOCKS ON SY: .RAD50 /DEL/ ; DELETE FILE(S) .RAD50 /TYP/ ; TYPE FILE(S) ON TI: .RAD50 /LIS/ ; .RAD50 /CRE/ ; CREATE A FILE AND ENTER TEXT INTO IT .RAD50 /TRU/ ; TRUNCATE A FILE[S] .RAD50 /SOR/ ; SORT/BRIEF LISTING .RAD50 /CHD/ ; CHANGE DEFAULT DIRECTORY .RAD50 /UIC/ ; " " " .RAD50 /ATS/ ; LIST ACTIVE TASKS .RAD50 /SHQ/ ; SHOW PRINT AND BATCH QUEUES IN FULL FORMAT .RAD50 /SHW/ ; SHOW PRINT AND BATCH QUEUES IN SHORT FORMAT .RAD50 /DLG/ ; DISPLAY LOGGED IN TERMINALS ON TI: .RAD50 /POO/ ; DISPLAY THE CURRENT AMOUNT OF POOL .RAD50 /SYS/ ; DISPLAY CURRENT SYSTEM UIC .RAD50 /DLY/ ; DELAY .RAD50 /HEY/ ; NOTIFY TERMINAL OF SPECIFIED TASK EXIT .RAD50 /BEL/ ; RING TERMINAL BELL .RAD50 /PAG/ ; ERASE TERMINAL SCREEN OF VT100/TEK 4014 .RAD50 /ERA/ ; ERASE TERMINAL SCREEN OF VT52 .RAD50 /SCR/ ; SET VT100 TO SCROOL MODE .RAD50 /NOS/ ; SET VT100 TO NOSCROLL MODE .RAD50 /HOL/ ; SET /HOLD=TI: .RAD50 /NOH/ ; SET /NOHOLD=TI: ENDCMD: ; END OF COMMAND TABLE JMPTBL: .WORD PIP ; .WORD PIP ; USE ALSO FOR PURGE .WORD PIP ; USE ALSO FOR SPOOL .WORD PIP ; USE ALSO FOR 'FREE' .WORD PIP ; USE ALSO FOR DELETE ENTRY POINT .WORD PIP ; USE FOR TYPE .WORD PIP ; USE FOR LIST .WORD PIP ; USE PIP FOR CREATE .WORD PIP ; USE PIP FOR TRUNCATE .WORD SRD ; USE CODE TEMPLATE FOR SRD /LI .WORD CHD ; .WORD CHD ; .WORD ATS ; .WORD SHQ ; .WORD SHW ; .WORD DLG ; .WORD POO ; .WORD SYS ; .WORD DLY ; .WORD HEY ; .WORD BELEP ; RING TERMINAL BELL .WORD PAGE ; ERASE TERMINAL SCREEN .WORD ERASE ; ERASE VT52 TERMINAL SCREEN .WORD SCROLL ; SET VT100 TO SCROLL MODE .WORD NSCROLL ; SET VT100 TO NORMAL MODE .WORD HOLD ; SET /HOLD =TI: .WORD NOHOLD ; SET /NOHOLD=TI: MCRBUF: .BLKW 40 ; BUFFER TO BUILD COMMAND LINE .BLKW 10 ; SOMETHING VERY STRANGE HAPPENS HERE ; NOTHING I CAN SEE SHOULD EVER OVERWRITE MCRBUF(INTO MCRNM) ; BECAUSE A CHECK IS MADE TO SEE IF LINE >78. CHARACTERS. ; HOWEVER, IF FIRST ATTEMPT IS TO SPAWN TO MCR... AND THE ; SECOND ATTEMPT IS TO ...MCR, MCRNM GETS OVERWRITTEN BUT ; ONLY ON LONG COMMAND LINES.(IE BUFFER OVERWRITTEN). ; AN ALMOST PAINLESS FIX IS TO INSERT A 10 WORD BUFFER BETWEEN ; MCRBUF AND MCRNM. LATER IN V3.2 ALL THIS CODE CAN BE ; REMOVED SINCE ONLY WILL SPAWN TO MCR...(HOWEVER BUFFER WILL ; STILL BE OVERWRITTEN. ; TO SEND TO MCR MCRNM: .RAD50 /...MCR/ ; DISPATCHER NAME .EVEN .PAGE .SBTTL COMPRESS COMMAND LINE ; GET THE COMMAND LINE FROM MCR AND PEEL OFF THE COMMAND FROM IT. ; THE COMMAND IS DEFINED AS THE FIRST N CHARACTERS OF THE LINE UP TO ; BUT NOT INCLUDING THE FIRST NON ALPHANUMERIC DCL: ; REF LABLE MOV #MCRBUF,SPWN+S.PWCA ; SET BUFFER ADDRESS IN NORMAL SPWN DPB MOV #EXSTAT,SPWN+S.PWES ; AND EXIT STATUS BLOCK ADDRESS MOV #MCR,R0 ; START OF MCR COMMAND BUFFER CLR R1 ; CONTROL FOR $CAT5(DO NOT DECODE DOTS) CALL $CAT5 ; CONVERT RAD50 TO ASCII(R1 CONTAINS COMMAND NAME) MOV #MCR,R0 ; GET START OF COMMAND BUFFER AGAIN MOV R0,R2 ; FOR COMPRESSION MOV R0,R5 ; POINTS TO REST OF COMMAND LINE MOV #CMDTBL,R4 ; SEARCH THE COMMAND TABLE FOR A MATCH MOV R1,CMDNAM ; SAVE CMDNAME FOR LATER 10$: CMP R1,(R4)+ ; SEE IF ITS A MATCH BEQ 20$ ; GOT IT CMP R4,#ENDCMD ; ARE WE AT END OF TABLE? BLO 10$ ; IF LO , NO, TRY AGAIN RETURN ; GO AND TRY THE .CCL FILE FOR A MATCH 20$: ; REF LABLE MOV R2,R0 ; RESTORE R0 ; FIND WHERE COMMAND ENDS ; THE TYPICAL COMMAND WILL LOOK AS FOLLOWS ; ; THE CMDNAME MAY BE MORE THAN THREE CHARACTERS LONG, BUT ONLY THE FIRST ; THREE WERE TESTED AGAINST THE JUMP TABLE(THIS IS CONSISTANT WITH MCR) ; A SPACE SEPERATED THE CMD NAME FROM ANY COMMAND QUALIFIER STRING PARSE: CMPB (R0),#' ; IS IT A SPACE? BEQ REPACK ; IF EQ, YES, GO REPACK BUFFER CMPB (R0),#33 ; IS IT AN ? BEQ REPACK ; IF EQ,YES CMPB (R0),#15 ; IS IT A BEQ REPACK ; IF EQ, YES INC R0 ; ELSE INCREMENT COUNTER BR PARSE ; AND CHECK NEXT CHARACTER REPACK: MOVB (R0),(R2)+ ; MOVE IN FIRST BYTE CMPB (R0),#33 ; IS IT BEQ OUT ; IF EQ, YES CMPB (R0),#15 ; IS IT BEQ OUT ; IF EQ, YES INC R0 ; INCREMENT COUNTER BR REPACK ; PACK NEXT CHARACTER OUT: CLRB (R2) ; LEAVE A NULL BYTE TO SIGNIFY END OF BUFFER ; AT THIS POINT THE COMMAND LINE APPEARS AS FOLLOWS. ; THE COMMAND NAME HAS BEEN REMOVED FROM THE COMMAND BUFFER . ; NOTE HOWEVER, THAT THE FIRST CHARACTER OF THE COMPRESSED BUFFER ; MAY BE A SPACE. THE LINE ENDS WITH EITHER A OR ; DEPENDING ON WHICH KEY TERMINATED THE READ. A ZERO BYTE FOLLOWS THIS ; IN ORDER TO SIMPLIFY CHECKING FOR EOL ; ; R5 POINTS TO THE START OF THE COMMAND BUFFER MOV R4,R0 ; RESTORE R0 MOV #MCRBUF,R1 ; GET SPAWN BUFFER TSTB 1(R5) ; ANY FILES FOLLOW COMMAND? BNE 25$ ; IF NE, YES INC NOBYTE ; SHOW NO DATA FOR LATER 25$: JMP @JMPTBL-CMDTBL-2(R0) ; YOU CAN TELL THIS LINE WAS BENN'S .PAGE .EVEN .ENABLE LSB ERR2: MOV #EMM2,QIOW+Q.IOPL ; ADDRESS OF ERROR MESSAGE MOV #EMM2L,QIOW+Q.IOPL+2 ; LENGTH OF COMMAND BR 10$ ERR3: MOV #EMM3,QIOW+Q.IOPL MOV #EMM3L,QIOW+Q.IOPL+2 BR 10$ ERR4: MOV #EMM4,QIOW+Q.IOPL MOV #EMM4L,Q.IOPL+2 BR 10$ 10$: DIR$ #QIOW EXST$S #EX$ERR .DSABLE LSB .PAGE .SBTTL PIP -LIKE COMMANDS ; DIR,SPOOL,DELETE,TRUNCATE,FREE,PURGE,CREATE, ..ETC. ALL PROCESSED HERE .EVEN SRD: MOV #SORMSG,R0 ; MOVE IN SRD MOV #^RDIR,CMDNAM ; PRETEND THIS IS DIRECTORY COMMAND BR COMON ; BRANCH THROUGH COMMON CODE PIP: CMP CMDNAM,#^RTYP ; IS IT TYPE COMMAND BEQ 1$ ; IF EQ YES 101$: CMP CMDNAM,#^RLIS ; PERHAPS LIST? BNE 2$ ; IF NE, NO 1$: TST NOBYTE ; ANY FILES TO LIST BNE XIT ; IF NE, NO FILES PRESENT MOV #TYPMSG,R0 ; ELSE POINT TO START OF COMMAND BR COMON ; AND SKIP OVER 2$: MOV #PIPHD,R0 ; FIRST PART OF SPAWN COMMAND COMON: ; MVZ R0,R1 ; MOV ASCIZ STRING TO SPAWN BUFFER MVZ R5,R1 ; MOV REST OF COMMAND UP TO ZERO DEC R1 ; BUMP OFF TERMINATING CMP CMDNAM,#^RPUR ; IS IT PURGE BNE 5$ ; IF NE NO TST NOBYTE ; ARE ANY FILES PRESENT BNE XIT ; IF NE, NO, SYNTAX ERROR MOV #PURMSG,R0 ; MOVE IN SECOND HALF OF LINE BR DOIT ; 5$: CMP CMDNAM,#^RDIR ; IS IT DIRECTORY BNE 10$ ; IF NE, NO MOV #DIRMSG,R0 ; MOV IN SECOND HALF OF NAME BR DOIT ; 10$: CMP CMDNAM,#^RSPO ; IS IT SPOOL? BNE 15$ ; IF NE, NO TST NOBYTE ; ARE ANY FILES PRESENT BNE XIT ; IF NE, NO , SYNTAX ERROR MOV #SPOMSG,R0 ; MOVE IN /SP BR DOIT ; GO DO IT 15$: CMP CMDNAM,#^RFRE ; IS IT /FR COMMAND BNE 20$ ; IF NE, NO MOV #FREMSG,R0 ; MOVE INSECOND HALF OF NAME BR DOIT ; GO ISSUE COMMAND 20$: CMP CMDNAM,#^RDEL ; IS IT DELETE? BNE 25$ ; IF NE,NO TST NOBYTE ; ANY FILES PRESENT? BNE XIT ; IF NE, NO, SYNTAX ERROR MOV #DELMSG,R0 ; MOVE IN SECOND HALF OF COMMAND BR DOIT ; GO ISSUE COMMAND 25$: CMP CMDNAM,#^RCRE ; IS IT CREATE? BNE 30$ ; IF NE, NO MOV #CREMSG,R0 ; MOVE IN SECOND HALF OF COMMAND BR DOIT ; GO ISSUE COMMAND 30$: CMP CMDNAM,#^RTRU ; IS IT TRUNCATE? BNE 35$ ; IF NE,NO MOV #TRUMSG,R0 ; IF YES, MOVE IN SWITCH BR DOIT ; AND GO DO IT. 35$: CMP CMDNAM,#^RTYP ; IS IT TYPE BEQ DOIT ; IF EQ, YES GO DOIT CMP CMDNAM,#^RLIS ; PERHAPS IT IS LIST? BEQ DOIT ; IF YES, DOIT 40$: JMP ERR4 ; WARN USER CODE FELL THROUGH HERE DOIT: MVZ R0,R1 ; MOVE IT IN SUB #MCRBUF,R1 ; LENGTH OF LINE TO SPAWN CMP R1,#78. ; IS COMPOSIT LINE TOO LONG BGT LNGERR ; IF GT, YES MOV R1,SPWN+S.PWCL ; AND THE LENGTH OF THE COMMAND JMP SPWNIT ; SPWAN COMMAND AND EXIT XIT: JMP ERR3 ; SAY SYNTAX ERROR LNGERR: MOV #EM2,R0 ; SAY IT'S TOO LONG JMP ERROR ; PRINT MESSAGE AND EXIT WITH ERROR .PAGE .SBTTL CHD ; CHD - CHANGE (OR SHOW) CURRENT UIC CHDM1: .ASCIZ \SET /UIC=[\ CHDM2: .ASCIZ \SET /UIC\ .EVEN CHD: ; REF LABLE TSTB 1(R5) ; IS THERE A UIC SPECIFIED? BEQ CHDSHW ; NO - SHOW CURRENT UIC MOV #CHDM1,R0 ; GET FIRST PART OF COMMAND MVZ R0,R1 ; MOVE FIRST PART OF STRING TO SPAWN BUFFER MOV R5,R0 ; INC R0 ; 10$: TSTB (R0) ; IS IT END OF LINE BEQ 20$ ; IF EQ 0, YES, CLOSE UP COMMAND CMPB (R0),#'[ ; IS IT [ BNE 11$ ; IF NE, NO, SKIP MOVB #40,(R0)+ ; YES, MAKE IT A SPACE BR 10$ ; AND TRY AGAIN 11$: CMPB (R0),#'= ; IS IT AN = BNE 12$ ; IF NE, NO MOVB #40,(R0)+ ; YES, MAKE IT A SPACE BR 10$ ; AND CHECK AGAIN 12$: CMPB #'],(R0) ; IS IT A ']'? BNE 13$ ; IF NE, NO MOVB #15,(R0)+ ; YES, SO TERMINATE COMMAND WITH MOVB #0,(R0) ; AND 0 BYTE BR 10$ ; AND LOOP AGAIN TO CATCH 0 BYTE 13$: ; IF NOT [, ], = , EITHER NUMBER OR CMPB (R0)+,#40 ; IF A SPACE SEPERATES THE GRM MEM BNE 10$ ; IF NE, MUST BE NUMBER-GET ANOTHER MOVB #',,-1(R0) ; ELSE MOVE IN A COMMA 20$: MVZ R5,R1 ; MOVE IN UIC DEC R1 ; BUMP MOVB #'],(R1)+ ; CLOSE UP COMMAND SUB #MCRBUF,R1 ; LENGTH OF SPAWN COMMAND MOV R1,SPWN+S.PWCL ; SET LENGTH IN SPAWN DPB JMP SPWNIT ; SPAWN COMMAND AND EXIT CHDSHW: ; REF LABLE MOV #CHDM2,SPWN+S.PWCA ; SET BUFFER ADDRESS MOV #8.,SPWN+S.PWCL ; SET BUFFER LENGTH JMP SPWNIT ; SPWAN COMMAND AND EXIT .PAGE .SBTTL ATS ; ATS - LIST ALL ACTIVE TASKS ( OR ONLY THOSE FOR A TERMINAL) ATSM1: .ASCII \ACT /ALL\ ATSM2: .ASCIZ \ACT /TERM=\ .EVEN ATS: TSTB 1(R5) ; US THERE A TERMINAL SPECIFIED BNE ATSTTY ; YES, JUMP MOV #8.,SPWN+S.PWCL ; SET COMMAND LENGTH MOV #ATSM1,SPWN+S.PWCA ; SET BUFFER ADDRESS BR SPWNIT ; SPWAN COMMAND AND EXIT ATSTTY: MOV #ATSM2,R0 ; FIRST PART OF SPAWN COMMAND MVZ R0,R1 ; MOVE ASCIZ STRING INTO SPAWN BUFFER INC R5 ; MVZ R5,R1 ; MOVE IN TERMINAL NUMBER DEC R1 ; BUMP SUB #MCRBUF,R1 ; LENGTH OF LINE TO SPAWN MOV R1,SPWN+S.PWCL ; SET COMMAND LENGTH BR SPWNIT ; SPAWN THE COMMAND .SBTTL TERMINAL SETTING ROUTINES .ENABL LC ERAMSG: .ASCII <33>/H/ ; CURSOR TO (1,1) VT52 .ASCII <33>/J/ ; ERASE TO END OF SCREEN VT52 .BYTE 0 ; SENTINAL PAGMSG: .ASCII <33>/[1;1H/ ; GOTO (1,1) VT100 .ASCII <33>/[2J/ ; ERASE SCREEN VT100 .ASCII <33><14> ; ERASE 4014 SCREEN .BYTE 0 ; SENTINAL BELMSG: .ASCIZ <7> ; RING BELL SCRMSG: .ASCIZ <33>/[?4h/ ; SET TERMINAL TO SCROOL MODE NSCMSG: .ASCIZ <33>/[?4l/ ; SET TERMINAL TO FAST JUMP MODE HOLMSG: .ASCII \SET /HOLD=TI:\ NOHMSG: .ASCII \SET /NOHOLD=TI:\ .EVEN ERASE: MOV #ERAMSG,R0 ; ERASE VT52 BR TOTERM ; BRANCH PAGE: MOV #PAGMSG,R0 ; GET ESCAPE STRING BR TOTERM ; GO WRITE OUT ESCAPE SEQ SCROLL: MOV #SCRMSG,R0 ; SET UP OUTPUT MESSAGE BR TOTERM ; SEND IT OUT NSCROLL:MOV #NSCMSG,R0 ; SET UP OUTPUT MESSAGE BR TOTERM ; SEND IT TO TERMINAL BELEP: MOV #BELMSG,R0 ; WRITE OUT MESSAGE TOTERM: CALL TYPEIT ; EXST$S #1 ; WHAT COULD POSSIBLY GO WRONG? HOLD: MOV #13.,SPWN+S.PWCL ; SET LENGTH MOV #HOLMSG,SPWN+S.PWCA ; AND BUFFER ADDRESS BR SPWNIT ; SPAWN COMMAND AND WAIT NOHOLD: MOV #15.,SPWN+S.PWCL ; SET LENGTH OF COMMAND MOV #NOHMSG,SPWN+S.PWCA ; AND BUFFER LENGTH BR SPWNIT ; SPAWN COMMAND AND WATI SPWNIT: ; REF LABLE DIR$ #SPWN ; TRY SPAWNING TO MCR... FIRST BCC 10$ ; IF CC WE GOT IT ; MOV MCRNM,SPWN+S.PWTN ; NEXT TRY ...MCR ; MOV MCRNM+2,SPWN+S.PWTN+2 ; SECOND HALF OF NAME ; DIR$ #SPWN ; SPAWN COMMAND ; BCC 10$ ; IF CC , SUCCESS MOV #BADSPN,R0 ; PRINT ERROR MESSAGE CALL TYPEIT ; OUT ON TI: EXST$S #4 ; VERY BAD ERROR 10$: JMP END ; END UP .PAGE .SBTTL SHQ - SHW - DLG ; SHQ - SHOW FULL QUEUE ENTRIES SHQM: .ASCII \QUE /LI:ALL\ .EVEN SHQ: MOV #11.,SPWN+S.PWCL ; SET LENGTH MOV #SHQM,SPWN+S.PWCA ; AND BUFFER ADDRESS BR SPWNIT ; SPAWN COMMAND ; SHW - SHOW QUE WAITING LIST SHWM: .ASCII \QUE /BR:ALL\ .EVEN SHW: MOV #11.,SPWN+S.PWCL; SET LENGTH MOV #SHWM,SPWN+S.PWCA ; AND ADDRESS BR SPWNIT ; SPWN COMMAND AND EXIT ; DLG - DISPLAY LOGGED IN TERMINALS DLGM: .ASCII \DEV /LOG\ .EVEN DLG: MOV #8.,SPWN+S.PWCL ; SET LENGTH MOV #DLGM,SPWN+S.PWCA ; AND ADDRESS BR SPWNIT ; SPAWN THE COMMAND AND EXIT .PAGE ; POO - SHOW POOL AMOUNT POOM: .ASCII \SET /POOL\ .EVEN POO: MOV #9.,SPWN+S.PWCL ; SET LENGTH MOV #POOM,SPWN+S.PWCA ; AND BUFFER ADDRESS BR SPWNIT ; SPAWN THE COMMAND AND EXIT ; SYS - SHOW CURRENT SYSTEM UIC SYSM: .ASCII \SET /SYSUIC\ .EVEN SYS: MOV #11.,SPWN+S.PWCL ; SET LENGTH MOV #SYSM,SPWN+S.PWCA; AND BUFFER ADDRESS BR SPWNIT ; SPAWN COMMAND AND EXIT .PAGE .SBTTL CREATE .PAGE .SBTTL DLY ; ; DLY NNNU -- DELAY 'NNNN' UNITS OF TIME ; DLY: MOV R5,R0 ; COPY BUFFER POINTER CALL $CDTB ; CONVERT UNITS VALUE MOV R1,R5 ; SAVE UNITS VALUE BEQ 30$ ; EXIT IF NULL MOV #1,R4 ; ASSUME TICS CMPB R2,#'T ; TICS? BEQ 20$ ; YES INC R4 ; TRY NEXT TIME VALUE CMPB R2,#'S ; SECONDS? BEQ 20$ ; IF EQ YES INC R4 ; NO , ASSUME MINUTES CMPB R2,#'M ; MINUTES? BEQ 20$ ; IF EQ, YES INC R4 ; IF NE, NO ASSUME HOURS CMPB R2,#'H ; HOURS? BNE 30$ ; IF NE, ILLEGAL VALUE 20$: MRKT$S #EFN1,R5,R4 ; ISSUE MARKTIME BCS 30$ ; IF DIRECTIVE ERROR JMP END ; GO WAIT 30$: ; RE LABLE JMP ERR3 ; SYNTAX ERROR ; .PAGE .SBTTL HEY ; ; HEY ; BUFFER: .BLKW 40. EXTBLK: .WORD -1 ISB: .WORD 0,0 CODES: .WORD E2 .WORD E3 .WORD E4 .WORD FUNNY ; BECAUSE EXIT STATUS IS 0,1,2,OR 4 .WORD E5 ERRS: .WORD FUNNY ; 0 - INTERNAL CONSISTENCY ERROR .WORD CMLINE ; 2 - COMMAND LINE I/O ERROR .WORD SYNTAX ; 4 - SYNTAX ERROR .WORD TSKCLI ; 6 - TASK A CLI .WORD NSTASK ; 8 - NO XSUCH ACTIVE TASK .NLIST BEX BADSPN: .ASCIZ <15><12>/...CA. -- BAD SPAWN TO ...MCR, SAVE PRINTOUT AND GET HELP / MESS1: .ASCIZ /HEY -- TASK / MESS2: .ASCIZ / EXITED WITH STATUS - / ERMES: .ASCIZ /HEY -- / E2: .ASCIZ /WARNING/ E3: .ASCIZ /SUCCESS/ E4: .ASCIZ /ERROR/ E5: .ASCIZ /SEVERE ERROR/ NSTASK: .ASCIZ /TASK NOT ACTIVE/ TSKCLI: .ASCIZ /BAD TASK/ SYNTAX: .ASCIZ /INVALID SYNTAX/ CMLINE: .ASCIZ /BAD COMMAND LINE/ FUNNY: .ASCIZ /FUNNY -- INTERNAL CONSISTANCY ERROR/ .LIST BEX .EVEN HEY: MOV #CNNECT+C.NCTN,R3 ; GET ADDRESS TO PUT TASKNAME MOV R5,R0 ; COPY BUFFER POINTER CLR R5 ; ZERO ERROR INDICATOR CMPB (R0),#SPA ; SPACE? BNE 20$ ; IF NE, NO TSTB (R0)+ ; YES, SKIP OVER IT 20$: ; REF LABLE CALL $CAT5 ; CONVERT ASCII TAKNAME TO RAD50 BCS 30$ ; IF CS LESS THAN 3 CHARACTERS INTASKNAME MOV R1,(R3)+ ; 1ST PART OF TASKNAME I N CONNECT DPB CALL $CAT5 ; CONVERT MORE TASKNAME INTO RAD50 BCS 40$ ; IF CS TERMINATING CHARACTER IN R2 30$: ; MOVB (R0),R2 ; GET TERMINATING CHARACTER 40$: ; MOV R1,(R3) ; TASKNAME IN CONNECT DPB CMPB R2,#ESC ; ESCAPE? BEQ 50$ ; IF EQ YES, OK CMPB R2,#CR ; CARRIAGE RETURN? BNE ERROR2 ; IN NE INVALID TERMINATOR .PAGE .SBTTL CONNECT AND WAIT DIR$ #CNNECT ; CONNECT TO THE SPECIFIED TASK CMP $DSW,#IS.SUC ; SUCCESSFUL CONNECTION? BEQ 50$ ; IF EQ, YES CMP $DSW,#IE.INS ; WAS SPECIFIED TASK A CLI? BEQ ERROR3 ; IF EQ YES CMP $DSW,#IE.ACT ; WAS TASK INACTIVE? BEQ ERROR4 ; IF EQ, YES BR ERROR0 ; NO FUNNY ERROR 50$: ; STSE$S #EF1 ; WAIT FOR CONNECTED TASK TO EXIT MOV #BUFFER,R0 ; GET OUTPUT BUFFER ADDRESS MOVB #BELL,(R0)+ ; PUT IN A BELL MOV #MESS1,R1 ; GET ADDRESS OF 1ST PART OF MESSAGE CALL MOVE ; PUT IN IN OUTPUT BUFFER MOV CNNECT+C.NCTN,R1 ; GET 1ST PART OF TASKNAME CALL $C5TA ; CONVERT TASKNAME TO RAD50 MOV CNNECT+C.NCTN+2,R1 ; GET 2ND PART OF TASKNAME CALL $C5TA ; CONVERT SECOND PART OF TASKNAME MOV #MESS2,R1 ; GET ADDRESS OF 2ND PART OF MESSAGE CALL MOVE ; MOVE IT INTO OUTPUT BUFFER MOV EXTBLK,R1 ; GET EXIT STATUS CMP #5,R1 ;KNOWN RETURN CODE BHI 60$ ; IF HI, YES CLR R2 ; SUPPRESS LEADING ZEROES CALL $CBOMG ; CONVERT TO OCTAL BR 70$ ; 60$: ; ASL R1 ; GET WORD INDEX MOV CODES(R1),R1 ; GET ADDRESS OF EXIT CODE MESSAGE CALL MOVE ; MOVE IT INTO BUFFER 70$: SUB #BUFFER,R0 ; GET LENGTH OF MESSAGE MOV R0,QIO+Q.IOPL+2 ; MOVE LENGTH OF BUFFER INTO QIO DIR$ #QIO ; PRINT MESSAGE BR ENDHEY ; FINISH UP .PAGE .SBTTL HEY ERROR PROCESSING ERROR4: INC R5 ; TASK NOT ACTIVE ERROR3: INC R5 ; TASK A CLI ERROR2: INC R5 ; INVALID SYNTAX ERROR1: INC R5 ; NO COMMAND LINE ERROR0: ; FUNNY INTERNAL ERROR ASL R5 ; GET WORD INDEX MOV #BUFFER,R0 ; GET 1ST PART OF ERROR MESSAGE CALL MOVE ; MOVE INTO OUTPUT BUFFER MOV ERRS(R5),R1 ; GET ADDRESS OF ERROR MESSAGE CALL MOVE ; MOVE MESSAGE INTO OUTPUT BUFFER SUB #BUFFER,R0 ; GET LENGTH OF MESSAGE MOV R0,QIO+Q.IOPL+2 ; PUT IT IN DPB DIR$ #QIO ; PRINT THE ERROR MESSAGE ENDHEY: EXST$S #EX$SUC ; EXIT SUCCESSFULLY .PAGE .SBTTL THE END ; ; THE END ; ENDUP: SUB #MCRBUF,R1 ; LENGTH OF LINE TO SPAWN SPWN$S #MCRNM,,,,,#1,,,#MCRBUF,R1 ; SEND TO MCR END: STSE$S #EF1 ; STOP FOR SPAWN TST EXSTAT ; IF EQ 0, WE HAVE SUCCESS BNE 5$ ; IF NE, USE WHAT'S SENT MOV #1,EXSTAT ; SHOW SUCCESS 5$: EXST$S EXSTAT ; EXIT SUCCESSFULLY .PAGE .SBTTL SUBROUTINES ;+ ; *** MOVE - MOVE AN ASCIZ STRING ; ; INPUTS: ; R0 - ADDRESS OF OUTPUT BUFFER ; R1 - ADDRESS OF ASCIZ STRING ; ; OUTPUTS: ; R0 - UPDATED ;- MOVE: ; MOVB (R1)+,(R0)+ ; MOVE NEXT CHARACTER TSTB (R1) ; END? BNE MOVE ; IF NE NO RETURN ; RETURN TO CALLER ; error message typer, error text ends in null TYPEIT: MOV R1,-(SP) MOV R0,R1 1$: TSTB (R1)+ BNE 1$ DEC R1 SUB R0,R1 QIOW$S #IO.WLB!TF.WAL,#2,#1,,,, MOV (SP)+,R1 RTS PC ; close our 1 file CLOS: CLOSE$ #FDB RTS PC ; open a file on lun 1, dataset descriptor in R1, eror label in R2 OPEN: OPEN$R #FDB,#1,R1 BCC 1$ JMP @R2 1$: RTS PC ; print couldnt access system file & die OPNFL: MOV #MSG2,R0 JMP ERROR ; EXIT WITH SEVERE ERROR ; IOSTS: .BLKW 2 PRMPT: ; THIS HAS TO FIND END OF INPUT LINE - ADD ? ; TYPE IT AND GET RESULT IN CORRECT 30 BYTE ARRAY CHUNK. MOVB INBF+1,R3 SUB #60,R3 CMP R3,L ; if the # for this line is lower than or equal to highest param ; we alreay have get the next one instead, this is settled already BLE NO MOV R3,L MUL #36,R3 ADD #P-36,R3 MOV #INBF,R1 MOV FDB+F.NRBD,R2 ADD R1,R2 ADD #2,R1 MOVB #'?,(R2)+ MOVB #' ,(R2)+ ; INSERT A SPACE SUB R1,R2 QIOW$S #IO.RPR,#2,#1,,#IOSTS,, CMPB IOSTS,#1 BEQ NO ; JMP .4000 MOV #MSG1,R0 ; DISPLAY CR,LF,> JMP ERROR ; EXIT WITH SEVERE ERROR NO: RTS PC ;+ ; WAITCK -- WAIT FOR TASK TO EXIT ; THIS SUBROUTINE PROCESSES THE CCL COMMAND ; -TASKNAME ;- WAITCK: CLR CNCT+C.NCTN+2 ; CLEAR OUT OLD TASK NAME CLR CNCT+C.NCTN ; CLEAR OUT OLD TASK NAME MOV #TSKNAM,R0 ; GET ADDRESS OF WHERE TO SHOVE TASK NAME MOV #6,R1 ; REPEAT 6 TIMES 1$: MOVB #40,(R0)+ ; INSERT A SPACE SOB R1,1$ ; LOOP UNTIL DONE MOV #INBF+1,R0 ; GET TASK NAME MOV PC,R2 ; WHAT IN THE WORLD IS THIS FOR, ORIGIONAL KIRKMAN??? MOV #1,R1 ; ACCEPT A . IN TASK NAME CALL $CAT5 BCC 2$ ; IF CC, CONVERSION COMPLETE(ALL THREE CHAR) MOV R1,CNCT+C.NCTN ;