*DECK,NEW 
USETEXT IP$COM
USETEXT MISC$ 
USETEXT TCH$COM 
USETEXT TSB$COM 
USETEXT ABH$COM 
USETEXT ACN$COM 
USETEXT SMDEF 
USETEXT DCB$COM 
USETEXT QAC$COM 
USETEXT QAB$COM 
USETEXT QCB$COM 
USETEXT GLOBALI 
USETEXT SM$COM
USETEXT TCB$COM 
USETEXT UCB$COM 
      PROC NEW; 
      BEGIN # NEW # 
*IF DEF,IMS 
 #
*1DC  NEW 
* 
*     1. PROC NAME           AUTHOR              DATE 
*        NEW                 B. M. WEST          6 MAY 1977 
*                            SEYUNG              DEC 10,1979
* 
*     2. FUNCTIONAL DESCRIPTION.
* 
*        NEW PROCESSES CON/REQ/SM.
* 
*     3. METHOD USED. 
*        NEW CALLS NEW$CONSOLE TO BUILD A TCB AND ACN$TABLE ENTRY FOR A 
*        CONSOLE CONNECTION OR CALLS NEW$BATCH TO BUILD A ACN$TABLE 
*        ENTRY AND TCB$DEVICE ENTRY IN TCB FOR A BATCH DEVICE 
*        CONNECTION.
* 
*        NEW WILL SEND A CON/REQ RESPONSE ACCEPTING OR REJECTING THE
*        CONNECTION. REJECTION IS DUE TO EITHER ERROR IN CON/REQ
*        DATA OR AN EXISTING ACN FOR ACN GIVEN IN THE CON/REQ SM. 
* 
*        NEW RELEASES THE NETWORK BUFFER CONTAING THE CON/REQ SM. 
* 
*        NEW$BATCH
*          1. SEARCHES FOR A CONTROLLING CONSOLE IF NONE, A PSEUDO
*             TCB IS BUILD AND A PSEUDO ACN TABLE ENTRY CREATED 
*             A PSEUDO ACN IS A ACN GREATER THAN TOTDEV + STATIONS, 
*             WHERE TOTDEV IS THE MAXIMUM NUMBER OF BATCH DEVICES TO BE 
*             ENTERED BY RBF AND STATIONS IS THE MAXIMUM NUMBER OF
*             CONSOLES TO BE SERVED BY RBF.  THE ARE STATIONS NUMBER OF 
*             PSEUDO ACN"S AVAILABLE IN THE ACN TABLE.
*          2. NEW$BATCH BUILDS A ACN TABLE ENTRY BUT DOES NOT 
*             LINK IT TO ANY MODULE, THAT IS DONE BY SMP WHEN THE 
*             FC/INIT SM IS RECEIVED. A TCB$DEVICE ENTRY FOR THE
*             BATCH DEVICE IS BUILD AND INITIALIZED.
* 
*          3. SHOULD A BUFFER FOR A PSEUDO TCB NOT BE AVAILABLE 
*             NEW WILL LINK TO ITSELF FOR SUBSEQUENT PROCESSING 
*             WHEN THERE MAY BE SPACE AVAILABLE.
* 
*        NEW$CONSOLE
*          1. SEARCHS FOR A CONSOLE WITH THE SAME TERMINAL NAME OR
*             USER/FAMILY NAME. IF FOUND AND NOT A PSEUDO ENTRY 
*             THEN THE CON/REQ IS REJECTED.  IF FOUND AND A PSEUDO
*             ENTRY THE PSEUDO ENTRY IS MOVED TO THE ACN GIVEN IN 
*             THE CON/REQ SM AND THE ACN ENTRY OF ASSOCIATED BATCH
*             DEVICES UPDATED TO POINT TO THE CONSOLE"S ACN.
*             IF NOT FOUND, A TCB IS BUILT. IF NOT FOUND AND NO SPACE 
*             IS AVAILABLE NEW WILL LINK TO ITSELF FOR SUBSEQUENT 
*             PROCESSING AND RETURN.
* 
*          2. ONCE A TCB IS AVAILABLE, NEW$CONSOLE MOVE THE TERMINAL
*             INFORMATION INTO THE TCB AND INITIALIZES ALL FLAGS
*             AND DATA FIELDS 
* 
*        3. THE RBF STARTED MESSAGE IS CHAIN TO THE CONSOLE"S TCB 
*             SO THAT WHEN THE CONSOLE IS LINKED TO IDLE AND PROCESSED
*             BY IT AFTER THE FC/INIT IS RECEIVED THE MESSAGE WILL BE 
*             SENT TO THE CONSOLE. FOR 200UT"S THIS WILL PUT THE
*             TERMINAL IN INTERACTIVE MODE. 
* 
*          4. THE READY MESSAGE IS ALSO APPENDED TO THE CONSOLE"S 
*             TCB AND NEW$CONSOLE RETURNS TO NEW. 
* 
* 
*     4. ENTRY PARAMETERS.
* 
*        ACN$CTLR [ACN]      ORDINAL OF THE BUFFER CONTAINING 
*        THE CON/REQ/SM.
* 
*     5. EXIT PARAMETERS. NONE. 
* 
*     6. COMDECKS CALLED. 
* 
*        RBF$COM
*        TCB$COM
*        TSBMDEFS 
*        TSBMBASE 
*        SM$COM 
*        ABH$COM
*        CON$COM
*        DCB$COM
*        UCB$COM
* 
*     7. ROUTINES CALLED. 
* 
*        RETTSB, NETPUT, GETBUF, LINK, CHGSIZE, SYSTEM, CONSOLE 
*        RDYMSG, REMOVE 
* 
*     8. DAYFILE MESSAGES. NONE.
* 
 #
*ENDIF
  
      XREF PROC EVENT;
      XREF PROC SYSTEM;      # MAKES SYSTEM CALLS                      #
      XREF PROC NETPUT;      # SENDS BLOCK TO NETWORK                  #
      XREF PROC RETTSB;      # FREE BUFFER                             #
      XREF PROC SETUPACN;                      # SET UP CONTROL BLOCKS #
      XREF FUNC GETBUF U;    # ACQUIRE BUFFER                          #
      XREF PROC LINK;        # LINK ACN TO MODULE                      #
      XREF PROC REMOVE;      # REMOVE ACN FROM A CHAIN                 #
      XREF PROC CHGSIZE;     # CHANGE SIZE OF BUFFER                   #
      XREF FUNC BUFINFO U;             # DO NOT MOVE TSB               #
      XREF PROC MOVEOK;                # MAKE TSB MOVEABLE             #
      XREF LABEL CALLRTN; 
      ITEM CONSOLEACN I;     # CONSOLE"S ACN                           #
      ITEM I I;              # INDEX VARIABLE                          #
      ITEM K I;              # INDEX VARIABLE                          #
      ITEM NEXT I;           # QAB ORDINAL #
      ITEM SMBUFFER U;       # ORDINAL OF CON/REQ SM BUFFER            #
      ITEM BADDATA B;        # BAD DATA FLAG                           #
      ITEM FOUND B;          # FOUND FLAG                              #
      ITEM RELEASE B;        # RELEASE BUFFER FLAG                     #
      ITEM ACTYPE I;         # ACT OF CONNECTION                       #
      LABEL NEWDEVEXIT; 
      DEF  RBFNAME   #"RBF"#; 
      CONTROL EJECT;
      FUNC SUPBLKS(NAME) C(7); # TRANSFORM BLANKS TO ZEROS IN A NAME   #
*IF,DEF,IMS 
 #
*1DC  SUPBLKS 
* 
*     1. FUNC NAME             AUTHOR               DATE
*        SUPBLKS               G. A. VALENCIA       JANUARY 24, 1980
* 
*     2. FUNCTIONAL DESCRIPTION 
*             CHANGES ANY TRAILING BLANKS IN A 7-CHARACTER NOS
*        NAME TO ZEROS (AS REQURIED BY MOST NOS FUNCTION PROCESSORS). 
*     3. METHOD USED
* 
*     3. METHOD USED
*             SEARCH FOR BLANKS STARTING AT THE END OF A NOS NAME.
*        WHEN ONE IS FOUND, INSERT A CORRESPONDING ZERO INTO THE VALUE
*        RETURNED.  IF NON-BLANK, PICK UP THE BEGINING OF THE NAME AND
*        RETURN.
* 
*     4. ENTRY PARAMETERS 
*        NAME - CHARACTER STRING TO BE CONVERTED.  ASSUMED TO BE
*               THE LEFTMOST 7 CHARACTERS.
* 
*     5. VALUE RETURNED 
*        SUPBLKS - FIRST 7 CHARACTERS IN NAME WITH ANY TRAILING 
*                  BLANKS SUPRESSED.
* 
*     6. THIS FUNCTION IS LOCAL TO NEW. 
* 
 #
*ENDIF
      BEGIN     # SUPBLKS # 
      ITEM NAME C(10);         # INPUT PARAMETER                       #
      ITEM RETSTRING C(7);     # TEMPORARY STORAGE FOR RETURNED VALUE  #
      ITEM K;                  # INDUCTION VARIABLE                    #
  
      FOR K=6 STEP -1 UNTIL 0 
      DO                       # CHECK LEFTMOST CHARS, STARTING AT 6TH #
        BEGIN 
        IF C<K>NAME EQ " "
        THEN
          BEGIN                # CONVERT BLANK TO ZERO                 #
          C<K>RETSTRING = 0;
          END 
        ELSE
          BEGIN                # MOVE NAME TO THE RETURNED VALUE       #
          C<0,K+1>RETSTRING = C<0,K+1>NAME; 
          K = 0;               # NAME IS FOUND, TERMINATE LOOP         #
          END 
        END 
  
      SUPBLKS = RETSTRING;
      RETURN;                  # ENTIRE NAME CONVERTED TO ZEROS        #
      END       # SUPBLKS # 
      CONTROL EJECT;
      PROC NEW$BATCH; 
      BEGIN # NEW$BATCH # 
#                                                                      #
#     PROCESS CON/REQ SM FOR A BATCH CONNECTION                        #
#                                                                      #
#     SEARCH FOR CONNECTED OR PRE-CONNECTED CONTROLLING CONSOLE        #
#                                                                      #
      IF CONORD EQ 0                           # IF DEVICE ORDINAL = 0 #
         THEN BEGIN 
              BADDATA = TRUE;                  # REJECT CON/REQ        #
              RETURN; 
              END 
      FOUND = FALSE;
      FOR I = 1 STEP 1 WHILE I LQ TOTDEV + STATIONS + STATIONS AND
        NOT FOUND DO
        BEGIN # SEARCH FOR CONSOLE #
        IF ACN$DEVTYPE [I] EQ S"CONSOLE"
           AND ACN$STATE [I] NQ S"NON$EXISTENT" 
           AND ACN$CB [I] NQ 0
        THEN
          BEGIN # CHECK CONSOLE ID #
          P<TCB> = ADDRESS [ACN$CB[I]]; 
          FOUND = CONOWNR EQ TCB$TERMNAME;
          END   # CHECK CONSOLE ID #
        IF FOUND
        THEN
          CONSOLEACN = I; 
        END   # SEARCH FOR CONSOLE #
      IF NOT FOUND
      THEN
        BEGIN # BUILD A PRE-CONNECTED CONSOLE TCB AND PSEUDO ACN ENTRY #
        FOR I = TOTDEV + STATIONS + 1 STEP 1 WHILE I LQ TOTDEV +
          STATIONS + STATIONS AND NOT FOUND DO
          BEGIN # SEARCH FOR FREE PSEUDO ACN #
          FOUND = ACN$STATE [I] EQ S"NON$EXISTENT"; 
          CONSOLEACN = I; 
          END   # SEARCH FOR FREE PSEUDO ACN #
        IF NOT FOUND
        THEN
          BEGIN # NO FREE PSEUDO ACN - ERROR #  # REJECT CON/REQ       #
          BADDATA = TRUE ;
          RETURN;                               # PSEUDO SECTION FOR   #
          END  #  NO FREE PSEUDO ACN - ERROR #  # ALL CONSOLES TO BE   #
                                                # PRE CONNECTED        #
        ELSE
          BEGIN # BUILD TCB AND PSEUDO ACN #
GETATCB:  
          ACN$CB [CONSOLEACN] = GETBUF (TCB$SIZE+TCB$DEVSIZE,MOVEABLE); 
          IF ACN$CB [CONSOLEACN] EQ 0 
          THEN
            BEGIN # NO ROOM FOR TCB # 
            ACN$CTLR [ACN] = SMBUFFER;
            EVENT (CHAINS"BACKGROUND");          # WAIT FOR BUFFER AREA#
            GOTO GETATCB;                        # TRY ONCE MORE       #
            END   # NO ROOM FOR TCB # 
          ELSE
            BEGIN # TRANSFER INFO INTO TCB AND PSEUDO ACN # 
            P<TCB> = ADDRESS [ACN$CB[CONSOLEACN]];
            TCB$TERMNAME = CONOWNR; 
            ACN$STATE [CONSOLEACN] = S"PRE$CONNECT";
            ACN$DEVTYPE [CONSOLEACN] = S"CONSOLE";
            END   # TRANSFER INFO TO TCB AND PSEUDO ACN # 
          END   # BUILD TCB AND PSEUDO ACN #
        END   # BUILD A PRE CONNECTED CONSOLE TCB AND PSEUDO ACN ENTRY #
#                                                                      #
#     CONSOLEACN NOW CONTAINS THE ACN OF A CONSOLE WHICH CAN BE USED   #
#     TO ASSOCIATE THIS BATCH DEVICE ENTRY                             #
#                                                                      #
      ACN$DEVTYPE[ACN] = COND;
      P<TCB> = ADDRESS [ACN$CB[CONSOLEACN]];
      I = TCB$SIZE + ((TCB$NDEVICE + 1) * TCB$DEVSIZE); 
CHGTCBSIZE: 
      CHGSIZE (ACN$CB[CONSOLEACN],I,0); 
      IF CHGSIZEREJ 
      THEN
        BEGIN                                    # CAN NOT CHANGE TCB  #
        CHGSIZEREJ = FALSE;                      # SIZE WAIT FOR A     #
        EVENT (CHAINS"BACKGROUND");              # WHILE               #
        GOTO CHGTCBSIZE;
        END 
      P<TCB> = ADDRESS [ACN$CB[CONSOLEACN]];
      P<TCB$DEVICE> = P<TCB> + TCB$SIZE + TCB$DEVSIZE * TCB$NDEVICE;
      P<SM$> = ADDRESS[SMBUFFER]+1; 
      TCB$NDEVICE = TCB$NDEVICE + 1;
      ACTYPE = ACT"ASCII8"; 
      ACN$CTLR [ACN] = CONSOLEACN;
      ACN$STATE [ACN] = S"CONNECTED"; 
      ACN$DEVINDEX [ACN] = ((TCB$NDEVICE - 1) * TCB$DEVSIZE) + TCB$SIZE;
      TCB$AL = CONSL ;
      TCB$DEVDT = COND; 
      TCB$DEVTC = CONT; 
      TCB$DEVBSZ = CONXBZ;
      IF CONT EQ TERMINALCLAS"$HASP$PRE" OR 
         CONT EQ TERMINALCLAS"$HASP$PST"
         OR CONT EQ TERMINALCLAS"$200UT"
      THEN                                       # HASP, M4 TERM CLASS #
        TCB$ACKFLAG = TRUE;                      # ACK FILENAME        #
      ELSE                                       # ALL OTHER TERM CLASS#
        TCB$ACKFLAG = FALSE;                     # NO ACK OF FILENAME  #
      IF ACN$DEVTYPE [ACN] EQ S"CARD$READER"
      THEN
        BEGIN # CARD READER CONNECTION #
        ACN$MODE [ACN] = UCMSTATE"UCM$STOP";     # UCM INITIAL STATE   #
        TCB$DEVUPS = CONUPS;
        P<UCB> = ADDRESS [ACN$CB [ACN]];
        UCB$TERMNAME = CONTNM;
        IF CONR 
        THEN
          UCB$RIC = 1;
        ELSE
          UCB$RIC = 0;
        END   # CARD READER CONNECTION #
      ELSE
        BEGIN # OUTPUT DEVICE CONNECTION #
        ACN$MODE [ACN] = DCMSTATE"DCM$STOP";     # DCM INITIAL STATE   #
        TCB$DEVDPS = CONDPS;
        P<DCB> = ADDRESS [ACN$CB [ACN]];
        DCB$TERMNAME = CONTNM;
        IF CONR 
        THEN
          DCB$RIC = 1;
        ELSE
          DCB$RIC = 0;
      DCB$DEVABL = CONABL;                        # APP BLOCK LIMIT    #
        TCB$ORGWIDTH = CONPW - 50;
        TCB$CURWIDTH = CONPW - 50;
        TCB$TRAIN = CONSDT;                      # SUB-DEVICE TYPE     #
        TCB$FORMS = 0;
        IF CONT NQ TERMINALCLAS"$714$30"
           AND
           CONT NQ TERMINALCLAS"$714$10"
           AND
           COND NQ DEVICETYPE"PLOTTER"
        THEN
          BEGIN 
          TCB$BANFLAG = TRUE; 
          END 
        IF ACN$DEVTYPE [ACN] EQ S"LINE$PRINTER" 
        THEN
          BEGIN # LINE PRINTER #
          TCB$FMTFLAG = TRUE; 
          DCB$PLTEMP = CONPL;  # SET PAGE LENGTH OF LINE PRINTER       #
          END   # LINE PRINTER #
        END   # OUTPUT DEVICE CONNECTION #
      TCB$DEVACN = CONACN;
      TCB$ORD = CONORD;                          # SAVE DEVICE ORDINAL #
      GOTO NEWDEVEXIT;
      END   # NEW$BATCH # 
      CONTROL EJECT;
      PROC NEW$CONSOLE; 
      BEGIN # NEW$CONSOLE # 
      FOUND = FALSE;
      FOR I = 1 STEP 1 WHILE I LQ TOTDEV + STATIONS + STATIONS AND
        NOT FOUND DO
        BEGIN # SEARCH FOR CONSOLE WITH SAME TERMINAL NAME #
        IF ACN$DEVTYPE [I] EQ S"CONSOLE"
           AND ACN$STATE [I] NQ S"NON$EXISTENT" 
        THEN
          BEGIN # A CONSOLE CONNECTION #
          P<TCB> = ADDRESS [ACN$CB [I]];
          IF CONTNM EQ TCB$TERMNAME 
          THEN
            BEGIN # FOUND CONSOLE WITH SAME ID #
            FOUND = TRUE; 
            CONSOLEACN = I; 
            END   # FOUND CONSOLE WITH SAME ID #
          END   # A CONSOLE CONNECTION #
        END   # SEARCH FOR CONSOLE WITH SAME TERMINAL NAME #
      IF FOUND
      THEN
        BEGIN # CONSOLE FOUND # 
        IF ACN$STATE [CONSOLEACN] NQ S"PRE$CONNECT" 
        THEN
          BEGIN # NOT PRE-CONNECTED STATE - ERROR # 
          BADDATA = TRUE;    # CONSOLE FOUND ALREADY CONNECTED #
          RETURN; 
          END   # NOT PRE-CONNECTED STATE - ERROR # 
        ELSE
          BEGIN # MOVE PRE CONNECTED CONSOLE INFO TO ACN$TABLE [ACN] #
          ACN$WORD [ACN] = ACN$WORD [CONSOLEACN]; 
          P<TCB> = ADDRESS [ACN$CB[ACN]]; 
          IF TCB$EVENT NQ 0 
          THEN
            BEGIN # PSEUDO CONNECTION ON THE EVENT CHAIN #
            I = ACN;
            ACN = CONSOLEACN; 
            REMOVE (CHAINS"EVENT"); 
            ACN = I;
            TCB$EVENT = 0;
            ACN$CHAIN [ACN] = 0;
            END   # PSEUDO CONNECTION ON THE EVENT CHAIN #
          ELSE
            BEGIN # PSEUDO CONNECTION NOT ON THE  EVENT CHAIN # 
            IF ACN$CHAIN [ACN] NQ 0 
            THEN
              BEGIN # PSEUDO CONNECTION  ON NON-EVENT CHAIN # 
              I = ACN;
              ACN = CONSOLEACN; 
              REMOVE (ACN$CHAIN [ACN]); 
              ACN = I;
              ACN$CHAIN [ACN] = 0;
              END   # PSEUDO CONNECTION ON NON-EVENT CHAIN #
            END   # PSEUDO CONNECTION NOT ON THE EVENT CHAIN #
          ACN$WORD [CONSOLEACN] = 0;
          ACN$STATE [CONSOLEACN] = S"NON$EXISTENT"; 
          P<TCB$DEVICE> = P<TCB> + TCB$SIZE;
          FOR I = 1 STEP 1 WHILE I LQ TCB$NDEVICE DO
            BEGIN # CHANGE BATCH DEVICE ACN$CTLR #
            ACN$CTLR [TCB$DEVACN [I]] = ACN;
            END   # CHANGE BATCH DEVICE ACN$CTLR #
          IF  TCB$EXTDIVS NQ 0         # EXT. DIVERT PENDING #
            THEN  BEGIN 
                  P<QCB> = ADDRESS[ACN$CB[QCBACN]]; 
                  FOR K = 0 STEP 1 UNTIL 1 DO 
                     BEGIN
                     IF  K  EQ  0 
                       THEN 
                         NEXT = QCB$EXTSUBF;
                       ELSE 
                         NEXT = QCB$EXTTBSF;
                     FOR I = I WHILE NEXT NQ 0 DO 
                       BEGIN
                       P<QAB> = ADDRESS[NEXT];
                       IF  QAB$ACN  EQ  CONSOLEACN
                         THEN 
                         BEGIN
                          QAB$ACN = ACN;       # RESET CONSOLE ACN #
                          IF TCB$USERNUM NQ SUPBLKS(C<0,7>SPMSG5)  OR 
                             TCB$FAMNAME NQ SUPBLKS(C<0,7>SPMSG4) 
                            THEN               # CANCEL EXT. DIVERT # 
                            BEGIN 
                            TCB$EXTDIVS = 0;
                            QAB$CANCEL = TRUE;
                            END 
                          END 
                        NEXT = QAB$NEXT;
                        END 
                    END 
                  END 
          END   # MOVE PRE-CONNECTED CONSOLE INFO TO ACN$TABLE [ACN] #
        END   # CONSOLE FOUND # 
      ELSE
        BEGIN # NOT FOUND # 
        ACN$CB[ACN] = GETBUF (TCB$SIZE,MOVEABLE); 
        IF ACN$CB [ACN] EQ 0
        THEN
          BEGIN # NO ROOM FOR TCB # 
          BADDATA = TRUE; 
          RETURN; 
          END   # NO ROOM FOR TCB # 
        END   # NOT FOUND # 
#                                                                      #
#     BUILD TCB FROM INFORMATION IN CON/REQ SM                         #
#                                                                      #
      P<TCB> = ADDRESS [ACN$CB [ACN]];
      ACN$STATE [ACN] = S"CONNECTED"; 
      ACN$DEVTYPE [ACN] = S"CONSOLE"; 
      IF ( (CONT EQ TERMINALCLAS"$200UT") OR        # 200UT TERMINAL   #
           (CONT EQ TERMINALCLAS"$734$1")   ) AND   # 734 TERMINAL     #
         (  NOT CONNET[0]                   )       # NOT CDCNET CON   #
      THEN
        BEGIN 
         ACN$MODE [ACN] = CONSOLESTATE"CON$ACTIVE"; 
        TCB$MD4A = TRUE;                         # MODE 4A TERMINAL    #
        END 
      ELSE
        BEGIN 
         ACN$MODE [ACN] = CONSOLESTATE"CON$GO"; 
        TCB$BATCH = TRUE; 
        TCB$MD4A = FALSE; 
        END 
      TCB$ALOFLAG = FALSE;             # CLEAR AUTO-LOGOUT FLAG        #
      TCB$ALOTIME = 0;                 # CLEAR INACTIVITY TIMER        #
      TCB$HWFLAG = CONHW;              # SET HARDWIRED/SWITCHED FLAG   #
      TCB$CTIM = CONCTIM;              # SET NO-TIMEOUT FLAG           #
      TCB$CDCNT = CONNET[0];           # CDCNET CONNECTION FLAG        #
      TCB$STPFLAG = FALSE;             # CLEAR FC/STP FLAG             #
      TCB$IAFFLAG = FALSE;
      TCB$ACN = ACN;
      TCB$ABL = CONABL; 
      TCB$DT = COND;
      TCB$TC = CONT;
      TCB$TERMNAME = CONTNM;
      TCB$USERNUM = SUPBLKS( C<0,7>SPMSG5 );
      TCB$FAMNAME = SUPBLKS( C<0,7>SPMSG4 );
      TCB$USERORD  = B<42,18>SPMSG5;
      TCB$FAMORD   = B<42,18>SPMSG4;
      TCB$PW = CONPW; 
      TCB$PL = CONPL; 
      TCB$BLKSIZE = CONXBZ; 
      TCB$NEXTBSN = 1;
      TCB$NXTACKSN = 1; 
      IF TCB$TC EQ TERMINALCLAS"$200UT"      # 200UT TERMINAL CLASS    #
         OR 
         TCB$TC EQ TERMINALCLAS"$734$1"      # 734 TERMINAL            #
         OR 
         TCB$TC EQ TERMINALCLAS"$714$30"
         OR 
         TCB$TC EQ TERMINALCLAS"$714$10"
         OR 
         TCB$TC EQ TERMINALCLAS"$711" 
      THEN
        BEGIN                                    # PAGE WAIT ON        #
        TCB$PAGEWAIT = TRUE;
        END 
      ELSE
        BEGIN                                    # PAGE WAIT OFF       #
        TCB$PAGEWAIT = FALSE; 
        END 
      IF CONR 
      THEN
        TCB$RIC = 1;
      ELSE
        TCB$RIC = 0;
      ACTYPE = ACT"DISPLAYCODE";
      GOTO NEWDEVEXIT;
      END   # NEW$CONSOLE # 
      CONTROL EJECT;
#                                                                      #
#     BEGIN MAIN PROCESSING OF NEW                                     #
#                                                                      #
      RELEASE = TRUE; 
      SMBUFFER = ACN$CTLR [ACN];
      ACN$CTLR [ACN] = 0; 
      BADDATA = FALSE;
      P<SM$> = ADDRESS[SMBUFFER] + 1; 
      IF CONXBZ LS 200        # FORCE 200 .LE. BLKSIZE .LE. 2043   #
      THEN
        CONXBZ = 200; 
      ELSE
        BEGIN 
        IF CONXBZ GR 2043 
        THEN
          CONXBZ = 2043;
        END 
      IF COND GR DEVICETYPE"CARD$READER"   # FOR ALL DOWNLINE BATCH    #
                                           # DEVICES, FORCE 50 .LE.    #
                                           # PAGE WIDTH .LE. 150 .     #
      THEN
        BEGIN 
        IF CONPW LS 50
        THEN
          CONPW  =  50; 
        ELSE
          BEGIN 
          IF CONPW GR 150 
          THEN
            CONPW  =  150;
          END 
        END 
      IF COND EQ DT$INTA
        OR COND EQ DT$INTE
        OR COND EQ DT$CLP 
      THEN
        BADDATA = TRUE; 
      ELSE
        BEGIN 
        IF COND EQ DEVICETYPE"CONSOLE"
        THEN
          NEW$CONSOLE;
        ELSE
          NEW$BATCH;
        END 
NEWDEVEXIT: 
      IF RELEASE
      THEN
        BEGIN # SEND A CON/REQ AND RELEASE THE SM BUFFER #
        P<ABH> = ADDRESS [SMBUFFER];
        P<SM$> = P<ABH> + 1;
        EB = BADDATA; 
        RB = NOT EB;
        ABH$DBC = 0;
        ABH$TLC = LCORQR; 
        CONRRQ = 0; 
        CONBDD[0] = FALSE;             # DO NOT DISCARD BLKS AFTER BRK #
        CONSCT[0] = FALSE;             # SYNC SUP MSG ACT = 2          #
        CONNXP[0] = FALSE;             # DO NOT DISCARD TRANS INPUT    #
        CONALN = ALN;                  # APPLICATION LIST NUMBER       #
        CONACT = ACTYPE;
        NETPUT (ABH,SM$); 
        IF BADDATA
        THEN
          BEGIN 
          IF ACN$CB[ACN] NQ 0           # RETURN THE CONTROL BLOCK IF  #
          THEN                          # THERE IS ONE.                #
            RETTSB(ACN$CB[ACN]);
            SETUPACN (ACN); 
          ACN$WORD [ACN] = 0; 
          END 
        RETTSB (SMBUFFER);
        SETUPACN (ACN); 
        END  # SEND A CON/REQ AND RELEASE THE SM BUFFER # 
      GOTO CALLRTN; 
      END   # NEW # 
      TERM; 
