PDP-10.its/src/gren/sensor.87

;-*-Midas-*-
 
 
Title :SENSOR - Sends cENSOR
 
 
A=1 ;General porpoise
B=2
C=3
D=4
J=5
F=6
G=7
 
I=10 ;Index
 
R1=11 ;Returns
R2=12
R3=13
 
T1=14 ;Transient
T2=15
T3=16
 
P=17 ;The obligatory PDL
 
Call=<PUSHJ P,>
Return=<POPJ P,>
 
TTYo==1
CLIo==2
USRi==3
 
PDLen==15
JCLen==20
 
MaxIs==10 ;Max # unames to /Ignore
MaxPs==10 ; " # jnames to /Program
MaxFs==10 ; " # jnames to /Forward to
 
;;;
;;;;;
;;;
 
Define SYSCAL op,args
.Call [Setz ? Sixbit /op/ ? args ((Setz))]
Termin
 
Define TYPE &string
Movei T1,<.Length string>
Move T2,[440700,,[Ascii string]]
Syscal SIOT,[%Climm,,TTYo ? T2 ? T1]
.Lose %LsSys
Termin
 
;;;
;;;;;
;;;
 
Keys: "B ? "F ? "I ? "P ? "S ? "V ? "N
Hands: DoB ? DoF ? DoI ? DoP ? DoS ? DoV ? DoN
NKeys==.-Hands
 
BFlag: 0
FFlag: 0
IFlag: 0
PFlag: 0
SFlag: 0
VFlag: 0
 
oChan: TTYo
 
Uname: 0 ;Your uname
 
Valret: Ascii ":SELF
.JNAME/1'HACRTN
:KILL
HACTRNJ
L DSK:KP;SERVER BIN
:GZP
 :FORGET
J :VK "
 
Numbel: 1 ;Number of bells before message
Verbos: 4 ;Verbosity level
SaveSs: -1 ;0 if not Saving Sends
 
Device: Sixbit /DSK/ ;Filename of your sends file
Sname: Sixbit /.TEMP./
FN1: 0
FN2: Sixbit /SENDS/
 
Ignore: 0 ;# unames we're ignoring
INames: Block MaxIs ;da poop
IValue: Block MaxIs ;Ignorance level
 
Sacred: 0 ;# special programs
PNames: Block MaxPs ;more poop
PVerb: Block MaxPs ;Verbosity
PBell: Block MaxPs ;Bells.
 
Forwar: 0 ;# jnames to foreward to
FNames: Block MaxFs
FRilly: Block MaxFs
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Header-parse cruft that needs to be zeroed every pass goes
;;; tween the Zer's. Contents of ZerTop is written over it all.
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
ZerTop: 0 ;Had better be zero!
 
JOBp: 0 ;-1 if print funame/jname and mesage only.
MAILp: 0 ;-1 for mail notification
YesCLI: 0
 
Fname: Block 4 ;From Name
F6name: 0 ;6bit name of sender. nonzero iff this is from an ITS site
 
Fsite: Block 3 ;From Site
F6Site: 0
 
FUname: 0 ;From Uname/Jname (might be COMSYS or some such)
FJname: 0
 
Length: 0 ;Length of message
pText: 0
 
ZerBot: 0 ;Hi, mom.
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; End zeroed stuff
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
No: 0 ;True if this keyword has the /No prefix
gotFN1: 0
 
PDList: -PDLen,,.
Block PDLen
 
JCLbuf: Block JCLen
-1
 
OB: "[
CB: "]
EOF: -1,,3

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; The program (finally) begins
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
Begin: Move P,PDList
Syscal OPEN,[%Clbit,,.uao\%TJDIS
%Climm,,TTYo
[Sixbit /TTY/]]
.Lose %LsFil
.Suset [.rUNAME,,Uname]
 
JCLp: .Break 12,[..rJCL,,JCLbuf]
Skipn JCLbuf
Jrst Go ;No JCL to parse
Move J,[350700,,Jclbuf]
 
NabCmd: Setzm No
Call Getcmd
Jrst Go ;Nothing more to get
Movsi T1,NKeys
Fcomd: Camn R1,Keys(T1)
Jrst @Hands(T1)
Aobjn T1,Fcomd
 
Type "Unknown command: '"
.Iot TTYo,R1
.Iot TTYo,["']
Jrst JCLerr
 
;;;
;;; /BELLS nnn
;;;
 
DoB: Call Getnum
Jrst NoNum
Cail R1,10.
Jrst BadNum
Movem R1,Numbel
Setom BFlag
Jrst NabCmd
 
;;;
;;; /VERBOSITY nnn
;;;
 
DoV: Call Getnum
Jrst NoNum
Caile R1,3
Jrst BadNum
Movem R1,Verbos
Setom VFlag
Jrst NabCmd
 
;;;
;;; [/NO] /PROGRAM uname bells verbosity ...
;;;
 
DoP: Setz B,
Call GetSix
Jrst NoArg
DoP2: Cail B,MaxPs
Jrst ToMany
Move C,R1
Call GetNum
Jrst [Movei R1,1 ;B=1
Movei R2,2 ;V=2
Jrst SaveP]
IDivi R1,10.
Caig R1,9.
Caile R2,3
Jrst BadNum
SaveP: Movem C,PNames(B)
Movem R2,PVerb(B)
Movem R1,PBell(B)
Call GetSix
Jrst [Aoj B,
Movem B,Sacred
Setom PFlag
Jrst NabCmd]
Aoja B,DoP2
 
;;;
;;; [/NO] /SENDSAVE dev:sname;fn1 fn2
;;;
 
DoS: Skipe No
Jrst [Setzm SaveSs
Jrst NabCmd]
Setom SaveSs
Setzm gotFN1
Setom SFlag
gFile: Call GetSix
Jrst NabCmd
Cain R2,":
Jrst [Movem R1,Device
Jrst gFile]
Cain R2,";
Jrst [Movem R1,Sname
Jrst gFile]
Movei T1,FN1
Skipe gotFN1
Aoj T1,
Movem R1,(T1)
Setom GotFN1
Jrst gFile
 
;;;
;;; [/NO] /IGNORE uname intensity ...
;;;
 
DoI: Setz B,
Call GetSix
Jrst NoArg
DoI2: Cail B,MaxIs
Jrst ToMany
Skipe No
Jrst [Setom IValue(B)
Jrst DoI3]
Move C,R1
Call GetNum
Jrst NoNum
Movem R1,IValue(B)
DoI3: Movem C,INames(B)
Call GetSix
Jrst [Aoj B,
Movem B,Ignore
Setom IFlag
Jrst NabCmd]
Aoja B,DoI2
 
;;;
;;; [/NO] /FORWARD jname ...
;;;
 
DoF: Setz B,
Call GetSix
Jrst NoArg
DoF2: Cail B,MaxFs
Jrst ToMany
Movem R1,FNames(B)
Move T1,No
Movem T1,FRilly(B)
Call GetSix
Jrst [Aoj B,
Movem B,Forwar
Setom FFlag
Jrst NabCmd]
Aoja B,DoF2
 
DoN: Setcmm No
Jrst NabCmd

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; JCL is all parsed - Now we summon a new server, or just
;;; ship off these params to an existing one.
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
Go: Syscal OPEN,[%Clbit,,.bii
%Climm,,USRi
[Sixbit /USR/]
Uname
['HACRTN]]
.Value Valret
.Close USRi,
Syscal OPEN,[%Clbit,,.uao
%Climm,,CLIo
[Sixbit /CLI/]
Uname
['HACTRN]]
Jrst CantS
.Iot CLIo,[177]
.Iot CLIo,[177] ;Set up lead-in sequence
 
;;;
;;; <0><#of bells>
;;;
 
SendB: Skipn BFlag
Jrst SendF
.Iot CLIo,[0]
.Iot CLIo,Numbel
 
;;;
;;; <1><number><jname 1><0><jname 2><0> ...
;;;
 
SendF: Skipn FFlag
Jrst SendI
.Iot CLIo,[1]
.Iot CLIo,Forwar
Movn A,Forwar
Movss A
SendFl: Move T1,FNames(A)
Call 6Type
.Iot CLIo,[0]
Aobjn A,SendF
 
;;;
;;; <2><number><ignorance 1><uname 1><0><ignorance 2><uname 2><0> ...
;;;
 
SendI: Skipn IFlag
Jrst SendP
.Iot CLIo,[2]
.Iot CLIo,Ignore
Movn A,Ignore
Movss A
SendI1: .Iot CLIo,IValue(A)
Move T1,INames(A)
Call 6Type
.Iot CLIo,[0]
Aobjn A,SendI1
 
;;;
;;; <3><number><verbosity 1><bells 1><jname 1><0> ...
;;;
 
SendP: Skipn PFLag
Jrst SendS
.Iot CLIo,[3]
.Iot CLIo,Sacred
Movn A,Sacred
Movss A
SendP1: .Iot CLIo,PVerb(A)
.Iot CLIo,PBell(A)
Move T1,PNames(A)
Call 6Type
Aobjn A,SendP1
 
;;;
;;; <4><flag>[<device><0><sname><0><fn1><0><fn2><0>]
;;;
 
SendS: Skipn SFlag
Jrst SendV
.Iot CLIo,[4]
.Iot CLIo,SaveSs
Skipn SaveSs
Jrst SendV
Move T1,Device
Call 6Type
.Iot CLIo,[0]
Move T1,Sname
Call 6Type
.Iot CLIo,[0]
Move T1,FN1
Call 6Type
.Iot CLIo,[0]
Move T1,FN2
Call 6Type
.Iot CLIo,[0]
 
;;;
;;; <5><verbosity>
;;;
 
SendV: Skipn SendV
Jrst Finish
.Iot CLIo,[5]
.Iot CLIo,Verbos
 
Finish: .Close CLIo,
Type "[Arghs sent]"
Jrst Die
 
 
;;;
;;;;;
;;;
 
 
 
NoNum: Type "Missing numeric argument?"
Jrst JCLerr
 
BadNum: Type "Numeric argument out of valid range?"
Jrst JCLerr
 
NoArg: Type "Missing argument?"
Jrst JCLerr
 
BadArg: Type "Invalid argument?"
Jrst JCLerr
 
ToMany: Type "Too many arguments?"
 
JCLerr: .Iot TTYo,[^P]
.Iot TTYo,["A]
Move A,[440700,,JCLbuf]
JEloop: Ildb T1,A
Jumpe T1,Die
Cail T1,40
.Iot TTYo,T1
Came A,J
Jrst JEloop
.Iot TTYo,["<]
.Iot TTYo,["-]
Jrst JEloop
 
CantS: Type "Can't send arguments to HACTRN"
 
DIE: .Logout 1,
 
6Type: Setz T2,
Rotc T1,6
Addi T2,40
.Iot CLIo,T2
Jumpn T1,6Type
Return
 
GCmOne: Ibp J
GetCmd: Ldb T1,J
Caie T1,40 ;Skip leading whitespace
Cain T1,^I
Jrst GCmOne
Caie T1,^M ;Die on ^C, ^M, ^_, ^@
Cain T1,^C
Return
Skipe T1
Cain T1,^_
Return
Caie T1,"/ ;Ah, we found the "/"!
Jrst GCmOne
Ildb R1,J ;Get the command-char
Cail R1,"a
Trz R1,40 ;Uppercase it
 
Gc2: Ildb T1,J
Caie T1,40
Cain T1,"=
Jrst PopJ1
Caie T1,^I
Cain T1,",
Jrst PopJ1
Jumpn T1,GC2
Jrst PopJ1
 
GetSix: Setz R1,
Movei T3,6
Move T2,[440600,,R1]
Ildb R2,J
Caie R2,40
Cain R2,^I
Jrst .-3
Skipa
g6Char: Ildb R2,J
Caie R2,^M
Cain R2,^C
Jrst 6Check
Skipe R2
Cain R2,"/
Jrst 6Check
Caie R2,";
Cain R2,":
Jrst 6Check
Cain R2,40
Jrst 6Check
Jumpe T3,g6Char
Cail R2,"a
Trz R2,40
Subi R2,40
Idpb R2,T2
Soja T3,g6Char
 
6Check: Caie T3,6
Jrst PopJ1
Return
 
GetNum: Setz T3,
Ildb T1,J
Caie T1,40
Cain T1,^I
Jrst GetNum
Skipa
gNChar: Ildb T1,J
Caie T1,^M
Cain T1,^C
Jrst NCheck
Caie T1,"/
Skipn T1
Jrst NCheck
Caie T1,40
Cain T1,^I
Jrst NCheck
Cail T1,"0
Caile T1,"9
Jrst [Skipn T3
Return
Pop P,T1
Jrst .-3]
Subi T1,"0
Push P,T1
Aoja T3,gNChar
 
NCheck: Skipn T3
Return
Setz R1,
Movei R2,1
ToTen: Pop P,T1
IMul T1,R2
IMuli R2,10.
Add R1,T1
Sojn T3,ToTen
Jrst PopJ1
 
PopJ1: Aos (P)
Return
 
;;;
;;;;;
;;;
 
Variables
Constants
 
 
END Begin