!************************
!*      USERTS/USERTY   *
!* DATE: 17.DEC.80      *
!************************

! FILE 'USERTS'
! STK = 500, STREAMS = 0
%CONSTSTRING (7) VSN = "VSN002A"
%RECORDFORMAT DMF(%INTEGER I)

%CONSTRECORD (DMF) %NAME NULL = 0


%CONTROL K'100001'

%BEGIN

      %SYSTEMROUTINESPEC LINKIN(%INTEGER SER)
      %RECORDFORMAT ITPF(%BYTEINTEGER CNSL, HDB1, HDB2, %STRING (241) S)
      %RECORDFORMAT ITP2F(%BYTEINTEGERARRAY A(0:241))
      %RECORDFORMAT ITP3F(%BYTEINTEGER CNSL, HDB1, HDB2, %C
         %BYTEINTEGERARRAY A(0:32))

      %RECORDFORMAT NSI1F(%BYTEINTEGER FN, SUFL, ST, SS, SN, DN, DT, %C
        DS, FLAG, UFL, LEN1, DATA, %BYTEINTEGERARRAY A(2:238))
      %RECORDFORMAT NSI2F(%BYTEINTEGER FN, SUFL, ST, SS, FLAG, UFLAG %C
        %RECORD (ITPF) ITP)
      %RECORDFORMAT NSI3F(%BYTEINTEGERARRAY A(0:100))

      %RECORDFORMAT MEF(%RECORD (MEF) %NAME LINK, %C
        %BYTEINTEGER LEN, TYPE, %RECORD (NSI2F)NSS)
                                     ! THINK ABOUT THE POSITION OF 'LEN'
      %RECORDFORMAT PF(%BYTEINTEGER SER, REPLY, A1, A2, %C
         %RECORD (MEF) %NAME B, %BYTEINTEGER C1, C2)
      %RECORDFORMAT P2F(%BYTEINTEGER SER, REPLY, %INTEGER A, B, C)

      %RECORDFORMAT BUF1F(%INTEGER N)
      %RECORDFORMAT BUF2F(%BYTEINTEGERARRAYNAME B)
      %RECORDFORMAT BUF3F(%STRINGNAME S)

      !********** VARIOUS SERVICE NUMBERS *************
      %CONSTBYTEINTEGERNAME OWN ID = K'160030'
      %CONSTBYTEINTEGERNAME INT = K'160060'
      %CONSTBYTEINTEGERNAME TASK INT = K'000060'; ! IN MY SEG 0
      %CONSTINTEGER GATE SER = 16
      %CONSTINTEGER BUFFER MANAGER = 17

!           ITP /TASK INTERFACE MESSAGES
!
%CONSTINTEGER USER ID = 26
%CONSTINTEGER LOGON=1
%CONSTINTEGER DATA IN=2
%CONSTINTEGER INT IN=3
%CONSTINTEGER ILLEGAL MESSAGE=4
%CONSTINTEGER SEND DATA=5
%CONSTINTEGER DATA OUT=6
%CONSTINTEGER SEND PROMPT=7
%CONSTINTEGER TIMEOUT=8
%CONSTINTEGER LOGOFF=9
%CONSTINTEGER SETMODE=10
%CONSTINTEGER CHANGE TASK=11

   %CONSTSTRING (5) STEAL = "STEAL"
   %OWNSTRING (13) PR = "*
Command:"
   %CONSTSTRING (1) NULLS = ""
   %CONSTSTRING (5) STOP M = "STOP"
   %CONSTSTRING (25) INPM = "NODE9TERM"

      %RECORDFORMAT R1F(%INTEGER N)
      %RECORDFORMAT R2F(%STRINGNAME S)

      %RECORD (PF) P
      %RECORD (P2F) %NAME P2
      %RECORD (BUF1F) BUF1
      %RECORD (BUF2F) %NAME BUF
      %RECORD (BUF3F) %NAME BUF3
      %RECORD (R1F) %NAME R1
      %RECORD (R2F) R2
      %RECORD (MEF) %NAME MES
      %RECORD (ITP3F) %NAME ITP
      %INTEGER PT, SEG



      %OWNSTRING(2) NLS = "AB"
      %OWNINTEGER ITP SER = 0, TT REPLY, PORT, TASK ID, INP, OUTC
      %OWNINTEGER READ AD, READ LEN
      %OWNINTEGER MON = 0
      %INTEGER I, J, K

      %ROUTINESPEC DO PROMPT(%STRINGNAME S)
      %ROUTINESPEC SIMULATE TT(%INTEGER AD, LEN)
      %ROUTINESPEC FROM ITP INF
      %ROUTINESPEC HANDLE INT
      %ROUTINESPEC FREE BUFFER(%RECORD (MEF) %NAME MES)
      %RECORD (MEF) %MAPSPEC GET BUFFER
      %INTEGERFN %SPEC CALL LOADER(%STRINGNAME S)

      MAP VIRT(BUFFER MANAGER, 4, 3)
      MAP VIRT(BUFFER MANAGER, 5, 4)
MAP VIRT(BUFFER MANAGER, 6, 5)
      P2 == P
      LINKIN(USER ID)

      BUF == BUF1;  BUF3 == BUF
      R1 == R2

      CHARNO(PR, 1) = 13
      CHARNO(NLS, 1) = 13; CHARNO(NLS, 2) = 10

      %CYCLE
         P_SER = 0; POFF(P)
         %IF P_SER = USER ID %AND P_A2 = 0 %START
            SIMULATE TT(P2_B, P2_C)
         %ELSE %IF P_SER = USER ID %START
            FROM ITPINF
         %ELSE %IF P_REPLY = BUFFER MANAGER %START
         %ELSE
            %IF P2_C # 0 %START;    ! FAUILURE FLAG
               MES == GET BUFFER
               MES_NSS_ITP_S = "F A U L T "
               ITP == MES_NSS_ITP
               PT = 11
               %IF P2_C < 0 %START
                  P2_C = -P2_C
                  ITP_A(PT) = '-'; PT = PT+1
               %FINISH
               %IF P2_C>100 %START
                  ITP_A(PT) = '1'; PT = PT+1; P2_C=P2_C-100
               %FINISH
               %IF P2_C > 10 %START
                  I = P2_C//10
LAB:              ITP_A(PT) = I+'0'; PT = PT+1
                  P2_C = P2_C-I*10
               %FINISH
               P2_C=0 %IF P2_C>10
               ITP_A(PT) = P2_C+'0'
               ITP_A(PT+1) = NL
               MES_LEN = PT+1+4+6
               ITP_A(0) = PT+1
               P_SER = ITP SER; P_REPLY = 26
               P_A1 = DATA OUT; P_A2 = PORT
               P_B == MES
               PON(P)
            %FINISH
            !! SHOULD BE TASK TERMINATED
            !! HOW ABOUT A FLAG????
            DO PROMPT(PR)
         %FINISH
      %REPEAT


      %ROUTINE TO ITP(%INTEGER TYPE)
         P_SER = ITP SER; P_REPLY = 26
         P_A1 = TYPE; P_A2 = PORT
         PON(P)
      %END

      %ROUTINE DO PROMPT(%STRINGNAME S)
         %RECORD (MEF) %NAME MES
         MES == GET BUFFER
         MES_NSS_ITP_S = S
         MES_LEN = 6+4+LENGTH(S)
         P_B == MES
         TO ITP(SEND PROMPT)
      %END

      %ROUTINE SEND SETMODE(%INTEGER TYPE, VAL)
         %RECORD (MEF) %NAME MES
         %OWNSTRING (2) SETM = "AA"
         MES == GET BUFFER
         MES_LEN = 6+4+2
         CHARNO(SETM, 1) = TYPE; CHARNO(SETM, 2) = VAL
         MES_NSS_ITP_S = SETM
         P_B == MES
         TO ITP(SETMODE)
      %END

      %ROUTINE SEND INPUT TO TASK
         %INTEGER SEG
         SEG = READ AD>>13
         MAP VIRT(TASK ID, SEG, 0)
         BUF1_N = K'000000'!(READ AD&K'17777')
         %CYCLE I = 1, 1, LENGTH(R2_S)
            BUF_B(I-1) = CHARNO(R2_S, I)
         %REPEAT
         BUF_B(I) = NL
         MAP VIRT(0, -1, 0)
         P_SER = TASK ID; P_REPLY = 26
         P2_A = I+1
         PON(P)
         READ AD = 0; READ LEN = 0
      %END



      %ROUTINE FROM ITPINF
         %RECORD (MEF) %NAME MES
         %INTEGER FN, I, J, K
         %SWITCH SW(LOGON:CHANGE TASK)

         ITP SER = P_REPLY
         FN = P_A1
      %IF MON # 0 %START
            PRINTSTRING("FN:"); WRITE(FN, 1)
            PRINTSTRING(" RECD
")
         %FINISH

         -> SW(FN)

SW(LOGON):
      PRINTSTRING("Logon from TCP"); WRITE(P2_B>>8, 1)
      PRINTSTRING(", Cnsl"); WRITE(P_C1, 1)
      PRINTSTRING(", Port"); WRITE(P_A2, 1); NEWLINE
      %IF PORT = 0 %START
         PORT = P_A2
         OUTC = 1;    ! SEND SETMODE ON RECEIPT OF 'SEND'
      %FINISH
      %RETURN
SW(DATA IN):
      MES == P_B
      R1_N = P2_B+13
      LENGTH(R2_S) = LENGTH(R2_S)-2 %UNLESS LENGTH(R2_S) < 2
      %IF READ AD = 0 %START;    ! SEND IT TI THE CLOADER
         %IF R2_S = STOP M %START
CHOP:
            P_B == MES;  ! ENSURE THAT BUFFER IS RESTORED
            LENGTH(MES_NSS_ITP_S) = 0
            MES_LEN = 6+4
            TO ITP(LOGOFF)
            -> DO LOGOFF
         %FINISH
         %IF INP = 0 %START
            %IF R2_S # INPM %THEN ->CHOP
            SEND SETMODE(1, 1)
            INP = INP+1
            I = 0
         %ELSE
            I = CALL LOADER(R2_S)
         %FINISH
         %IF I = 0 %START
            DO PROMPT(PR)
         %FINISH
         TASK ID = I
      %ELSE;     ! INPUT FOR SEOMEONE
         SEND INPUT TO TASK
      %FINISH
      FREE BUFFER(MES)
      %RETURN
SW(INT IN):
         HANDLE INT
         %RETURN

SW(ILLEGAL MESSAGE):
SW(TIMEOUT):
      I=0; %RETURN
SW(LOGOFF):
DO LOGOFF:
      INP = 0
      TASK ID = 0; READ AD = 0
      PRINTSTRING("Console"); WRITE(PORT, 1)
      PRINTSTRING(" logged off
")
      PORT = 0; OUTC = 0
SW(SETMODE):
SW(CHANGE TASK):
         I = 0;        ! DUMMY
         %RETURN

SW(SEND DATA):
         %IF OUTC = 1 %START;    ! SEND THE ECHO OFF
            SEND SETMODE(1, 0)
            OUTC = OUTC+1
            %RETURN
         %FINISH

         %IF OUTC = 2 %START;    ! RESPONSE TO SETMODE
            DO PROMPT(PR)
            OUTC = OUTC+1
            %RETURN
         %FINISH
         %IF TT REPLY # 0 %START
            P_SER = TT REPLY; P_REPLY = 26
            P_A1 = 0
            PON(P)
            TT REPLY = 0
         %FINISH
      %END

      %ROUTINE SIMULATE TT(%INTEGER AD, LEN)
         %RECORD (MEF) %NAME MES
         %RECORD (ITP3F) %NAME ITP
         %INTEGER I, J, K, X


         !! P_A1 = 0 READ, P_A1 = 1 WRITE
         %IF MON # 0 %START
            PRINTSTRING("SIM:"); WRITE(P_A1, 1); NEWLINE
         %FINISH

         %IF P_A1 = 0 %START
            READ AD = AD; READ LEN = LEN
            DO PROMPT(NULLS)
            %RETURN
         %FINISH
         TT REPLY = P_REPLY
         MES == GET BUFFER
         ITP == MES_NSS_ITP
         SEG = AD >> 13
         MAP VIRT(TT REPLY, SEG, 0)
         BUF1_N = K'000000'!(AD&K'17777')
         %CYCLE I = 0, 1, LEN-1
            X = BUF_B(I)
            ITP_A(I+1) = X
         %REPEAT
         %IF ITP_A(LEN) = NL %START
            ITP_A(LEN) = 13; ITP_A(LEN+1) = 10
            LEN = LEN+1
         %FINISH
         ITP_A(0) = LEN
         MAP VIRT(0, -1, 0)
         P_B == MES
         MES_LEN = LEN+4+6
         TO ITP(DATA OUT)
      %END

      %RECORD (MEF) %MAP GET BUFFER
         P_SER = BUFFER MANAGER; P_REPLY = OWN ID
         P_A1=0; P_C1=0
         PONOFF(P)
         %RESULT == P_B
      %END
      %ROUTINE HANDLE INT
         %INTEGER I,J,K
         %RECORD (MEF) %NAME MES
         %STRINGNAME S

         R1_N = P2_B+13
         S == R2_S
         %IF CHARNO(S, LENGTH(S)) = NL %THEN %C
           LENGTH(S) = LENGTH(S)-2;   ! REMOVE CR/LP
         %IF LENGTH(S) = 1 %START;  ! STANDARD INT
            %IF TASK ID # 0 %START
               MAP VIRT(TASK ID, 7, 0); ! ITS SEG 7 TO MY 0
               TASK INT = CHARNO(S, 1)
               MAP VIRT(0, -1, 0)
            %FINISH
         %FINISH
         %IF S = STEAL %THEN PORT = 0
!         FREE BUFFER (P_B)
      %END

      %ROUTINE FREE BUFFER(%RECORD (MEF) %NAME MES)
         P_SER = BUFFER MANAGER; P_REPLY = OWN ID
         P_A1 = 1; P_B == MES
         PON(P)
      %END


     %INTEGERFN CALL LOADER(%STRINGNAME S)
         %CONSTINTEGER LOAD SER = 5
%CONSTBYTEINTEGERNAME FSYS=K'160055', TTNO = K'160061', CALLID = K'160031'
     %RECORDFORMAT PE(%BYTEINTEGER SERVICE, REPLY, %BYTEINTEGER A1, A2, %C
       %BYTEINTEGERNAME B, %BYTEINTEGER C1, C2)
       %INTEGER RES

     %RECORDFORMAT R1F(%STRINGNAME S)
     %RECORDFORMAT R2F(%BYTEINTEGERARRAYNAME A)

     %RECORD (R1F)R1;  %RECORD (R2F) %NAME R2
     %RECORD (PE)P
        R2 == R1
        R1_S == S
        R2_A(LENGTH(S)+1) = NL
        P_SERVICE = LOAD SER;  P_REPLY = OWN ID
        P_A1 = 1; P_A2 = FSYS;  P_B == R2_A(1);  P_C1 = 4
        P_C2 = 26;   ! USUALLY TT NO
        PONOFF(P)
        RES = P_A1
        P_SERVICE = CALL ID; P_REPLY = OWN ID
         P_A1 = 3;        ! TELL CLI EXTRA TASK LOADED
        PON(P)
        %RESULT = RES
     %END

%ENDOFPROGRAM
     %RECORDFORMAT PE(%BYTEINTEGER SERVICE, REPLY, %BYTEINTEGER A1, A2, %C