; 0001 MODULE KERTRM (IDENT = '2.0.005' ; 0002 ) = ; 0003 BEGIN ; 0004 ! ; 0005 ; 0006 !++ ; 0007 ! FACILITY: ; 0008 ! ; 0009 ! KERMIT-32 terminal processing. ; 0010 ! ; 0011 ! ABSTRACT: ; 0012 ! ; 0013 ! This module will do all of the terminal processing for KERMIT-32. ; 0014 ! It contains the output routines for the terminal to send and ; 0015 ! receive messages as well as the routines to output text for debugging. ; 0016 ! ; 0017 ! ENVIRONMENT: ; 0018 ! ; 0019 ! VAX/VMS user mode. ; 0020 ! ; 0021 ! AUTHOR: Robert C. McQueen, CREATION DATE: 25-March-1983 ; 0022 !-- ; 0023 ; 0024 %SBTTL 'Table of Contents' ; 0025 ! ; 0026 ! TABLE OF CONTENTS: ; 0027 ! ; 0028 %SBTTL 'Revision History' ; 0029 ; 0030 !++ ; 0031 ! ; 0032 ! Start of version 1. 25-March-1983 ; 0033 ! ; 0034 ! 1.0.000 By: Robert C. McQueen On: 25-March-1983 ; 0035 ! Create this module. ; 0036 ! ; 0037 ! 1.1.001 By: W. Hom On: 6-July-83 ; 0038 ! Implement CONNECT command. ; 0039 ! ; 0040 ! 1.1.002 By: Nick Bush On: 7-July-83 ; 0041 ! Fix RECEIVE QIO to time out correctly. ; 0042 ! ; 0043 ! 1.2.003 By: Robert C. McQueen On: 16-Aug-83 ; 0044 ! Get the status correctly for the SS$_TIMEOUT checks. ; 0045 ! ; 0046 ! 1.2.004 By: Robert C. McQueen On: 9-Sept-1983 ; 0047 ! Flag if we just opened the terminal, so that we can ; 0048 ! clear the input that is coming into the terminal. This ; 0049 ! will clear up some of the junk that we get on start up. ; 0050 ! ; 0051 ! 2.0.005 Release VAX/VMS Kermit-32 version 2.0 ; 0052 ! ; 0053 !-- ; 0054 ; 0055 %SBTTL 'Library files' ; 0056 ! ; 0057 ! INCLUDE FILES: ; 0058 ! ; 0059 ! ; 0060 ! System definitions ; 0061 ! ; 0062 ; 0063 LIBRARY 'SYS$LIBRARY:STARLET'; ; 0064 ; 0065 ! ; 0066 ! KERMIT common definitions ; 0067 ! ; 0068 ; 0069 REQUIRE 'KERCOM'; ; 0239 ; 0240 REQUIRE 'KERERR'; ; 0292 ; 0293 %SBTTL 'Structure definitions -- $GETDVI arguments' ; 0294 ! ; 0295 ! $GETDVI interface fields and structure definition ; 0296 ! ; 0297 ; 0298 LITERAL ; 0299 DVI_SIZE = 3; ! Length of a DVI item list entry ; 0300 ; 0301 ! ; 0302 ! Fields for accessing the items in a DVI item list ; 0303 ! ; 0304 ; 0305 FIELD ; 0306 DVI_FIELDS = ; 0307 SET ; 0308 DVI_BFR_LENGTH = [0, 0, 16, 0], ; 0309 DVI_ITEM_CODE = [0, 16, 16, 0], ; 0310 DVI_BFR_ADDRESS = [1, 0, 32, 0], ; 0311 DVI_RTN_LENGTH = [2, 0, 32, 0] ; 0312 TES; ; 0313 ; 0314 ! ; 0315 ! Structure definition for item list ; 0316 ; 0317 STRUCTURE ; 0318 DVI_ITEM_LIST [I, O, P, S, E; N] = ; 0319 [(N + 1)*DVI_SIZE*4] ; 0320 (DVI_ITEM_LIST + ((I*DVI_SIZE) + O)*4); ; 0321 ; 0322 %SBTTL 'Structures definitions -- Terminal characteristics' ; 0323 ! ; 0324 ! Terminal characteristics words ; 0325 ! ; 0326 ; 0327 LITERAL ; 0328 TC$_CHAR_LENGTH = 12; ; 0329 ; 0330 ! ; 0331 ! Fields for accessing the items in a characteristic block ; 0332 ! ; 0333 ; 0334 FIELD ; 0335 TC$_FIELDS = ; 0336 SET ; 0337 TC$_CLASS = [0, 0, 8, 0], ; 0338 TC$_TYPE = [0, 8, 8, 0], ; 0339 TC$_BFR_SIZE = [0, 16, 16, 0], ; 0340 TC$_PAGE_LEN = [1, 24, 8, 0], ; 0341 TC$_CHAR = [1, 0, 24, 0], ; 0342 TC$_CHAR_2 = [2, 0, 32, 0] ; 0343 TES; ; 0344 ; 0345 ! ; 0346 ! Structure definition for item list ; 0347 ! ; 0348 ; 0349 STRUCTURE ; 0350 TC$_CHAR_STR [O, P, S, E; N] = ; 0351 [TC$_CHAR_LENGTH] ; 0352 (TC$_CHAR_STR + O*4); ; 0353 ; 0354 %SBTTL 'Literals' ; 0355 ! ; 0356 ! Literal definitions ; 0357 ! ; 0358 ; 0359 LITERAL ; 0360 RECV_BUFF_SIZE = MAX_MSG + 20, ! Size of receive buffer ; 0361 TIME_EFN = 3, ! Event flag number for receive timer ; 0362 TERM_EFN = 2; ! Event flag number to use for Terminal input ; 0363 ; 0364 %SBTTL 'Storage' ; 0365 ! ; 0366 ! OWN STORAGE: ; 0367 ! ; 0368 ; 0369 OWN ; 0370 TEXT_DESC : BLOCK [8, BYTE]; ; 0371 ; 0372 ! ; 0373 ! Communications routines storage ; 0374 ! ; 0375 ; 0376 OWN ; 0377 TERM_FIRST_TIME, ! First time QIO to read done ; 0378 TERM_CHAN, ! Channel the terminal is opened on ; 0379 CONS_CHAN, ! Channel the console terminal is opened on ; 0380 IO_STATUS : VECTOR [4, WORD], ! IOSB for receive QIO ; 0381 RECV_BUFFER : VECTOR [CH$ALLOCATION (RECV_BUFF_SIZE, CHR_SIZE)], ! Input buffer ; 0382 OLD_PARITY : BLOCK [8, BYTE], ! Old IOSB information ; 0383 OLD_TERM_CHAR : TC$_CHAR_STR FIELD (TC$_FIELDS), ! Old terminal chars ; 0384 NEW_TERM_CHAR : TC$_CHAR_STR FIELD (TC$_FIELDS); ! New terminal chars ; 0385 ; 0386 GLOBAL ; 0387 TERM_FLAG; ! Terminal open flag ; 0388 ; 0389 %SBTTL 'External routines' ; 0390 ! ; 0391 ! EXTERNAL REFERENCES: ; 0392 ! ; 0393 ! ; 0394 ! System library routines ; 0395 ! ; 0396 ; 0397 EXTERNAL ROUTINE ; 0398 LIB$PUT_SCREEN : ADDRESSING_MODE (GENERAL), ; 0399 LIB$PUT_OUTPUT : ADDRESSING_MODE (GENERAL), ; 0400 LIB$EMUL : ADDRESSING_MODE (GENERAL), ; 0401 LIB$ADDX : ADDRESSING_MODE (GENERAL), ; 0402 LIB$SIGNAL : ADDRESSING_MODE (GENERAL); ; 0403 ; 0404 ! ; 0405 ! Forward routines: ; 0406 ! ; 0407 ; 0408 FORWARD ROUTINE ; 0409 DO_RECEIVE_QIO, ; 0410 DO_CONS_QIO; ; 0411 ; 0412 %SBTTL 'External storage' ; 0413 ; 0414 !++ ; 0415 ! The following is the various external storage locations that are ; 0416 ! referenced from this module. ; 0417 !-- ; 0418 ; 0419 ! ; 0420 ! KERMSG storage ; 0421 ! ; 0422 ; 0423 EXTERNAL ; 0424 PARITY_TYPE, ! Type of parity being used ; 0425 IBM_FLAG, ! True if IBM mode ; 0426 IBM_CHAR, ! IBM mode turn-around character ; 0427 RCV_EOL, ! Receive EOL character ; 0428 RCV_TIMEOUT, ! Receive time out counter ; 0429 CONNECT_FLAG; ! Flag if communications line is TT: ; 0430 ; 0431 ! ; 0432 ! KERMIT storage ; 0433 ! ; 0434 ; 0435 EXTERNAL ; 0436 ESCAPE_CHR, ! Escape char. for CONNECT. ; 0437 TERM_NAME, ! Terminal name ; 0438 TERM_DESC : BLOCK [8, BYTE]; ! Descriptor for terminal name ; 0439 ; 0440 %SBTTL 'Terminal routines -- TERM_INIT - Initialize this module' ; 0441 ; 0442 GLOBAL ROUTINE TERM_INIT : NOVALUE = ; 0443 ; 0444 !++ ; 0445 ! FUNCTIONAL DESCRIPTION: ; 0446 ! ; 0447 ! This routine will initialize the terminal processing module. It will ; 0448 ! initialize the various data locations in this module. ; 0449 ! ; 0450 ! CALLING SEQUENCE: ; 0451 ! ; 0452 ! TERM_INIT(); ; 0453 ! ; 0454 ! INPUT PARAMETERS: ; 0455 ! ; 0456 ! None. ; 0457 ! ; 0458 ! IMPLICIT INPUTS: ; 0459 ! ; 0460 ! None. ; 0461 ! ; 0462 ! OUTPUT PARAMETERS: ; 0463 ! ; 0464 ! None. ; 0465 ! ; 0466 ! IMPLICIT OUTPUTS: ; 0467 ! ; 0468 ! None. ; 0469 ! ; 0470 ! COMPLETION CODES: ; 0471 ! ; 0472 ! None. ; 0473 ! ; 0474 ! SIDE EFFECTS: ; 0475 ! ; 0476 ! None. ; 0477 ! ; 0478 !-- ; 0479 ; 0480 BEGIN ; 0481 ! ; 0482 ! Initialize the text descriptor ; 0483 ! ; 0484 TEXT_DESC [DSC$B_CLASS] = DSC$K_CLASS_S; ; 0485 TEXT_DESC [DSC$B_DTYPE] = DSC$K_DTYPE_T; ; 0486 TEXT_DESC [DSC$W_LENGTH] = 0; ; 0487 ! ; 0488 ! Set up the terminal name descriptor ; 0489 ! ; 0490 TERM_DESC [DSC$B_CLASS] = DSC$K_CLASS_S; ; 0491 TERM_DESC [DSC$B_DTYPE] = DSC$K_DTYPE_T; ; 0492 TERM_DESC [DSC$A_POINTER] = TERM_NAME; ; 0493 TERM_DESC [DSC$W_LENGTH] = 12; ; 0494 CH$COPY (10, CH$PTR (UPLIT ('SYS$INPUT:')), 0, 11, CH$PTR (TERM_NAME)); ; 0495 ! ; 0496 ! Initialize the flags ; 0497 ! ; 0498 TERM_FLAG = FALSE; ; 0499 END; ! End of TERM_INIT .TITLE KERTRM .IDENT \2.0.005\ .PSECT $PLIT$,NOWRT,NOEXE,2 P.AAA: .ASCII \SYS$INPUT:\<0><0> ; ; .PSECT $OWN$,NOEXE,2 ;TEXT_DESC U.1: .BLKB 8 ;TERM_FIRST_TIME U.2: .BLKB 4 ;TERM_CHAN U.3: .BLKB 4 ;CONS_CHAN U.4: .BLKB 4 ;IO_STATUS U.5: .BLKB 8 ;RECV_BUFFER U.6: .BLKB 116 ;OLD_PARITY U.7: .BLKB 8 ;OLD_TERM_CHAR U.8: .BLKB 12 ;NEW_TERM_CHAR U.9: .BLKB 12 .PSECT $GLOBAL$,NOEXE,2 TERM_FLAG:: .BLKB 4 PR_MIN== 0 PR_NONE== 0 PR_MARK== 1 PR_EVEN== 2 PR_ODD== 3 PR_SPACE== 4 PR_MAX== 4 GC_MIN== 0 GC_LOGOUT== 0 GC_EXIT== 1 GC_MAX== 1 DP_FULL== 0 DP_HALF== 1 CHK_1CHAR== 49 CHK_2CHAR== 50 CHK_CRC== 51 MAX_MSG== 96 .EXTRN LIB$PUT_SCREEN, LIB$PUT_OUTPUT, LIB$EMUL, LIB$ADDX, LIB$SIGNAL, PARITY_TYPE, IBM_FLAG .EXTRN IBM_CHAR, RCV_EOL, RCV_TIMEOUT, CONNECT_FLAG, ESCAPE_CHR, TERM_NAME, TERM_DESC .PSECT $CODE$,NOWRT,2 .ENTRY TERM_INIT, ^M ;TERM_INIT, Save R2,R3,R4,R5 ; 0442 MOVL #17694720, W^U.1 ;#17694720, U.1 ; 0486 MOVL #17694732, W^TERM_DESC ;#17694732, TERM_DESC ; 0493 MOVAB W^TERM_NAME, W^TERM_DESC+4 ;TERM_NAME, TERM_DESC+4 ; 0492 MOVC5 #10, W^P.AAA, #0, #11, W^TERM_NAME ;#10, P.AAA, #0, #11, TERM_NAME ; 0494 CLRL W^TERM_FLAG ;TERM_FLAG ; 0498 RET ; ; 0442 ; Routine Size: 42 bytes, Routine Base: $CODE$ + 0000 ; 0500 ; 0501 %SBTTL 'TERM_DUMP - This routine will dump text on the terminal' ; 0502 ; 0503 GLOBAL ROUTINE TERM_DUMP (BUFFER_ADDRESS, BUFFER_COUNT) : NOVALUE = ; 0504 ; 0505 !++ ; 0506 ! FUNCTIONAL DESCRIPTION: ; 0507 ! ; 0508 ! This routine will dump the text specified on the user's terminal. ; 0509 ! It will then return to the caller. ; 0510 ! ; 0511 ! CALLING SEQUENCE: ; 0512 ! ; 0513 ! TERM_DUMP( TEXT-BUFFER-ADDRESS, COUNT) ; 0514 ! ; 0515 ! INPUT PARAMETERS: ; 0516 ! ; 0517 ! TEXT-BUFFER-ADDRESS - Address of the buffer containing the characters. ; 0518 ! ; 0519 ! COUNT - Count of the characters in the buffer. ; 0520 ! ; 0521 ! IMPLICIT INPUTS: ; 0522 ! ; 0523 ! None. ; 0524 ! ; 0525 ! OUPTUT PARAMETERS: ; 0526 ! ; 0527 ! None. ; 0528 ! ; 0529 ! IMPLICIT OUTPUTS: ; 0530 ! ; 0531 ! None. ; 0532 ! ; 0533 ! COMPLETION CODES: ; 0534 ! ; 0535 ! None. ; 0536 ! ; 0537 ! SIDE EFFECTS: ; 0538 ! ; 0539 ! None. ; 0540 ! ; 0541 !-- ; 0542 ; 0543 BEGIN ; 0544 LOCAL ; 0545 TEXT_DESC : BLOCK [8, BYTE]; ; 0546 ; 0547 IF NOT .CONNECT_FLAG ; 0548 THEN ; 0549 BEGIN ; 0550 IF .TERM_FLAG THEN ; P 0551 $QIOW (CHAN = .CONS_CHAN, FUNC = IO$_WRITEVBLK OR IO$M_NOFORMAT, ; 0552 P1 = .BUFFER_ADDRESS, P2 = .BUFFER_COUNT) ; 0553 ELSE ; 0554 BEGIN ; 0555 TEXT_DESC [DSC$B_CLASS] = DSC$K_CLASS_S; ; 0556 TEXT_DESC [DSC$B_DTYPE] = DSC$K_DTYPE_T; ; 0557 TEXT_DESC [DSC$W_LENGTH] = .BUFFER_COUNT; ; 0558 TEXT_DESC [DSC$A_POINTER] = .BUFFER_ADDRESS; ; 0559 LIB$PUT_OUTPUT(TEXT_DESC); ; 0560 END; ; 0561 END; ; 0562 ; 0563 END; ! End of TERM_DUMP .EXTRN SYS$QIOW .ENTRY TERM_DUMP, ^M<> ;TERM_DUMP, Save nothing ; 0503 SUBL2 #8, SP ;#8, SP ; BLBS W^CONNECT_FLAG, 2$ ;CONNECT_FLAG, 2$ ; 0547 BLBC W^TERM_FLAG, 1$ ;TERM_FLAG, 1$ ; 0550 CLRQ -(SP) ;-(SP) ; 0552 CLRQ -(SP) ;-(SP) ; MOVQ 4(AP), -(SP) ;BUFFER_ADDRESS, -(SP) ; CLRQ -(SP) ;-(SP) ; CLRL -(SP) ;-(SP) ; MOVZWL #304, -(SP) ;#304, -(SP) ; PUSHL W^U.4 ;U.4 ; CLRL -(SP) ;-(SP) ; CALLS #12, G^SYS$QIOW ;#12, SYS$QIOW ; RET ; ; 0550 1$: MOVW #270, 2(SP) ;#270, TEXT_DESC+2 ; 0556 MOVW 8(AP), (SP) ;BUFFER_COUNT, TEXT_DESC ; 0557 MOVL 4(AP), 4(SP) ;BUFFER_ADDRESS, TEXT_DESC+4 ; 0558 PUSHL SP ;SP ; 0559 CALLS #1, G^LIB$PUT_OUTPUT ;#1, LIB$PUT_OUTPUT ; 2$: RET ; ; 0503 ; Routine Size: 71 bytes, Routine Base: $CODE$ + 002A ; 0564 ; 0565 %SBTTL 'DBG_DUMP - This routine will dump text on the terminal' ; 0566 ; 0567 GLOBAL ROUTINE DBG_DUMP (BUFFER_ADDRESS, BUFFER_COUNT) : NOVALUE = ; 0568 ; 0569 !++ ; 0570 ! FUNCTIONAL DESCRIPTION: ; 0571 ! ; 0572 ! This routine will dump the text specified on the user's terminal. ; 0573 ! It will then return to the caller. ; 0574 ! ; 0575 ! CALLING SEQUENCE: ; 0576 ! ; 0577 ! DBG_DUMP( TEXT-BUFFER-ADDRESS, COUNT) ; 0578 ! ; 0579 ! INPUT PARAMETERS: ; 0580 ! ; 0581 ! TEXT-BUFFER-ADDRESS - Address of the buffer containing the characters. ; 0582 ! ; 0583 ! COUNT - Count of the characters in the buffer. ; 0584 ! ; 0585 ! IMPLICIT INPUTS: ; 0586 ! ; 0587 ! None. ; 0588 ! ; 0589 ! OUPTUT PARAMETERS: ; 0590 ! ; 0591 ! None. ; 0592 ! ; 0593 ! IMPLICIT OUTPUTS: ; 0594 ! ; 0595 ! None. ; 0596 ! ; 0597 ! COMPLETION CODES: ; 0598 ! ; 0599 ! None. ; 0600 ! ; 0601 ! SIDE EFFECTS: ; 0602 ! ; 0603 ! None. ; 0604 ! ; 0605 !-- ; 0606 ; 0607 BEGIN ; 0608 LOCAL ; 0609 TEXT_DESC : BLOCK [8, BYTE]; ; 0610 ; 0611 IF NOT .CONNECT_FLAG ; 0612 THEN ; 0613 BEGIN ; 0614 IF .TERM_FLAG THEN ; P 0615 $QIOW (CHAN = .CONS_CHAN, FUNC = IO$_WRITEVBLK OR IO$M_NOFORMAT, ; 0616 P1 = .BUFFER_ADDRESS, P2 = .BUFFER_COUNT) ; 0617 ELSE ; 0618 BEGIN ; 0619 TEXT_DESC [DSC$B_CLASS] = DSC$K_CLASS_S; ; 0620 TEXT_DESC [DSC$B_DTYPE] = DSC$K_DTYPE_T; ; 0621 TEXT_DESC [DSC$W_LENGTH] = .BUFFER_COUNT; ; 0622 TEXT_DESC [DSC$A_POINTER] = .BUFFER_ADDRESS; ; 0623 LIB$PUT_OUTPUT(TEXT_DESC); ; 0624 END; ; 0625 END; ; 0626 END; ! End of DBG_DUMP .ENTRY DBG_DUMP, ^M<> ;DBG_DUMP, Save nothing ; 0567 SUBL2 #8, SP ;#8, SP ; BLBS W^CONNECT_FLAG, 2$ ;CONNECT_FLAG, 2$ ; 0611 BLBC W^TERM_FLAG, 1$ ;TERM_FLAG, 1$ ; 0614 CLRQ -(SP) ;-(SP) ; 0616 CLRQ -(SP) ;-(SP) ; MOVQ 4(AP), -(SP) ;BUFFER_ADDRESS, -(SP) ; CLRQ -(SP) ;-(SP) ; CLRL -(SP) ;-(SP) ; MOVZWL #304, -(SP) ;#304, -(SP) ; PUSHL W^U.4 ;U.4 ; CLRL -(SP) ;-(SP) ; CALLS #12, G^SYS$QIOW ;#12, SYS$QIOW ; RET ; ; 0614 1$: MOVW #270, 2(SP) ;#270, TEXT_DESC+2 ; 0620 MOVW 8(AP), (SP) ;BUFFER_COUNT, TEXT_DESC ; 0621 MOVL 4(AP), 4(SP) ;BUFFER_ADDRESS, TEXT_DESC+4 ; 0622 PUSHL SP ;SP ; 0623 CALLS #1, G^LIB$PUT_OUTPUT ;#1, LIB$PUT_OUTPUT ; 2$: RET ; ; 0567 ; Routine Size: 71 bytes, Routine Base: $CODE$ + 0071 ; 0627 ; 0628 %SBTTL 'Communcations line -- TERM_OPEN' ; 0629 ; 0630 GLOBAL ROUTINE TERM_OPEN = ; 0631 ; 0632 !++ ; 0633 ! FUNCTIONAL DESCRIPTION: ; 0634 ! ; 0635 ! This routine will assign a channel that is used in the CONNECT ; 0636 ! processing and to send/receive a file from. ; 0637 ! ; 0638 ! CALLING SEQUENCE: ; 0639 ! ; 0640 ! TERM_OPEN(); ; 0641 ! ; 0642 ! INPUT PARAMETERS: ; 0643 ! ; 0644 ! None. ; 0645 ! ; 0646 ! IMPLICIT INPUTS: ; 0647 ! ; 0648 ! TERM_DESC - Descriptor of a vector of ASCII characters that represent ; 0649 ! the name of the terminal to use. ; 0650 ! ; 0651 ! OUTPUT PARAMETERS: ; 0652 ! ; 0653 ! None. ; 0654 ! ; 0655 ! IMPLICIT OUTPUTS: ; 0656 ! ; 0657 ! TERM_CHAN - Channel number of the terminal line we are using. ; 0658 ! ; 0659 ! COMPLETION CODES: ; 0660 ! ; 0661 ! SS$_NORMAL or error condition. ; 0662 ! ; 0663 ! SIDE EFFECTS: ; 0664 ! ; 0665 ! None. ; 0666 ! ; 0667 !-- ; 0668 ; 0669 BEGIN ; 0670 ; 0671 BIND ; 0672 SYS_OUTPUT = %ASCID'TT:'; ; 0673 ; 0674 LOCAL ; 0675 STATUS, ; 0676 OUTPUT_ITM : DVI_ITEM_LIST [2] FIELD (DVI_FIELDS), ; 0677 OUTPUT_NAME : VECTOR [65, BYTE], ; 0678 OUTPUT_LENGTH, ; 0679 OUTPUT_CLASS, ; 0680 OUTPUT_STATUS, ; 0681 TERM_ITM : DVI_ITEM_LIST [2] FIELD (DVI_FIELDS), ; 0682 TERM_NAME : VECTOR [65, BYTE], ; 0683 TERM_LENGTH, ; 0684 TERM_CLASS, ; 0685 TERM_STATUS; ; 0686 ; 0687 ! ; 0688 ! Initialize the first character to be an underscore, incase we have a ; 0689 ! concealed device name ; 0690 ! ; 0691 OUTPUT_NAME [0] = %C'_'; ; 0692 TERM_NAME [0] = %C'_'; ; 0693 ! ; 0694 ! Initialize the GETDVI call for the TT: ; 0695 ! ; 0696 OUTPUT_ITM [0, DVI_ITEM_CODE] = DVI$_DEVCLASS; ; 0697 OUTPUT_ITM [0, DVI_BFR_LENGTH] = 4; ; 0698 OUTPUT_ITM [0, DVI_BFR_ADDRESS] = OUTPUT_CLASS; ; 0699 OUTPUT_ITM [0, DVI_RTN_LENGTH] = 0; ; 0700 ! ; 0701 OUTPUT_ITM [1, DVI_ITEM_CODE] = DVI$_DEVNAM; ; 0702 OUTPUT_ITM [1, DVI_BFR_LENGTH] = 64; ; 0703 OUTPUT_ITM [1, DVI_BFR_ADDRESS] = OUTPUT_NAME [1]; ; 0704 OUTPUT_ITM [1, DVI_RTN_LENGTH] = OUTPUT_LENGTH; ; 0705 ! ; 0706 OUTPUT_ITM [2, DVI_ITEM_CODE] = 0; ; 0707 OUTPUT_ITM [2, DVI_BFR_LENGTH] = 0; ; 0708 ! ; 0709 ! Initialize the GETDVI call for the terminal name given ; 0710 ! ; 0711 TERM_ITM [0, DVI_ITEM_CODE] = DVI$_DEVCLASS; ; 0712 TERM_ITM [0, DVI_BFR_LENGTH] = 4; ; 0713 TERM_ITM [0, DVI_BFR_ADDRESS] = TERM_CLASS; ; 0714 TERM_ITM [0, DVI_RTN_LENGTH] = 0; ; 0715 ! ; 0716 TERM_ITM [1, DVI_ITEM_CODE] = DVI$_DEVNAM; ; 0717 TERM_ITM [1, DVI_BFR_LENGTH] = 64; ; 0718 TERM_ITM [1, DVI_BFR_ADDRESS] = TERM_NAME [1]; ; 0719 TERM_ITM [1, DVI_RTN_LENGTH] = TERM_LENGTH; ; 0720 ! ; 0721 TERM_ITM [2, DVI_ITEM_CODE] = 0; ; 0722 TERM_ITM [2, DVI_BFR_LENGTH] = 0; ; 0723 ! ; 0724 ! Get the device information ; 0725 ! ; 0726 OUTPUT_STATUS = $GETDVI (EFN = TERM_EFN, DEVNAM = SYS_OUTPUT, ITMLST = OUTPUT_ITM); ; 0727 ; 0728 IF NOT .OUTPUT_STATUS ; 0729 THEN ; 0730 BEGIN ; 0731 LIB$SIGNAL (.OUTPUT_STATUS); ; 0732 RETURN .OUTPUT_STATUS; ; 0733 END; ; 0734 ; 0735 STATUS = $WAITFR (EFN = TERM_EFN); ; 0736 ; 0737 IF NOT .STATUS ; 0738 THEN ; 0739 BEGIN ; 0740 LIB$SIGNAL (.STATUS); ; 0741 RETURN .STATUS; ; 0742 END; ; 0743 ; 0744 ! ; 0745 ! For both of the device names ; 0746 ! ; 0747 TERM_STATUS = $GETDVI (EFN = TERM_EFN, DEVNAM = TERM_DESC, ITMLST = TERM_ITM); ; 0748 ; 0749 IF NOT .TERM_STATUS ; 0750 THEN ; 0751 BEGIN ; 0752 LIB$SIGNAL (.TERM_STATUS); ; 0753 RETURN .TERM_STATUS; ; 0754 END; ; 0755 ; 0756 STATUS = $WAITFR (EFN = TERM_EFN); ; 0757 ; 0758 IF NOT .STATUS ; 0759 THEN ; 0760 BEGIN ; 0761 LIB$SIGNAL (.STATUS); ; 0762 RETURN .STATUS; ; 0763 END; ; 0764 ; 0765 ! ; 0766 ! Make sure that they are terminals ; 0767 ! ; 0768 ; 0769 IF .TERM_CLASS EQL DC$_TERM AND .OUTPUT_CLASS EQL DC$_TERM ; 0770 THEN ; 0771 BEGIN ; 0772 ; 0773 IF CH$NEQ (.OUTPUT_LENGTH, CH$PTR (.OUTPUT_ITM [1, DVI_BFR_ADDRESS]), .TERM_LENGTH, ; 0774 CH$PTR (.TERM_ITM [1, DVI_BFR_ADDRESS]), CHR_NUL) ; 0775 THEN ; 0776 CONNECT_FLAG = FALSE ; 0777 ELSE ; 0778 CONNECT_FLAG = TRUE; ; 0779 ; 0780 END ; 0781 ELSE ; 0782 BEGIN ; 0783 RETURN KER_LINTERM; ; 0784 END; ; 0785 ; 0786 STATUS = $ASSIGN (DEVNAM = TERM_DESC, CHAN = TERM_CHAN); ; 0787 ; 0788 IF NOT .STATUS ; 0789 THEN ; 0790 BEGIN ; 0791 LIB$SIGNAL (.STATUS); ; 0792 RETURN .STATUS; ; 0793 END; ; 0794 ; 0795 ! ; 0796 ! If we are not sending data on the console terminal, open it up as well, ; 0797 ! since we will want to be able to capture command characters from it. ; 0798 ! ; 0799 ; 0800 IF NOT .CONNECT_FLAG ; 0801 THEN ; 0802 BEGIN ; 0803 STATUS = $ASSIGN (DEVNAM = SYS_OUTPUT, CHAN = CONS_CHAN); ; 0804 ; 0805 IF NOT .STATUS ; 0806 THEN ; 0807 BEGIN ; 0808 LIB$SIGNAL (.STATUS); ; 0809 RETURN .STATUS; ; 0810 END; ; 0811 ; 0812 END; ; 0813 ; P 0814 STATUS = $QIOW (CHAN = .TERM_CHAN, FUNC = IO$_SENSEMODE, P1 = OLD_TERM_CHAR, ; 0815 P2 = TC$_CHAR_LENGTH, IOSB = OLD_PARITY); ; 0816 ; 0817 IF NOT .STATUS ; 0818 THEN ; 0819 BEGIN ; 0820 LIB$SIGNAL (.STATUS); ; 0821 RETURN .STATUS; ; 0822 END; ; 0823 ; 0824 NEW_TERM_CHAR [TC$_BFR_SIZE] = .OLD_TERM_CHAR [TC$_BFR_SIZE]; ; 0825 NEW_TERM_CHAR [TC$_TYPE] = .OLD_TERM_CHAR [TC$_TYPE]; ; 0826 NEW_TERM_CHAR [TC$_CLASS] = .OLD_TERM_CHAR [TC$_CLASS]; ; 0827 NEW_TERM_CHAR [TC$_PAGE_LEN] = .OLD_TERM_CHAR [TC$_PAGE_LEN]; ; 0828 NEW_TERM_CHAR [TC$_CHAR] = (.OLD_TERM_CHAR [TC$_CHAR] OR TT$M_EIGHTBIT OR TT$M_NOBRDCST) AND NOT ; 0829 (TT$M_CRFILL OR TT$M_LFFILL OR TT$M_WRAP); ; 0830 NEW_TERM_CHAR [TC$_CHAR_2] = .OLD_TERM_CHAR [TC$_CHAR_2] OR TT2$M_XON; ; P 0831 STATUS = $QIOW (CHAN = .TERM_CHAN, FUNC = IO$_SETMODE, P1 = NEW_TERM_CHAR, ; 0832 P2 = TC$_CHAR_LENGTH, P5 = TT$M_ALTRPAR); ; 0833 ; 0834 IF NOT .STATUS ; 0835 THEN ; 0836 BEGIN ; 0837 LIB$SIGNAL (.STATUS); ; 0838 RETURN .STATUS; ; 0839 END; ; 0840 ; 0841 TERM_FLAG = TRUE; ! Terminal now open ; 0842 TERM_FIRST_TIME = TRUE; ! Flag first time QIO should clear input ; 0843 ! ; 0844 ! Now post the initial receive QIO ; 0845 ! ; 0846 STATUS = DO_RECEIVE_QIO (); ; 0847 ; 0848 IF NOT .STATUS ; 0849 THEN ; 0850 BEGIN ; 0851 LIB$SIGNAL (.STATUS); ; 0852 RETURN KER_RECERR; ; 0853 END; ; 0854 ; 0855 ! ; 0856 ! Also post the QIO for the console ; 0857 ! ; 0858 ; 0859 IF NOT .CONNECT_FLAG ; 0860 THEN ; 0861 BEGIN ; 0862 STATUS = DO_CONS_QIO (); ; 0863 ; 0864 IF NOT .STATUS ; 0865 THEN ; 0866 BEGIN ; 0867 LIB$SIGNAL (.STATUS); ; 0868 $CANCEL (CHAN = .TERM_CHAN); ; 0869 $DASSGN (CHAN = .TERM_CHAN); ; 0870 RETURN KER_RECERR; ; 0871 END; ; 0872 ; 0873 END; ; 0874 ; 0875 RETURN KER_NORMAL; ; 0876 END; ! End of TERM_OPEN .PSECT $PLIT$,NOWRT,NOEXE,2 P.AAC: .ASCII \TT:\<0> ; ; P.AAB: .LONG 17694723 ; ; .ADDRESS P.AAC ; ; U.17= P.AAB .EXTRN SYS$GETDVI, SYS$WAITFR, SYS$ASSIGN, SYS$CANCEL, SYS$DASSGN .PSECT $CODE$,NOWRT,2 .ENTRY TERM_OPEN, ^M ; ; MOVAB G^SYS$QIOW, R11 ;SYS$QIOW, R11 ; MOVAB G^SYS$ASSIGN, R10 ;SYS$ASSIGN, R10 ; MOVAB W^CONNECT_FLAG, R9 ;CONNECT_FLAG, R9 ; MOVAB G^SYS$WAITFR, R8 ;SYS$WAITFR, R8 ; MOVAB G^SYS$GETDVI, R7 ;SYS$GETDVI, R7 ; MOVAB G^LIB$SIGNAL, R6 ;LIB$SIGNAL, R6 ; MOVAB W^U.3, R5 ;U.3, R5 ; MOVAB -224(SP), SP ;-224(SP), SP ; MOVB #95, 120(SP) ;#95, OUTPUT_NAME ; 0691 MOVB #95, 16(SP) ;#95, TERM_NAME ; 0692 MOVL #262148, -36(FP) ;#262148, OUTPUT_ITM ; 0697 MOVAB 12(SP), -32(FP) ;OUTPUT_CLASS, OUTPUT_ITM+4 ; 0698 CLRL -28(FP) ;OUTPUT_ITM+8 ; 0699 MOVL #2097216, -24(FP) ;#2097216, OUTPUT_ITM+12 ; 0702 MOVAB 121(SP), -20(FP) ;OUTPUT_NAME+1, OUTPUT_ITM+16 ; 0703 MOVAB 8(SP), -16(FP) ;OUTPUT_LENGTH, OUTPUT_ITM+20 ; 0704 CLRL -12(FP) ;OUTPUT_ITM+24 ; 0707 MOVL #262148, 84(SP) ;#262148, TERM_ITM ; 0712 MOVAB 4(SP), 88(SP) ;TERM_CLASS, TERM_ITM+4 ; 0713 CLRL 92(SP) ;TERM_ITM+8 ; 0714 MOVL #2097216, 96(SP) ;#2097216, TERM_ITM+12 ; 0717 MOVAB 17(SP), 100(SP) ;TERM_NAME+1, TERM_ITM+16 ; 0718 MOVAB (SP), 104(SP) ;TERM_LENGTH, TERM_ITM+20 ; 0719 CLRL 108(SP) ;TERM_ITM+24 ; 0722 CLRQ -(SP) ;-(SP) ; 0726 CLRQ -(SP) ;-(SP) ; PUSHAB -36(FP) ;OUTPUT_ITM ; PUSHAB W^U.17 ;U.17 ; MOVQ #2, -(SP) ;#2, -(SP) ; CALLS #8, (R7) ;#8, SYS$GETDVI ; MOVL R0, R2 ;R0, OUTPUT_STATUS ; BLBC R2, 1$ ;OUTPUT_STATUS, 1$ ; 0728 PUSHL #2 ;#2 ; 0735 CALLS #1, (R8) ;#1, SYS$WAITFR ; MOVL R0, R4 ;R0, STATUS ; BLBC R4, 6$ ;STATUS, 6$ ; 0737 CLRQ -(SP) ;-(SP) ; 0747 CLRQ -(SP) ;-(SP) ; PUSHAB 100(SP) ;TERM_ITM ; PUSHAB W^TERM_DESC ;TERM_DESC ; MOVQ #2, -(SP) ;#2, -(SP) ; CALLS #8, (R7) ;#8, SYS$GETDVI ; MOVL R0, R2 ;R0, TERM_STATUS ; BLBS R2, 2$ ;TERM_STATUS, 2$ ; 0749 1$: PUSHL R2 ;TERM_STATUS ; 0752 CALLS #1, (R6) ;#1, LIB$SIGNAL ; MOVL R2, R0 ;TERM_STATUS, R0 ; 0751 RET ; ; 2$: PUSHL #2 ;#2 ; 0756 CALLS #1, (R8) ;#1, SYS$WAITFR ; MOVL R0, R4 ;R0, STATUS ; BLBC R4, 8$ ;STATUS, 8$ ; 0758 CMPL 4(SP), #66 ;TERM_CLASS, #66 ; 0769 BNEQ 4$ ;4$ ; CMPL 12(SP), #66 ;OUTPUT_CLASS, #66 ; BNEQ 4$ ;4$ ; CMPC5 8(SP), @-20(FP), #0, (SP), @100(SP) ;OUTPUT_LENGTH, @OUTPUT_ITM+16, #0, TERM_LENGTH, @TERM_ITM+16 ; 0773 BEQL 3$ ;3$ ; CLRL (R9) ;CONNECT_FLAG ; 0776 BRB 5$ ;5$ ; 0773 3$: MOVL #1, (R9) ;#1, CONNECT_FLAG ; 0778 BRB 5$ ;5$ ; 0769 4$: MOVL #134316226, R0 ;#134316226, R0 ; 0782 RET ; ; 5$: CLRQ -(SP) ;-(SP) ; 0786 PUSHL R5 ;R5 ; PUSHAB W^TERM_DESC ;TERM_DESC ; CALLS #4, (R10) ;#4, SYS$ASSIGN ; MOVL R0, R4 ;R0, STATUS ; BLBC R4, 8$ ;STATUS, 8$ ; 0788 BLBS (R9), 7$ ;CONNECT_FLAG, 7$ ; 0800 CLRQ -(SP) ;-(SP) ; 0803 PUSHAB 4(R5) ;CONS_CHAN ; PUSHAB W^U.17 ;U.17 ; CALLS #4, (R10) ;#4, SYS$ASSIGN ; MOVL R0, R4 ;R0, STATUS ; 6$: BLBC R4, 9$ ;STATUS, 9$ ; 0805 7$: CLRQ -(SP) ;-(SP) ; 0815 CLRQ -(SP) ;-(SP) ; PUSHL #12 ;#12 ; PUSHAB 140(R5) ;OLD_TERM_CHAR ; CLRQ -(SP) ;-(SP) ; PUSHAB 132(R5) ;OLD_PARITY ; PUSHL #39 ;#39 ; PUSHL (R5) ;TERM_CHAN ; CLRL -(SP) ;-(SP) ; CALLS #12, (R11) ;#12, SYS$QIOW ; MOVL R0, R4 ;R0, STATUS ; 8$: BLBC R4, 9$ ;STATUS, 9$ ; 0817 MOVL 140(R5), 152(R5) ;OLD_TERM_CHAR, NEW_TERM_CHAR ; 0826 MOVB 147(R5), 159(R5) ;OLD_TERM_CHAR+7, NEW_TERM_CHAR+7 ; 0827 EXTZV #0, #24, 144(R5), R0 ;#0, #24, OLD_TERM_CHAR+4, R0 ; 0669 INSV #0, #9, #3, R0 ;#0, #9, #3, R0 ; BISL3 #163840, R0, R1 ;#163840, R0, R1 ; 0828 INSV R1, #0, #24, 156(R5) ;R1, #0, #24, NEW_TERM_CHAR+4 ; BISL3 #32, 148(R5), 160(R5) ;#32, OLD_TERM_CHAR+8, NEW_TERM_CHAR+8 ; 0830 MOVQ #32, -(SP) ;#32, -(SP) ; 0832 CLRQ -(SP) ;-(SP) ; PUSHL #12 ;#12 ; PUSHAB 152(R5) ;NEW_TERM_CHAR ; CLRQ -(SP) ;-(SP) ; MOVQ #35, -(SP) ;#35, -(SP) ; PUSHL (R5) ;TERM_CHAN ; CLRL -(SP) ;-(SP) ; CALLS #12, (R11) ;#12, SYS$QIOW ; MOVL R0, R4 ;R0, STATUS ; BLBS R4, 10$ ;STATUS, 10$ ; 0834 9$: PUSHL R4 ;STATUS ; 0837 CALLS #1, (R6) ;#1, LIB$SIGNAL ; MOVL R4, R0 ;STATUS, R0 ; 0836 RET ; ; 10$: MOVL #1, W^TERM_FLAG ;#1, TERM_FLAG ; 0841 MOVL #1, -4(R5) ;#1, TERM_FIRST_TIME ; 0842 CALLS #0, W^U.11 ;#0, U.11 ; 0846 MOVL R0, R4 ;R0, STATUS ; BLBS R4, 11$ ;STATUS, 11$ ; 0848 PUSHL R4 ;STATUS ; 0851 CALLS #1, (R6) ;#1, LIB$SIGNAL ; BRB 12$ ;12$ ; 0850 11$: BLBS (R9), 13$ ;CONNECT_FLAG, 13$ ; 0859 CALLS #0, W^U.12 ;#0, U.12 ; 0862 MOVL R0, R4 ;R0, STATUS ; BLBS R4, 13$ ;STATUS, 13$ ; 0864 PUSHL R4 ;STATUS ; 0867 CALLS #1, (R6) ;#1, LIB$SIGNAL ; PUSHL (R5) ;TERM_CHAN ; 0868 CALLS #1, G^SYS$CANCEL ;#1, SYS$CANCEL ; PUSHL (R5) ;TERM_CHAN ; 0869 CALLS #1, G^SYS$DASSGN ;#1, SYS$DASSGN ; 12$: MOVL #134316250, R0 ;#134316250, R0 ; 0866 RET ; ; 13$: MOVL #134316043, R0 ;#134316043, R0 ; 0669 RET ; ; 0630 ; Routine Size: 496 bytes, Routine Base: $CODE$ + 00B8 ; 0877 ; 0878 %SBTTL 'Communications line -- TERM_CLOSE' ; 0879 ; 0880 GLOBAL ROUTINE TERM_CLOSE = ; 0881 ; 0882 !++ ; 0883 ! FUNCTIONAL DESCRIPTION: ; 0884 ! ; 0885 ! This routine will deassign the channel that was assigned by ; 0886 ! TERM_OPEN. ; 0887 ! ; 0888 ! CALLING SEQUENCE: ; 0889 ! ; 0890 ! TERM_CLOSE(); ; 0891 ! ; 0892 ! INPUT PARAMETERS: ; 0893 ! ; 0894 ! None. ; 0895 ! ; 0896 ! IMPLICIT INPUTS: ; 0897 ! ; 0898 ! TERM_CHAN - Channel number to deassign. ; 0899 ! ; 0900 ! OUTPUT PARAMETERS: ; 0901 ! ; 0902 ! None. ; 0903 ! ; 0904 ! IMPLICIT OUTPUTS: ; 0905 ! ; 0906 ! None. ; 0907 ! ; 0908 ! COMPLETION CODES: ; 0909 ! ; 0910 ! SS$_NORMAL or error condition. ; 0911 ! ; 0912 ! SIDE EFFECTS: ; 0913 ! ; 0914 ! None. ; 0915 ! ; 0916 !-- ; 0917 ; 0918 BEGIN ; 0919 ; 0920 LOCAL ; 0921 PAR, ! Parity being set ; 0922 STATUS; ! Status returned by system service ; 0923 ; 0924 STATUS = $CANCEL (CHAN = .TERM_CHAN); ! Kill pending QIO ; 0925 ; 0926 IF NOT .CONNECT_FLAG ; 0927 THEN ; 0928 BEGIN ; 0929 $CANCEL (CHAN = .CONS_CHAN); ; 0930 $DASSGN (CHAN = .CONS_CHAN); ; 0931 END; ; 0932 ; 0933 CONNECT_FLAG = FALSE; ; 0934 PAR = .OLD_PARITY [1, 8, 8, 0] OR TT$M_ALTRPAR; ; P 0935 STATUS = $QIOW (CHAN = .TERM_CHAN, FUNC = IO$_SETMODE, P1 = OLD_TERM_CHAR, ; 0936 P2 = TC$_CHAR_LENGTH, P5 = .PAR); ; 0937 ; 0938 IF NOT .STATUS ; 0939 THEN ; 0940 BEGIN ; 0941 LIB$SIGNAL (.STATUS); ; 0942 RETURN .STATUS; ; 0943 END; ; 0944 ; 0945 STATUS = $DASSGN (CHAN = .TERM_CHAN); ; 0946 ; 0947 IF .STATUS ; 0948 THEN ; 0949 BEGIN ; 0950 TERM_FLAG = FALSE; ; 0951 RETURN KER_NORMAL ; 0952 END ; 0953 ELSE ; 0954 BEGIN ; 0955 LIB$SIGNAL (.STATUS); ; 0956 RETURN .STATUS; ; 0957 END; ; 0958 ; 0959 END; ! End of TERM_CLOSE .ENTRY TERM_CLOSE, ^M ;TERM_CLOSE, Save R2,R3,R4,R5 ; 0880 MOVAB G^SYS$DASSGN, R5 ;SYS$DASSGN, R5 ; MOVAB G^SYS$CANCEL, R4 ;SYS$CANCEL, R4 ; MOVAB W^U.3, R3 ;U.3, R3 ; PUSHL (R3) ;TERM_CHAN ; 0924 CALLS #1, (R4) ;#1, SYS$CANCEL ; MOVL R0, R2 ;R0, STATUS ; BLBS W^CONNECT_FLAG, 1$ ;CONNECT_FLAG, 1$ ; 0926 PUSHL 4(R3) ;CONS_CHAN ; 0929 CALLS #1, (R4) ;#1, SYS$CANCEL ; PUSHL 4(R3) ;CONS_CHAN ; 0930 CALLS #1, (R5) ;#1, SYS$DASSGN ; 1$: CLRL W^CONNECT_FLAG ;CONNECT_FLAG ; 0933 MOVZBL 134(R3), R0 ;OLD_PARITY+2, PAR ; 0934 BISL2 #32, R0 ;#32, PAR ; CLRL -(SP) ;-(SP) ; 0936 PUSHL R0 ;PAR ; CLRQ -(SP) ;-(SP) ; PUSHL #12 ;#12 ; PUSHAB 140(R3) ;OLD_TERM_CHAR ; CLRQ -(SP) ;-(SP) ; MOVQ #35, -(SP) ;#35, -(SP) ; PUSHL (R3) ;TERM_CHAN ; CLRL -(SP) ;-(SP) ; CALLS #12, G^SYS$QIOW ;#12, SYS$QIOW ; MOVL R0, R2 ;R0, STATUS ; BLBC R2, 2$ ;STATUS, 2$ ; 0938 PUSHL (R3) ;TERM_CHAN ; 0945 CALLS #1, (R5) ;#1, SYS$DASSGN ; MOVL R0, R2 ;R0, STATUS ; BLBC R2, 2$ ;STATUS, 2$ ; 0947 CLRL W^TERM_FLAG ;TERM_FLAG ; 0950 MOVL #134316043, R0 ;#134316043, R0 ; 0918 RET ; ; 2$: PUSHL R2 ;STATUS ; 0955 CALLS #1, G^LIB$SIGNAL ;#1, LIB$SIGNAL ; MOVL R2, R0 ;STATUS, R0 ; 0918 RET ; ; 0880 ; Routine Size: 128 bytes, Routine Base: $CODE$ + 02A8 ; 0960 ; 0961 %SBTTL 'Communications line -- SEND' ; 0962 ; 0963 GLOBAL ROUTINE SEND (ADDRESS, LENGTH) = ; 0964 ; 0965 !++ ; 0966 ! FUNCTIONAL DESCRIPTION: ; 0967 ! ; 0968 ! This routine will send a stream of 8-bit bytes over the terminal ; 0969 ! line to the remote KERMIT. This routine is called from KERMSG. ; 0970 ! ; 0971 ! CALLING SEQUENCE: ; 0972 ! ; 0973 ! SEND(Address-of-msg, Length-of-msg); ; 0974 ! ; 0975 ! INPUT PARAMETERS: ; 0976 ! ; 0977 ! None. ; 0978 ! ; 0979 ! IMPLICIT INPUTS: ; 0980 ! ; 0981 ! TERM_CHAN - Channel number to deassign. ; 0982 ! ; 0983 ! OUTPUT PARAMETERS: ; 0984 ! ; 0985 ! None. ; 0986 ! ; 0987 ! IMPLICIT OUTPUTS: ; 0988 ! ; 0989 ! None. ; 0990 ! ; 0991 ! COMPLETION CODES: ; 0992 ! ; 0993 ! SS$_NORMAL or error condition. ; 0994 ! ; 0995 ! SIDE EFFECTS: ; 0996 ! ; 0997 ! None. ; 0998 ! ; 0999 !-- ; 1000 ; 1001 BEGIN ; 1002 ; 1003 LOCAL ; 1004 STATUS; ! Status returned by $QIOW ; 1005 ; P 1006 STATUS = $QIOW (CHAN = .TERM_CHAN, FUNC = IO$_WRITEVBLK + IO$M_NOFORMAT, P1 = .ADDRESS, ; 1007 P2 = .LENGTH); ; 1008 ; 1009 IF .STATUS EQL SS$_NORMAL ; 1010 THEN ; 1011 RETURN KER_NORMAL ; 1012 ELSE ; 1013 BEGIN ; 1014 LIB$SIGNAL (.STATUS); ; 1015 RETURN .STATUS; ; 1016 END; ; 1017 ; 1018 END; ! End of SEND .ENTRY SEND, ^M ;SEND, Save R2 ; 0963 CLRQ -(SP) ;-(SP) ; 1007 CLRQ -(SP) ;-(SP) ; MOVQ 4(AP), -(SP) ;ADDRESS, -(SP) ; CLRQ -(SP) ;-(SP) ; CLRL -(SP) ;-(SP) ; MOVZWL #304, -(SP) ;#304, -(SP) ; PUSHL W^U.3 ;U.3 ; CLRL -(SP) ;-(SP) ; CALLS #12, G^SYS$QIOW ;#12, SYS$QIOW ; MOVL R0, R2 ;R0, STATUS ; CMPL R2, #1 ;STATUS, #1 ; 1009 BNEQ 1$ ;1$ ; MOVL #134316043, R0 ;#134316043, R0 ; 1001 RET ; ; 1$: PUSHL R2 ;STATUS ; 1014 CALLS #1, G^LIB$SIGNAL ;#1, LIB$SIGNAL ; MOVL R2, R0 ;STATUS, R0 ; 1001 RET ; ; 0963 ; Routine Size: 61 bytes, Routine Base: $CODE$ + 0328 ; 1019 ; 1020 %SBTTL 'Communications line -- RECEIVE' ; 1021 ; 1022 GLOBAL ROUTINE RECEIVE (ADDRESS, LENGTH) = ; 1023 ; 1024 !++ ; 1025 ! FUNCTIONAL DESCRIPTION: ; 1026 ! ; 1027 ! This routine will receive a stream of 8-bit bytes over the terminal ; 1028 ! line to the remote KERMIT. This routine is called from KERMSG. ; 1029 ! The text that is stored will always contain the control-A as the ; 1030 ! first character. ; 1031 ! ; 1032 ! CALLING SEQUENCE: ; 1033 ! ; 1034 ! RECEIVE(Address-of-msg); ; 1035 ! ; 1036 ! INPUT PARAMETERS: ; 1037 ! ; 1038 ! None. ; 1039 ! ; 1040 ! IMPLICIT INPUTS: ; 1041 ! ; 1042 ! TERM_CHAN - Channel number to deassign. ; 1043 ! ; 1044 ! OUTPUT PARAMETERS: ; 1045 ! ; 1046 ! None. ; 1047 ! ; 1048 ! IMPLICIT OUTPUTS: ; 1049 ! ; 1050 ! None. ; 1051 ! ; 1052 ! COMPLETION CODES: ; 1053 ! ; 1054 ! SS$_NORMAL or error condition. ; 1055 ! ; 1056 ! SIDE EFFECTS: ; 1057 ! ; 1058 ! None. ; 1059 ! ; 1060 !-- ; 1061 ; 1062 BEGIN ; 1063 ; 1064 LOCAL ; 1065 QWORD_TIMEOUT : VECTOR [2, LONG], ! Quad word TIMEOUT value ; 1066 TIMER_VALUE : VECTOR [2, LONG], ! Quad word TIME value ; 1067 OLD_POINTER, ! Pointer into the message ; 1068 NEW_POINTER, ! Other pointer for finding SOH ; 1069 CUR_LENGTH, ! Running length while finding SOH ; 1070 CUR_EFN, ! Current EFN value ; 1071 STATUS; ! Status returned by $QIO ; 1072 ; 1073 ! ; 1074 ! Set up the timer if we have a time out parameter ; 1075 ! ; 1076 STATUS = $CLREF (EFN = TIME_EFN); ; 1077 ; 1078 IF .RCV_TIMEOUT GTR 0 ; 1079 THEN ; 1080 BEGIN ; 1081 STATUS = $CANTIM (REQIDT = TIME_EFN); ; 1082 STATUS = $GETTIM (TIMADR = TIMER_VALUE); ; 1083 STATUS = LIB$EMUL (RCV_TIMEOUT, UPLIT (10000000), UPLIT (0), QWORD_TIMEOUT); ; 1084 STATUS = LIB$ADDX (TIMER_VALUE, QWORD_TIMEOUT, QWORD_TIMEOUT); ; 1085 STATUS = $SETIMR (DAYTIM = QWORD_TIMEOUT, EFN = TIME_EFN, REQIDT = TIME_EFN); ; 1086 END; ; 1087 ; 1088 ! ; 1089 ! Loop until we get something that is acceptable ; 1090 ! ; 1091 ; 1092 WHILE TRUE DO ; 1093 BEGIN ; 1094 ! ; 1095 ! Wait for something to happen. Either the terminal EFN will come up ; 1096 ! indicating we have some data, or the timer EFN will indicate that ; 1097 ! the time has run out. ; 1098 ! ; 1099 STATUS = $WFLOR (EFN = TERM_EFN, MASK = (1^TERM_EFN OR 1^TIME_EFN)); ; 1100 STATUS = $READEF (EFN = TERM_EFN, STATE = CUR_EFN); ; 1101 ! ; 1102 ! If the terminal EFN is not set, the time must have expired. Therefore, ; 1103 ! we have timed out, and need to return that fact. ; 1104 ! ; 1105 ; 1106 IF (.CUR_EFN AND 1^TERM_EFN) EQL 0 THEN RETURN KER_TIMEOUT; ; 1107 ; 1108 ! ; 1109 ! Check if the QIO completed successfully. If not, we will return ; 1110 ! an error. ; 1111 ! ; 1112 ; 1113 IF NOT .IO_STATUS [0] ; 1114 THEN ; 1115 BEGIN ; 1116 LIB$SIGNAL (.IO_STATUS [0]); ; 1117 RETURN KER_RECERR; ; 1118 END; ; 1119 ; 1120 ! ; 1121 ! First check for a control-Y as the terminator. If it was, then ; 1122 ! just abort now, since the user probably typed it. ; 1123 ! ; 1124 ; 1125 IF .CONNECT_FLAG ; 1126 THEN ; 1127 ; 1128 IF (.IO_STATUS [2] EQL CHR_CTL_Y) AND (.RCV_EOL NEQ CHR_CTL_Y) ; 1129 THEN ; 1130 BEGIN ; 1131 STATUS = $CANTIM (REQIDT = TIME_EFN); ; 1132 RETURN KER_ABORTED ; 1133 END; ; 1134 ; 1135 ! ; 1136 ! Now find the final start of header character in the buffer. We ; 1137 ! will only return the text from that point on. If there is no SOH, ; 1138 ! then just get another buffer. It was probably noise on the line. ; 1139 ! ; 1140 OLD_POINTER = CH$PTR (RECV_BUFFER, 0, CHR_SIZE); ; 1141 CUR_LENGTH = .IO_STATUS [1]; ! Length without terminating character ; 1142 NEW_POINTER = CH$FIND_CH (.CUR_LENGTH, .OLD_POINTER, CHR_CTL_A); ; 1143 ! ; 1144 ! If we found a start of header character, then we probably have something ; 1145 ! to return. However, first we must find the last start of header, in case ; 1146 ! something is garbled. ; 1147 ! ; 1148 ; 1149 IF NOT CH$FAIL (.NEW_POINTER) ; 1150 THEN ; 1151 BEGIN ; 1152 ! ; 1153 ! Search until we can't find any more start of headers, or until we run ; 1154 ! out of string to search (last character before EOL is an SOH). ; 1155 ! ; 1156 ; 1157 WHILE (.CUR_LENGTH GTR 0) AND ( NOT CH$FAIL (.NEW_POINTER)) DO ; 1158 BEGIN ; 1159 CUR_LENGTH = .CUR_LENGTH - CH$DIFF (.NEW_POINTER, .OLD_POINTER); ; 1160 ! Adjust the length for the characters we are skipping ; 1161 OLD_POINTER = .NEW_POINTER; ! Remember where we start ; 1162 NEW_POINTER = CH$FIND_CH (.CUR_LENGTH - 1, CH$PLUS (.OLD_POINTER, 1), CHR_CTL_A); ; 1163 ! Find the next SOH (if any) ; 1164 END; ; 1165 ; 1166 ! ; 1167 ! If we have something left of the buffer, move from the SOH until the end ; 1168 ! into the callers buffer. ; 1169 ! ; 1170 ; 1171 IF (.CUR_LENGTH GTR 0) ; 1172 THEN ; 1173 BEGIN ; 1174 .LENGTH = .CUR_LENGTH + 1; ; 1175 IF .PARITY_TYPE EQL PR_NONE ; 1176 THEN ; 1177 CH$MOVE (.CUR_LENGTH + 1, .OLD_POINTER, CH$PTR (.ADDRESS, 0, CHR_SIZE)) ; 1178 ELSE ; 1179 BEGIN ; 1180 NEW_POINTER = CH$PTR(.ADDRESS, 0, CHR_SIZE); ; 1181 DECR CUR_LENGTH FROM .CUR_LENGTH TO 0 DO ; 1182 CH$WCHAR_A((CH$RCHAR_A(OLD_POINTER) AND %O'177'),NEW_POINTER); ; 1183 END; ; 1184 EXITLOOP ; 1185 END ; 1186 ; 1187 END; ! End of IF NOT CH$FAIL(.POINTER) ; 1188 ; 1189 ! ; 1190 ! If we have gotten here, we have input a buffer without a valid message. ; 1191 ! Make sure we post the QIO again ; 1192 ! ; 1193 STATUS = DO_RECEIVE_QIO (); ; 1194 ; 1195 IF NOT .STATUS ; 1196 THEN ; 1197 BEGIN ; 1198 LIB$SIGNAL (.STATUS); ; 1199 RETURN KER_RECERR ; 1200 END; ; 1201 ; 1202 END; ! End of WHILE TRUE DO ; 1203 ; 1204 ! ; 1205 ! If we have gotten here, we have a valid message to return. ; 1206 ! Post the QIO so the buffer is available for the next message. ; 1207 ! ; 1208 STATUS = DO_RECEIVE_QIO (); ; 1209 ; 1210 IF NOT .STATUS ; 1211 THEN ; 1212 BEGIN ; 1213 LIB$SIGNAL (.STATUS); ; 1214 RETURN KER_RECERR ; 1215 END; ; 1216 ; 1217 RETURN KER_NORMAL; ! Return happy ; 1218 END; ! End of RECEIVE .PSECT $PLIT$,NOWRT,NOEXE,2 P.AAD: .LONG 10000000 ; ; P.AAE: .LONG 0 ; ; .EXTRN SYS$CLREF, SYS$CANTIM, SYS$GETTIM, SYS$SETIMR, SYS$WFLOR, SYS$READEF .PSECT $CODE$,NOWRT,2 .ENTRY RECEIVE, ^M ; ; MOVAB G^SYS$CANTIM, R11 ;SYS$CANTIM, R11 ; MOVAB W^U.5, R10 ;U.5, R10 ; SUBL2 #20, SP ;#20, SP ; PUSHL #3 ;#3 ; 1076 CALLS #1, G^SYS$CLREF ;#1, SYS$CLREF ; MOVL R0, R9 ;R0, STATUS ; TSTL W^RCV_TIMEOUT ;RCV_TIMEOUT ; 1078 BLEQ 1$ ;1$ ; MOVQ #3, -(SP) ;#3, -(SP) ; 1081 CALLS #2, (R11) ;#2, SYS$CANTIM ; MOVL R0, R9 ;R0, STATUS ; PUSHAB 4(SP) ;TIMER_VALUE ; 1082 CALLS #1, G^SYS$GETTIM ;#1, SYS$GETTIM ; MOVL R0, R9 ;R0, STATUS ; PUSHAB 12(SP) ;QWORD_TIMEOUT ; 1083 PUSHAB W^P.AAE ;P.AAE ; PUSHAB W^P.AAD ;P.AAD ; PUSHAB W^RCV_TIMEOUT ;RCV_TIMEOUT ; CALLS #4, G^LIB$EMUL ;#4, LIB$EMUL ; MOVL R0, R9 ;R0, STATUS ; PUSHAB 12(SP) ;QWORD_TIMEOUT ; 1084 PUSHAB 16(SP) ;QWORD_TIMEOUT ; PUSHAB 12(SP) ;TIMER_VALUE ; CALLS #3, G^LIB$ADDX ;#3, LIB$ADDX ; MOVL R0, R9 ;R0, STATUS ; PUSHL #3 ;#3 ; 1085 CLRL -(SP) ;-(SP) ; PUSHAB 20(SP) ;QWORD_TIMEOUT ; PUSHL #3 ;#3 ; CALLS #4, G^SYS$SETIMR ;#4, SYS$SETIMR ; MOVL R0, R9 ;R0, STATUS ; 1$: PUSHL #12 ;#12 ; 1099 PUSHL #2 ;#2 ; CALLS #2, G^SYS$WFLOR ;#2, SYS$WFLOR ; MOVL R0, R9 ;R0, STATUS ; PUSHL SP ;SP ; 1100 PUSHL #2 ;#2 ; CALLS #2, G^SYS$READEF ;#2, SYS$READEF ; MOVL R0, R9 ;R0, STATUS ; BBS #2, (SP), 2$ ;#2, CUR_EFN, 2$ ; 1106 MOVL #134316232, R0 ;#134316232, R0 ; RET ; ; 2$: BLBS (R10), 3$ ;IO_STATUS, 3$ ; 1113 MOVZWL (R10), -(SP) ;IO_STATUS, -(SP) ; 1116 BRW 15$ ;15$ ; 3$: BLBC W^CONNECT_FLAG, 4$ ;CONNECT_FLAG, 4$ ; 1125 CMPW 4(R10), #25 ;IO_STATUS+4, #25 ; 1128 BNEQ 4$ ;4$ ; CMPL W^RCV_EOL, #25 ;RCV_EOL, #25 ; BEQL 4$ ;4$ ; MOVQ #3, -(SP) ;#3, -(SP) ; 1131 CALLS #2, (R11) ;#2, SYS$CANTIM ; MOVL R0, R9 ;R0, STATUS ; MOVL #134316242, R0 ;#134316242, R0 ; 1130 RET ; ; 4$: MOVAB 8(R10), R6 ;RECV_BUFFER, OLD_POINTER ; 1140 MOVZWL 2(R10), R8 ;IO_STATUS+2, CUR_LENGTH ; 1141 LOCC #1, R8, (R6) ;#1, CUR_LENGTH, (OLD_POINTER) ; 1142 BNEQ 5$ ;5$ ; CLRL R1 ;R1 ; 5$: MOVL R1, R7 ;R1, NEW_POINTER ; BEQL 12$ ;12$ ; 1149 6$: TSTL R8 ;CUR_LENGTH ; 1157 BLEQ 8$ ;8$ ; TSTL R7 ;NEW_POINTER ; BEQL 8$ ;8$ ; SUBL3 R7, R6, R0 ;NEW_POINTER, OLD_POINTER, R0 ; 1159 ADDL2 R0, R8 ;R0, CUR_LENGTH ; MOVL R7, R6 ;NEW_POINTER, OLD_POINTER ; 1161 MOVAB -1(R8), R0 ;-1(R8), R0 ; 1162 LOCC #1, R0, 1(R6) ;#1, R0, 1(OLD_POINTER) ; BNEQ 7$ ;7$ ; CLRL R1 ;R1 ; 7$: MOVL R1, R7 ;R1, NEW_POINTER ; BRB 6$ ;6$ ; 1157 8$: TSTL R8 ;CUR_LENGTH ; 1171 BLEQ 12$ ;12$ ; MOVAB 1(R8), R0 ;1(R8), R0 ; 1174 MOVL R0, @8(AP) ;R0, @LENGTH ; TSTL W^PARITY_TYPE ;PARITY_TYPE ; 1175 BNEQ 9$ ;9$ ; MOVC3 R0, (R6), @4(AP) ;R0, (OLD_POINTER), @ADDRESS ; 1177 BRB 13$ ;13$ ; 1175 9$: MOVL 4(AP), R7 ;ADDRESS, NEW_POINTER ; 1180 MOVAB 1(R8), R0 ;1(R8), CUR_LENGTH ; 1181 BRB 11$ ;11$ ; 10$: MOVZBL (R6)+, R1 ;(OLD_POINTER)+, R1 ; 1182 EXTZV #0, #7, R1, R2 ;#0, #7, R1, R2 ; MOVB R2, (R7)+ ;R2, (NEW_POINTER)+ ; 11$: SOBGEQ R0, 10$ ;CUR_LENGTH, 10$ ; 1181 BRB 13$ ;13$ ; 1173 12$: CALLS #0, W^U.11 ;#0, U.11 ; 1193 MOVL R0, R9 ;R0, STATUS ; BLBC R9, 14$ ;STATUS, 14$ ; 1195 BRW 1$ ;1$ ; 13$: CALLS #0, W^U.11 ;#0, U.11 ; 1208 MOVL R0, R9 ;R0, STATUS ; BLBS R9, 16$ ;STATUS, 16$ ; 1210 14$: PUSHL R9 ;STATUS ; 1213 15$: CALLS #1, G^LIB$SIGNAL ;#1, LIB$SIGNAL ; MOVL #134316250, R0 ;#134316250, R0 ; 1212 RET ; ; 16$: MOVL #134316043, R0 ;#134316043, R0 ; 1062 RET ; ; 1022 ; Routine Size: 362 bytes, Routine Base: $CODE$ + 0365 ; 1219 ; 1220 %SBTTL 'Communications line -- IBM_WAIT' ; 1221 ; 1222 GLOBAL ROUTINE IBM_WAIT = ; 1223 ; 1224 !++ ; 1225 ! FUNCTIONAL DESCRIPTION: ; 1226 ! ; 1227 ! This routine will wait until the IBM turnaround character ; 1228 ! is seen on the communications line, or until the timeout ; 1229 ! parameter is exceeded. ; 1230 ! ; 1231 ! CALLING SEQUENCE: ; 1232 ! ; 1233 ! STATUS = IBM_WAIT (); ; 1234 ! ; 1235 ! INPUT PARAMETERS: ; 1236 ! ; 1237 ! None. ; 1238 ! ; 1239 ! IMPLICIT INPUTS: ; 1240 ! ; 1241 ! TERM_CHAN - Channel number for terminal ; 1242 ! ; 1243 ! OUTPUT PARAMETERS: ; 1244 ! ; 1245 ! Status value is returned as routine value. ; 1246 ! ; 1247 ! IMPLICIT OUTPUTS: ; 1248 ! ; 1249 ! None. ; 1250 ! ; 1251 ! COMPLETION CODES: ; 1252 ! ; 1253 ! SS$_NORMAL or error condition. ; 1254 ! ; 1255 ! SIDE EFFECTS: ; 1256 ! ; 1257 ! None. ; 1258 ! ; 1259 !-- ; 1260 ; 1261 BEGIN ; 1262 ; 1263 LOCAL ; 1264 QWORD_TIMEOUT : VECTOR [2, LONG], ! Quad word TIMEOUT value ; 1265 TIMER_VALUE : VECTOR [2, LONG], ! Quad word TIME value ; 1266 CUR_EFN, ! Current EFN value ; 1267 STATUS; ! Status returned by $QIO ; 1268 ; 1269 ! ; 1270 ! Set up the timer if we have a time out parameter ; 1271 ! ; 1272 STATUS = $CLREF (EFN = TIME_EFN); ; 1273 ; 1274 IF .RCV_TIMEOUT GTR 0 ; 1275 THEN ; 1276 BEGIN ; 1277 STATUS = $CANTIM (REQIDT = TIME_EFN); ; 1278 STATUS = $GETTIM (TIMADR = TIMER_VALUE); ; 1279 STATUS = LIB$EMUL (RCV_TIMEOUT, UPLIT (10000000), UPLIT (0), QWORD_TIMEOUT); ; 1280 STATUS = LIB$ADDX (TIMER_VALUE, QWORD_TIMEOUT, QWORD_TIMEOUT); ; 1281 STATUS = $SETIMR (DAYTIM = QWORD_TIMEOUT, EFN = TIME_EFN, REQIDT = TIME_EFN); ; 1282 END; ; 1283 ; 1284 ! ; 1285 ! Loop until we get something that is acceptable ; 1286 ! ; 1287 ; 1288 WHILE TRUE DO ; 1289 BEGIN ; 1290 ! ; 1291 ! Wait for something to happen. Either the terminal EFN will come up ; 1292 ! indicating we have some data, or the timer EFN will indicate that ; 1293 ! the time has run out. ; 1294 ! ; 1295 STATUS = $WFLOR (EFN = TERM_EFN, MASK = (1^TERM_EFN OR 1^TIME_EFN)); ; 1296 STATUS = $READEF (EFN = TERM_EFN, STATE = CUR_EFN); ; 1297 ! ; 1298 ! If the terminal EFN is not set, the time must have expired. Therefore, ; 1299 ! pretend we got the character. ; 1300 ! ; 1301 ; 1302 IF (.CUR_EFN AND 1^TERM_EFN) EQL 0 THEN RETURN KER_NORMAL; ; 1303 ; 1304 ! ; 1305 ! Check if the QIO completed successfully. If not, we will return ; 1306 ! an error. ; 1307 ! ; 1308 ; 1309 IF NOT .IO_STATUS [0] ; 1310 THEN ; 1311 BEGIN ; 1312 LIB$SIGNAL (.IO_STATUS [0]); ; 1313 RETURN KER_RECERR; ; 1314 END; ; 1315 ; 1316 ! ; 1317 ! First check for a control-Y as the terminator. If it was, then ; 1318 ! just abort now, since the user probably typed it. ; 1319 ! ; 1320 ; 1321 IF .CONNECT_FLAG ; 1322 THEN ; 1323 ; 1324 IF (.IO_STATUS [2] EQL CHR_CTL_Y) AND (.RCV_EOL NEQ CHR_CTL_Y) ; 1325 THEN ; 1326 BEGIN ; 1327 STATUS = $CANTIM (REQIDT = TIME_EFN); ; 1328 RETURN KER_ABORTED ; 1329 END; ; 1330 ; 1331 ! Check if terminator was the turnaround character ; 1332 ; 1333 IF (.IO_STATUS [2] EQL .IBM_CHAR) THEN EXITLOOP; ; 1334 ; 1335 ! ; 1336 ! Make sure we post the QIO again ; 1337 ! ; 1338 STATUS = DO_RECEIVE_QIO (); ; 1339 ; 1340 IF NOT .STATUS ; 1341 THEN ; 1342 BEGIN ; 1343 LIB$SIGNAL (.STATUS); ; 1344 RETURN KER_RECERR ; 1345 END; ; 1346 ; 1347 END; ! End of WHILE TRUE DO ; 1348 ; 1349 ! ; 1350 ! If we have gotten here, we have a valid message to return. ; 1351 ! Post the QIO so the buffer is available for the next message. ; 1352 ! ; 1353 STATUS = DO_RECEIVE_QIO (); ; 1354 ; 1355 IF NOT .STATUS ; 1356 THEN ; 1357 BEGIN ; 1358 LIB$SIGNAL (.STATUS); ; 1359 RETURN KER_RECERR ; 1360 END; ; 1361 ; 1362 RETURN KER_NORMAL; ! Return happy ; 1363 END; ! End of RECEIVE .PSECT $PLIT$,NOWRT,NOEXE,2 P.AAF: .LONG 10000000 ; ; P.AAG: .LONG 0 ; ; .PSECT $CODE$,NOWRT,2 .ENTRY IBM_WAIT, ^M ;IBM_WAIT, Save R2,R3,R4 ; 1222 MOVAB W^U.5, R4 ;U.5, R4 ; MOVAB G^SYS$CANTIM, R3 ;SYS$CANTIM, R3 ; SUBL2 #20, SP ;#20, SP ; PUSHL #3 ;#3 ; 1272 CALLS #1, G^SYS$CLREF ;#1, SYS$CLREF ; MOVL R0, R2 ;R0, STATUS ; TSTL W^RCV_TIMEOUT ;RCV_TIMEOUT ; 1274 BLEQ 1$ ;1$ ; MOVQ #3, -(SP) ;#3, -(SP) ; 1277 CALLS #2, (R3) ;#2, SYS$CANTIM ; MOVL R0, R2 ;R0, STATUS ; PUSHAB 4(SP) ;TIMER_VALUE ; 1278 CALLS #1, G^SYS$GETTIM ;#1, SYS$GETTIM ; MOVL R0, R2 ;R0, STATUS ; PUSHAB 12(SP) ;QWORD_TIMEOUT ; 1279 PUSHAB W^P.AAG ;P.AAG ; PUSHAB W^P.AAF ;P.AAF ; PUSHAB W^RCV_TIMEOUT ;RCV_TIMEOUT ; CALLS #4, G^LIB$EMUL ;#4, LIB$EMUL ; MOVL R0, R2 ;R0, STATUS ; PUSHAB 12(SP) ;QWORD_TIMEOUT ; 1280 PUSHAB 16(SP) ;QWORD_TIMEOUT ; PUSHAB 12(SP) ;TIMER_VALUE ; CALLS #3, G^LIB$ADDX ;#3, LIB$ADDX ; MOVL R0, R2 ;R0, STATUS ; PUSHL #3 ;#3 ; 1281 CLRL -(SP) ;-(SP) ; PUSHAB 20(SP) ;QWORD_TIMEOUT ; PUSHL #3 ;#3 ; CALLS #4, G^SYS$SETIMR ;#4, SYS$SETIMR ; MOVL R0, R2 ;R0, STATUS ; 1$: PUSHL #12 ;#12 ; 1295 PUSHL #2 ;#2 ; CALLS #2, G^SYS$WFLOR ;#2, SYS$WFLOR ; MOVL R0, R2 ;R0, STATUS ; PUSHL SP ;SP ; 1296 PUSHL #2 ;#2 ; CALLS #2, G^SYS$READEF ;#2, SYS$READEF ; MOVL R0, R2 ;R0, STATUS ; BBC #2, (SP), 7$ ;#2, CUR_EFN, 7$ ; 1302 BLBS (R4), 2$ ;IO_STATUS, 2$ ; 1309 MOVZWL (R4), -(SP) ;IO_STATUS, -(SP) ; 1312 BRB 6$ ;6$ ; 2$: BLBC W^CONNECT_FLAG, 3$ ;CONNECT_FLAG, 3$ ; 1321 CMPW 4(R4), #25 ;IO_STATUS+4, #25 ; 1324 BNEQ 3$ ;3$ ; CMPL W^RCV_EOL, #25 ;RCV_EOL, #25 ; BEQL 3$ ;3$ ; MOVQ #3, -(SP) ;#3, -(SP) ; 1327 CALLS #2, (R3) ;#2, SYS$CANTIM ; MOVL R0, R2 ;R0, STATUS ; MOVL #134316242, R0 ;#134316242, R0 ; 1326 RET ; ; 3$: CMPZV #0, #16, 4(R4), W^IBM_CHAR ;#0, #16, IO_STATUS+4, IBM_CHAR ; 1333 BEQL 4$ ;4$ ; CALLS #0, W^U.11 ;#0, U.11 ; 1338 MOVL R0, R2 ;R0, STATUS ; BLBS R2, 1$ ;STATUS, 1$ ; 1340 BRB 5$ ;5$ ; 1343 4$: CALLS #0, W^U.11 ;#0, U.11 ; 1353 MOVL R0, R2 ;R0, STATUS ; BLBS R2, 7$ ;STATUS, 7$ ; 1355 5$: PUSHL R2 ;STATUS ; 1358 6$: CALLS #1, G^LIB$SIGNAL ;#1, LIB$SIGNAL ; MOVL #134316250, R0 ;#134316250, R0 ; 1357 RET ; ; 7$: MOVL #134316043, R0 ;#134316043, R0 ; 1261 RET ; ; 1222 ; Routine Size: 254 bytes, Routine Base: $CODE$ + 04CF ; 1364 ; 1365 %SBTTL 'DO_RECEIVE_QIO' ; 1366 ROUTINE DO_RECEIVE_QIO = ; 1367 ; 1368 !++ ; 1369 ! FUNCTIONAL DESCRIPTION: ; 1370 ! ; 1371 ! This routine is called to perform a QIO input from the terminal. This ; 1372 ! ensures that there is usually a receive buffer pending. ; 1373 ! ; 1374 ! CALLING SEQUENCE: ; 1375 ! ; 1376 ! STATUS = DO_RECEIVE_QIO (); ; 1377 ! ; 1378 ! INPUT PARAMETERS: ; 1379 ! ; 1380 ! None. ; 1381 ! ; 1382 ! IMPLICIT INPUTS: ; 1383 ! ; 1384 ! RCV_EOL - Receive end-of-line character ; 1385 ! ; 1386 ! OUPTUT PARAMETERS: ; 1387 ! ; 1388 ! None. ; 1389 ! ; 1390 ! IMPLICIT OUTPUTS: ; 1391 ! ; 1392 ! IO_STATUS - IOSB for the QIO ; 1393 ! RCV_BUFFER - Data input from terminal ; 1394 ! ; 1395 ! COMPLETION CODES: ; 1396 ! ; 1397 ! None. ; 1398 ! ; 1399 ! SIDE EFFECTS: ; 1400 ! ; 1401 ! TERM_EFN is set when I/O completes ; 1402 ! ; 1403 !-- ; 1404 ; 1405 BEGIN ; 1406 ; 1407 LOCAL ; 1408 QIO_FUNC, ; 1409 TERMINATOR : VECTOR [2, LONG], ; 1410 STATUS; ! For status of QIO call ; 1411 ; 1412 ! ; 1413 ! Initialize the terminating characters for the QIO. Only terminate ; 1414 ! on the end-of-line character and a control-Y ; 1415 ! ; 1416 TERMINATOR [0] = 0; ; 1417 TERMINATOR [1] = 1^.RCV_EOL OR 1^CHR_CTL_Y; ; 1418 ; 1419 IF .IBM_FLAG THEN TERMINATOR [1] = TERMINATOR [1] OR 1^.IBM_CHAR; ; 1420 ; 1421 ! ; 1422 ! Initialize the QIO function ; 1423 ! ; 1424 QIO_FUNC = IO$_TTYREADALL OR IO$M_NOECHO; ; 1425 ! ; 1426 ! If this is the first time then purge any information that we have ; 1427 ! received on the line, before attempting to read information. ; 1428 ! ; 1429 ; 1430 IF .TERM_FIRST_TIME ; 1431 THEN ; 1432 BEGIN ; 1433 QIO_FUNC = .QIO_FUNC OR IO$M_PURGE; ; 1434 TERM_FIRST_TIME = FALSE ! Not first time anymore ; 1435 END; ; 1436 ; P 1437 RETURN $QIO (CHAN = .TERM_CHAN, EFN = TERM_EFN, FUNC = .QIO_FUNC, IOSB = IO_STATUS, ; 1438 P1 = RECV_BUFFER, P2 = RECV_BUFF_SIZE, P4 = TERMINATOR); ; 1439 END; ! End of DO_RECEIVE_QIO .EXTRN SYS$QIO ;DO_RECEIVE_QIO U.11: .WORD ^M ;Save R2 ; 1366 MOVAB W^U.2, R2 ;U.2, R2 ; SUBL2 #4, SP ;#4, SP ; CLRL -(SP) ;TERMINATOR ; 1416 ASHL W^RCV_EOL, #1, R0 ;RCV_EOL, #1, R0 ; 1417 BISL3 #33554432, R0, 4(SP) ;#33554432, R0, TERMINATOR+4 ; BLBC W^IBM_FLAG, 1$ ;IBM_FLAG, 1$ ; 1419 ASHL W^IBM_CHAR, #1, R1 ;IBM_CHAR, #1, R1 ; MOVAB 4(SP), R0 ;TERMINATOR+4, R0 ; BISL3 R1, R0, 4(SP) ;R1, R0, TERMINATOR+4 ; 1$: MOVZBL #122, R0 ;#122, QIO_FUNC ; 1424 BLBC (R2), 2$ ;TERM_FIRST_TIME, 2$ ; 1430 BISW2 #2048, R0 ;#2048, QIO_FUNC ; 1433 CLRL (R2) ;TERM_FIRST_TIME ; 1434 2$: CLRQ -(SP) ;-(SP) ; 1438 PUSHAB 8(SP) ;TERMINATOR ; CLRL -(SP) ;-(SP) ; MOVZBL #116, -(SP) ;#116, -(SP) ; PUSHAB 20(R2) ;RECV_BUFFER ; CLRQ -(SP) ;-(SP) ; PUSHAB 12(R2) ;IO_STATUS ; PUSHL R0 ;QIO_FUNC ; PUSHL 4(R2) ;TERM_CHAN ; PUSHL #2 ;#2 ; CALLS #12, G^SYS$QIO ;#12, SYS$QIO ; RET ; ; 1366 ; Routine Size: 95 bytes, Routine Base: $CODE$ + 05CD ; 1440 %SBTTL 'DO_CONS_QIO' ; 1441 ROUTINE DO_CONS_QIO = ; 1442 ; 1443 !++ ; 1444 ! FUNCTIONAL DESCRIPTION: ; 1445 ! ; 1446 ! This routine is called to perform a QIO input from the terminal. This ; 1447 ! ensures that there is usually a receive buffer pending. ; 1448 ! ; 1449 ! CALLING SEQUENCE: ; 1450 ! ; 1451 ! STATUS = DO_CONS_QIO (); ; 1452 ! ; 1453 ! INPUT PARAMETERS: ; 1454 ! ; 1455 ! None. ; 1456 ! ; 1457 ! IMPLICIT INPUTS: ; 1458 ! ; 1459 ! RCV_EOL - Receive end-of-line character ; 1460 ! ; 1461 ! OUPTUT PARAMETERS: ; 1462 ! ; 1463 ! None. ; 1464 ! ; 1465 ! IMPLICIT OUTPUTS: ; 1466 ! ; 1467 ! IO_STATUS - IOSB for the QIO ; 1468 ! RCV_BUFFER - Data input from terminal ; 1469 ! ; 1470 ! COMPLETION CODES: ; 1471 ! ; 1472 ! None. ; 1473 ! ; 1474 ! SIDE EFFECTS: ; 1475 ! ; 1476 ! TERM_EFN is set when I/O completes ; 1477 ! ; 1478 !-- ; 1479 ; 1480 BEGIN ; 1481 ; 1482 EXTERNAL ; 1483 ABT_CUR_FILE, ; 1484 ABT_ALL_FILE; ; 1485 ; 1486 LOCAL ; 1487 STATUS; ! For status of QIO call ; 1488 ; 1489 LITERAL ; 1490 CONS_BUFF_SIZE = 1; ; 1491 ; 1492 OWN ; 1493 CONS_STATUS : VECTOR [4, WORD], ; 1494 CONS_BUFFER : VECTOR [CONS_BUFF_SIZE, BYTE]; ; 1495 ; 1496 ! ; 1497 ! AST routine for console ; 1498 ! ; 1499 ROUTINE CONS_AST (DUMMY) = ; 1500 BEGIN ; 1501 ; 1502 IF .CONS_STATUS [0] ; 1503 THEN ; 1504 ; 1505 IF .CONS_STATUS [2] EQL CHR_CTL_Z ; 1506 THEN ; 1507 ABT_ALL_FILE = TRUE ; 1508 ELSE ; 1509 ; 1510 IF .CONS_STATUS [2] EQL CHR_CTL_X ; 1511 THEN ; 1512 ABT_CUR_FILE = TRUE ; 1513 ELSE ; 1514 ; 1515 IF .CONS_STATUS [2] EQL CHR_CTL_Y OR .CONS_STATUS EQL CHR_CTL_C ; 1516 THEN ; 1517 RETURN SS$_NORMAL; ; 1518 ; 1519 IF .CONS_STATUS [0] NEQ SS$_CANCEL AND .CONS_STATUS [0] NEQ SS$_ABORT ; 1520 THEN ; 1521 RETURN DO_CONS_QIO () ; 1522 ELSE ; 1523 RETURN SS$_NORMAL; ; 1524 ; 1525 END; .PSECT $OWN$,NOEXE,2 ;CONS_STATUS U.22: .BLKB 8 ;CONS_BUFFER U.23: .BLKB 1 .EXTRN ABT_CUR_FILE, ABT_ALL_FILE .PSECT $CODE$,NOWRT,2 ;CONS_AST U.24: .WORD ^M<> ;Save nothing ; 1499 MOVZWL W^U.22, R1 ;U.22, R1 ; 1502 BLBC R1, 3$ ;R1, 3$ ; MOVZWL W^U.22+4, R0 ;U.22+4, R0 ; 1505 CMPW R0, #26 ;R0, #26 ; BNEQ 1$ ;1$ ; MOVL #1, W^ABT_ALL_FILE ;#1, ABT_ALL_FILE ; 1507 BRB 3$ ;3$ ; 1505 1$: CMPW R0, #24 ;R0, #24 ; 1510 BNEQ 2$ ;2$ ; MOVL #1, W^ABT_CUR_FILE ;#1, ABT_CUR_FILE ; 1512 BRB 3$ ;3$ ; 1510 2$: CMPW R0, #25 ;R0, #25 ; 1515 BEQL 4$ ;4$ ; CMPL W^U.22, #3 ;U.22, #3 ; BEQL 4$ ;4$ ; 3$: CMPW R1, #2096 ;R1, #2096 ; 1519 BEQL 4$ ;4$ ; CMPW R1, #44 ;R1, #44 ; BEQL 4$ ;4$ ; CALLS #0, W^U.12 ;#0, U.12 ; 1521 RET ; ; 1500 4$: MOVL #1, R0 ;#1, R0 ; RET ; ; 1499 ; Routine Size: 73 bytes, Routine Base: $CODE$ + 062C ; P 1526 RETURN $QIO (CHAN = .CONS_CHAN, FUNC = IO$_TTYREADALL, IOSB = CONS_STATUS, ASTADR = CONS_AST, ; 1527 P1 = CONS_BUFFER, P2 = CONS_BUFF_SIZE); ; 1528 END; ! End of DO_CONS_QIO ;DO_CONS_QIO U.12: .WORD ^M<> ;Save nothing ; 1441 CLRQ -(SP) ;-(SP) ; 1527 CLRQ -(SP) ;-(SP) ; PUSHL #1 ;#1 ; PUSHAB W^U.23 ;U.23 ; CLRL -(SP) ;-(SP) ; PUSHAB B^U.24 ;U.24 ; PUSHAB W^U.22 ;U.22 ; PUSHL #58 ;#58 ; PUSHL W^U.4 ;U.4 ; CLRL -(SP) ;-(SP) ; CALLS #12, G^SYS$QIO ;#12, SYS$QIO ; RET ; ; 1441 ; Routine Size: 37 bytes, Routine Base: $CODE$ + 0675 ; 1529 %SBTTL 'TERM_CONNECT' ; 1530 ; 1531 GLOBAL ROUTINE TERM_CONNECT = ; 1532 ; 1533 !++ ; 1534 ! FUNCTIONAL DESCRIPTION: ; 1535 ! ; 1536 ! This routine TERM_CONNECT will enable two terminal-like devices, ; 1537 ! MY_TERM and TERM_NAME, to communicate with each other. Anything ; 1538 ! that the user types on his terminal, MYTERM, will be sent to the ; 1539 ! other device, TERM_NAME, over the terminal line TERM_CHAN. ; 1540 ! Anything that TERM_NAME cares to output will be sent to MYTERM. ; 1541 ! The main routine TERM_CONNECT performs the initialization. It ; 1542 ! opens the input and output files and connects streams. ; 1543 ! ; 1544 ! CALLING SEQUENCE: ; 1545 ! ; 1546 ! TERM_CONNECT(); ; 1547 ! ; 1548 ! INPUT PARAMETERS: ; 1549 ! ; 1550 ! None. ; 1551 ! ; 1552 ! IMPLICIT INPUTS: ; 1553 ! ; 1554 ! TERM_DESC - Descriptor of a vector of ASCII characters that represent ; 1555 ! the name of the terminal to use. ; 1556 ! ; 1557 ! OUTPUT PARAMETERS: ; 1558 ! ; 1559 ! None. ; 1560 ! ; 1561 ! IMPLICIT OUTPUTS: ; 1562 ! ; 1563 ! TERM_CHAN - Channel number used by the terminal line to TERM_DESC. ; 1564 ! ; 1565 ! COMPLETION CODES: ; 1566 ! ; 1567 ! SS$_NORMAL or error condition. ; 1568 ! ; 1569 ! SIDE EFFECTS: ; 1570 ! ; 1571 ! None. ; 1572 ! ; 1573 !-- ; 1574 ; 1575 BEGIN ; 1576 ; 1577 LITERAL ; 1578 OUT_BUFLEN = 80, ! Max # of char. in output buffer ; 1579 INP_BUFSIZ = 25, ! Max # of char. in input buffer ; 1580 NUM_OUT_BUF = 2, ! # of output buffers per device ; 1581 NUM_IN_BUF = 2, ! # of input buffers per device ; 1582 MYT = 0, ! Device MY_TERM ; 1583 TRM = 1, ! Device TERM_NAME ; 1584 OFFSET = 1, ! IOSB : offset to terminator ; 1585 TIMEUP = 1, ! Time limit for READ QIO ; 1586 EOFSIZ = 3, ! IOSB : terminator size ; 1587 T_EFN_DISP = NUM_OUT_BUF, ; 1588 XITEFN = 2*NUM_OUT_BUF + 1, ! Exit event flag number ; 1589 EFN_MASK = (1^XITEFN - 1) AND ( NOT 1); ! Mask of flags set by CONNECT ; 1590 ; 1591 STRUCTURE ; 1592 IOSB_VECTOR [D, BUFNUM, INFO; NUMBUF] = ; 1593 [NUMBUF*16] ; 1594 (IOSB_VECTOR + (D*NUMBUF + BUFNUM)*8 + 2*INFO)<0, 16, 0>, ; 1595 BUFFER_VECTOR [D, BUFNUM; NUMBUF, BUFSIZ] = ; 1596 [NUMBUF*BUFSIZ*2 + NUMBUF] ; 1597 (BUFFER_VECTOR + (D*NUMBUF + BUFNUM)*BUFSIZ + D); ; 1598 ; 1599 OWN ; 1600 BTIMUP : VECTOR [4, WORD], ! Time limit in binary format ; 1601 CHANNEL : VECTOR [2, LONG], ! Contains channel #s ; 1602 CHR_COUNT : VECTOR [2, WORD] INITIAL (0), ! # of char. in out buffer ; 1603 ESC_FLG : INITIAL (FALSE), ! Was last char. the ESCAPE_CHR ; 1604 ESC_CHR_MSG : VECTOR [30, BYTE], ! Escape character message ; 1605 IN_IOSB : IOSB_VECTOR [NUM_IN_BUF], ! IOSB status block ; 1606 INP_BUF : BUFFER_VECTOR [NUM_IN_BUF, INP_BUFSIZ], ! Input buffers ; 1607 MSG : VECTOR [80, BYTE], ! Combined escape message ; 1608 MSG_DES : BLOCK [8, BYTE], ! Descriptor for message ; 1609 OUT_BUF : BUFFER_VECTOR [NUM_OUT_BUF, OUT_BUFLEN], ! Output buffers ; 1610 OUT_BUFNUM : VECTOR [2, BYTE], ! Present output buffer ; 1611 OUT_EFN : VECTOR [2, BYTE], ! Present event flag # ; 1612 OUT_PTR : VECTOR [2, LONG], ! CS-pointer for output buffer ; 1613 STATE; ! Used by $READEF to store state of EFs ; 1614 ; 1615 BIND ; 1616 ATIMUP = %ASCID'0 00:00:00.100', ; 1617 MYT_CHAN = CHANNEL [1], ; 1618 MY_TERM = %ASCID'SYS$INPUT:'; ; 1619 ; 1620 LABEL ; 1621 CONN_STREAMS; ; 1622 ; 1623 LOCAL ; 1624 CON_MSG : VECTOR [80, BYTE], ; 1625 CON_MSG_DESC : BLOCK [8, BYTE], ; 1626 STATUS; ; 1627 ; 1628 %SBTTL 'TERM_CONNECT -- TYPE_OUT_BUF' ; 1629 ROUTINE TYPE_OUT_BUF (DEV) = ; 1630 ; 1631 !++ ; 1632 ! This routine send the contents of the output buffer to the other ; 1633 ! device. It also resets the OUT_PTR and the CHR_COUNT and it ; 1634 ! increments OUT_EFN and OUT_BUFNUM. ; 1635 !-- ; 1636 ; 1637 BEGIN ; 1638 ; 1639 LOCAL ; 1640 STATUS; ; 1641 ; 1642 ! Check to make sure exit flag not set before $QIO ; 1643 ; 1644 IF (STATUS = $READEF (EFN = XITEFN, STATE = STATE)) NEQ SS$_WASCLR ; 1645 THEN ; 1646 BEGIN ; 1647 $SETEF (EFN = .OUT_EFN [.DEV]); ; 1648 RETURN .STATUS; ; 1649 END; ; 1650 ; 1651 $WAITFR (EFN = .OUT_EFN [.DEV]); ; 1652 $CLREF (EFN = .OUT_EFN [.DEV]); ; 1653 ; 1654 IF $READEF (EFN = XITEFN, STATE = STATE) EQL SS$_WASCLR ; 1655 THEN ; P 1656 STATUS = $QIO (CHAN = .CHANNEL [.DEV], EFN = .OUT_EFN [.DEV], ; P 1657 FUNC = IO$_WRITEVBLK OR IO$M_NOFORMAT, P1 = OUT_BUF [.DEV, .OUT_BUFNUM [.DEV]], ; 1658 P2 = .CHR_COUNT [.DEV]) ; 1659 ELSE ; 1660 BEGIN ; 1661 $SETEF (EFN = .OUT_EFN [.DEV]); ; 1662 RETURN .STATUS; ; 1663 END; ; 1664 ; 1665 CHR_COUNT [.DEV] = 0; ; 1666 OUT_EFN [.DEV] = .OUT_EFN [.DEV] + 1; ; 1667 ; 1668 IF (OUT_BUFNUM [.DEV] = .OUT_BUFNUM [.DEV] + 1) GEQ NUM_OUT_BUF ; 1669 THEN ; 1670 BEGIN ; 1671 OUT_BUFNUM [.DEV] = 0; ; 1672 OUT_EFN [.DEV] = .DEV*T_EFN_DISP + 1; ; 1673 END; ; 1674 ; 1675 OUT_PTR [.DEV] = CH$PTR (OUT_BUF [.DEV, .OUT_BUFNUM [.DEV]]); ; 1676 ; 1677 IF NOT .STATUS ; 1678 THEN ; 1679 BEGIN ; 1680 LIB$SIGNAL (.STATUS); ; 1681 $SETEF (EFN = XITEFN); ; 1682 END; ; 1683 ; 1684 RETURN .STATUS; ; 1685 END; .PSECT $PLIT$,NOWRT,NOEXE,2 P.AAI: .ASCII \0 00:00:00.100\<0><0> ; ; P.AAH: .LONG 17694734 ; ; .ADDRESS P.AAI ; ; P.AAK: .ASCII \SYS$INPUT:\<0><0> ; ; P.AAJ: .LONG 17694730 ; ; .ADDRESS P.AAK ; ; .PSECT $OWN$,NOEXE,2 .BLKB 3 ;BTIMUP U.26: .BLKB 8 ;CHANNEL U.27: .BLKB 8 ;CHR_COUNT U.28: .LONG 0 ; ; ;ESC_FLG U.29: .LONG 0 ; ; ;ESC_CHR_MSG U.30: .BLKB 30 .BLKB 2 ;IN_IOSB U.31: .BLKB 32 ;INP_BUF U.32: .BLKB 102 .BLKB 2 ;MSG U.33: .BLKB 80 ;MSG_DES U.34: .BLKB 8 ;OUT_BUF U.35: .BLKB 322 .BLKB 2 ;OUT_BUFNUM U.36: .BLKB 2 .BLKB 2 ;OUT_EFN U.37: .BLKB 2 .BLKB 2 ;OUT_PTR U.38: .BLKB 8 ;STATE U.39: .BLKB 4 U.40= P.AAH U.41= U.27+4 U.42= P.AAJ .EXTRN SYS$SETEF .PSECT $CODE$,NOWRT,2 ;TYPE_OUT_BUF U.43: .WORD ^M ;Save R2,R3,R4,R5,R6 ; 1629 MOVAB G^SYS$READEF, R6 ;SYS$READEF, R6 ; MOVAB W^U.39, R5 ;U.39, R5 ; PUSHL R5 ;R5 ; 1644 PUSHL #5 ;#5 ; CALLS #2, (R6) ;#2, SYS$READEF ; MOVL R0, R4 ;R0, STATUS ; CMPL R4, #1 ;STATUS, #1 ; BEQL 1$ ;1$ ; MOVAB -12(R5), R0 ;OUT_EFN, R0 ; 1647 MOVZBL @4(AP)[R0], -(SP) ;@DEV[R0], -(SP) ; BRB 3$ ;3$ ; 1$: MOVL 4(AP), R2 ;DEV, R2 ; 1651 MOVAB -12(R5)[R2], R3 ;OUT_EFN[R2], R3 ; MOVZBL (R3), -(SP) ;(R3), -(SP) ; CALLS #1, G^SYS$WAITFR ;#1, SYS$WAITFR ; MOVZBL (R3), -(SP) ;(R3), -(SP) ; 1652 CALLS #1, G^SYS$CLREF ;#1, SYS$CLREF ; PUSHL R5 ;R5 ; 1654 PUSHL #5 ;#5 ; CALLS #2, (R6) ;#2, SYS$READEF ; CMPL R0, #1 ;R0, #1 ; BNEQ 2$ ;2$ ; CLRQ -(SP) ;-(SP) ; 1658 CLRQ -(SP) ;-(SP) ; MOVZWL -604(R5)[R2], -(SP) ;CHR_COUNT[R2], -(SP) ; MOVZBL -16(R5)[R2], R0 ;OUT_BUFNUM[R2], R0 ; MOVAW (R0)[R2], R0 ;(R0)[R2], R0 ; MULL2 #80, R0 ;#80, R0 ; MOVAB -340(R5)[R0], R0 ;OUT_BUF[R0], R0 ; PUSHAB (R2)[R0] ;(R2)[R0] ; CLRQ -(SP) ;-(SP) ; CLRL -(SP) ;-(SP) ; MOVZWL #304, -(SP) ;#304, -(SP) ; PUSHL -612(R5)[R2] ;CHANNEL[R2] ; MOVZBL (R3), -(SP) ;(R3), -(SP) ; CALLS #12, G^SYS$QIO ;#12, SYS$QIO ; MOVL R0, R4 ;R0, STATUS ; BRB 4$ ;4$ ; 1654 2$: MOVZBL (R3), -(SP) ;(R3), -(SP) ; 1661 3$: BRB 6$ ;6$ ; 4$: CLRW -604(R5)[R2] ;CHR_COUNT[R2] ; 1665 INCB (R3) ;(R3) ; 1666 MOVAB -16(R5)[R2], R1 ;OUT_BUFNUM[R2], R1 ; 1668 MOVZBL (R1), R0 ;(R1), R0 ; INCL R0 ;R0 ; MOVB R0, (R1) ;R0, (R1) ; CMPL R0, #2 ;R0, #2 ; BLSS 5$ ;5$ ; CLRB (R1) ;(R1) ; 1671 ASHL #1, R2, R0 ;#1, R2, R0 ; 1672 ADDB3 #1, R0, (R3) ;#1, R0, (R3) ; 5$: MOVZBL (R1), R0 ;(R1), R0 ; 1675 MOVAW (R0)[R2], R0 ;(R0)[R2], R0 ; MULL2 #80, R0 ;#80, R0 ; MOVAB -340(R5)[R0], R0 ;OUT_BUF[R0], R0 ; ADDL3 R2, R0, -8(R5)[R2] ;R2, R0, OUT_PTR[R2] ; BLBS R4, 7$ ;STATUS, 7$ ; 1677 PUSHL R4 ;STATUS ; 1680 CALLS #1, G^LIB$SIGNAL ;#1, LIB$SIGNAL ; PUSHL #5 ;#5 ; 1681 6$: CALLS #1, G^SYS$SETEF ;#1, SYS$SETEF ; 7$: MOVL R4, R0 ;STATUS, R0 ; 1637 RET ; ; 1629 ; Routine Size: 236 bytes, Routine Base: $CODE$ + 069A ; 1686 %SBTTL 'TERM_CONNECT -- TIME_UP' ; 1687 ROUTINE TIME_UP (OUTEFN) : NOVALUE = ; 1688 ; 1689 !++ ; 1690 ! AST routine called 0.1 second after first character is input. It calls ; 1691 ! TYPE_OUT_BUF to transmit output buffer. ; 1692 !-- ; 1693 ; 1694 BEGIN ; 1695 ; 1696 LOCAL ; 1697 DEV; ; 1698 ; 1699 IF (.OUTEFN - T_EFN_DISP) LEQ 0 ; 1700 THEN ; 1701 DEV = 0 ! Device was MY_TERM ; 1702 ELSE ; 1703 DEV = 1; ! Device was TERM_NAME ; 1704 ; 1705 TYPE_OUT_BUF (.DEV); ; 1706 END; ! End of TIME_UP ;TIME_UP U.44: .WORD ^M<> ;Save nothing ; 1687 CMPL 4(AP), #2 ;OUTEFN, #2 ; 1699 BGTR 1$ ;1$ ; CLRL R0 ;DEV ; 1701 BRB 2$ ;2$ ; 1699 1$: MOVL #1, R0 ;#1, DEV ; 1703 2$: PUSHL R0 ;DEV ; 1705 CALLS #1, W^U.43 ;#1, U.43 ; RET ; ; 1687 ; Routine Size: 23 bytes, Routine Base: $CODE$ + 0786 ; 1707 %SBTTL 'TERM_CONNECT -- STORE_INPUT' ; 1708 ROUTINE STORE_INPUT (DEV, INP_BUFNUM, NUM_CHR_IN) : NOVALUE = ; 1709 ; 1710 !++ ; 1711 ! This routine stores the input buffer in the output buffer and keeps ; 1712 ! track of the number of characters in the output buffer. It also ; 1713 ! calls TYPE_OUT_BUF when the output buffer is full and it sets up ; 1714 ! the timer routine TIME_UP. ; 1715 !-- ; 1716 ; 1717 BEGIN ; 1718 ; 1719 LOCAL ; 1720 STATUS; ; 1721 ; 1722 IF (STATUS = $READEF (EFN = XITEFN, STATE = STATE)) NEQ SS$_WASCLR THEN RETURN .STATUS; ; 1723 ; 1724 IF .NUM_CHR_IN EQL 0 THEN RETURN .STATUS; ; 1725 ; 1726 IF .CHR_COUNT [.DEV] EQL 0 ; 1727 THEN ; 1728 BEGIN ; 1729 STATUS = $SETIMR (DAYTIM = BTIMUP, ASTADR = TIME_UP, REQIDT = .OUT_EFN [.DEV]); ; 1730 ; 1731 IF NOT .STATUS ; 1732 THEN ; 1733 BEGIN ; 1734 LIB$SIGNAL (.STATUS); ; 1735 $SETEF (EFN = XITEFN); ; 1736 RETURN .STATUS; ; 1737 END; ; 1738 ; 1739 END; ; 1740 ; 1741 OUT_PTR [.DEV] = CH$MOVE (.NUM_CHR_IN, CH$PTR (INP_BUF [.DEV, .INP_BUFNUM]), ; 1742 .OUT_PTR [.DEV]); ; 1743 ; 1744 IF (CHR_COUNT [.DEV] = .CHR_COUNT [.DEV] + .NUM_CHR_IN) GEQ OUT_BUFLEN - INP_BUFSIZ ; 1745 THEN ; 1746 BEGIN ; 1747 $CANTIM (REQIDT = .OUT_EFN [.DEV]); ; 1748 TYPE_OUT_BUF (.DEV); ; 1749 END; ; 1750 ; 1751 RETURN .STATUS; ; 1752 END; ! End of STORE_INPUT ;STORE_INPUT U.45: .WORD ^M ;Save R2,R3,R4,R5,R6,R7,R8,R9 ; 1708 MOVAB W^U.37, R9 ;U.37, R9 ; PUSHAB 12(R9) ;STATE ; 1722 PUSHL #5 ;#5 ; CALLS #2, G^SYS$READEF ;#2, SYS$READEF ; MOVL R0, R2 ;R0, STATUS ; CMPL R2, #1 ;STATUS, #1 ; BEQL 1$ ;1$ ; RET ; ; 1$: MOVL 12(AP), R8 ;NUM_CHR_IN, R8 ; 1724 BEQL 3$ ;3$ ; MOVL 4(AP), R6 ;DEV, R6 ; 1726 MOVAW -592(R9)[R6], R7 ;CHR_COUNT[R6], R7 ; TSTW (R7) ;(R7) ; BNEQ 2$ ;2$ ; MOVZBL (R9)[R6], -(SP) ;OUT_EFN[R6], -(SP) ; 1729 PUSHAB B^U.44 ;U.44 ; PUSHAB -608(R9) ;BTIMUP ; CLRL -(SP) ;-(SP) ; CALLS #4, G^SYS$SETIMR ;#4, SYS$SETIMR ; MOVL R0, R2 ;R0, STATUS ; BLBS R2, 2$ ;STATUS, 2$ ; 1731 PUSHL R2 ;STATUS ; 1734 CALLS #1, G^LIB$SIGNAL ;#1, LIB$SIGNAL ; PUSHL #5 ;#5 ; 1735 CALLS #1, G^SYS$SETEF ;#1, SYS$SETEF ; RET ; ; 1733 2$: MOVAW @8(AP)[R6], R0 ;@INP_BUFNUM[R6], R0 ; 1741 MULL2 #25, R0 ;#25, R0 ; MOVAB -520(R9)[R0], R0 ;INP_BUF[R0], R0 ; MOVL 4(R9)[R6], R1 ;OUT_PTR[R6], R1 ; 1742 MOVC3 R8, (R6)[R0], (R1) ;R8, (R6)[R0], (R1) ; 1741 MOVL R3, 4(R9)[R6] ;R3, OUT_PTR[R6] ; MOVZWL (R7), R0 ;(R7), R0 ; 1744 ADDL2 R8, R0 ;R8, R0 ; MOVW R0, (R7) ;R0, (R7) ; CMPL R0, #55 ;R0, #55 ; BLSS 3$ ;3$ ; CLRL -(SP) ;-(SP) ; 1747 MOVZBL (R9)[R6], -(SP) ;OUT_EFN[R6], -(SP) ; CALLS #2, G^SYS$CANTIM ;#2, SYS$CANTIM ; PUSHL R6 ;R6 ; 1748 CALLS #1, W^U.43 ;#1, U.43 ; 3$: RET ; ; 1708 ; Routine Size: 157 bytes, Routine Base: $CODE$ + 079D ; 1753 %SBTTL 'TERM_CONNECT -- MYTINP' ; 1754 ROUTINE MYTINP (INP_BUFNUM) = ; 1755 ; 1756 !++ ; 1757 ! This AST routine gets characters from the channel MYT_CHAN and outputs ; 1758 ! them on the channel TERM_CHAN. It also checks to see if the exit ; 1759 ! characters have been typed. If they have been typed, MYTINP sets the ; 1760 ! event flag XITEFN. INP_BUFNUM contains the # of the input buffer. ; 1761 !-- ; 1762 ; 1763 BEGIN ; 1764 ; 1765 OWN ; 1766 STATUS, ; 1767 NUM_CHR_IN; ; 1768 ; 1769 %SBTTL 'TERM_CONNECT -- MYTINP -- CHK_FOR_EXIT' ; 1770 ROUTINE CHK_FOR_EXIT (INP_BUFNUM) = ; 1771 ; 1772 !++ ; 1773 ! This routine checks to see if the exit characters have been typed. It ; 1774 ! returns TRUE if found and FALSE if not. If only 1 ESCAPE_CHR found ; 1775 ! then ESC_FLG is set to TRUE. ; 1776 !-- ; 1777 ; 1778 BEGIN ; 1779 ; 1780 LOCAL ; 1781 ESC_PTR, ; 1782 INDEX : INITIAL (0), ! Displacement of ESC from beginning of buffer ; 1783 PTR0; ! Points to beginning of input buffer ; 1784 ; 1785 PTR0 = CH$PTR (INP_BUF [MYT, .INP_BUFNUM]); ; 1786 ; 1787 IF .ESC_FLG EQL TRUE ! ESCAPE_CHR was previously typed. ; 1788 THEN ; 1789 BEGIN ; 1790 INDEX = 0; ; 1791 ESC_PTR = .PTR0; ; 1792 ESC_FLG = FALSE; ; 1793 END ; 1794 ELSE ; 1795 ; 1796 IF (ESC_PTR = CH$FIND_CH (.NUM_CHR_IN, .PTR0, .ESCAPE_CHR)) EQL 0 ; 1797 THEN ; 1798 RETURN FALSE ; 1799 ELSE ; 1800 BEGIN ; 1801 INDEX = CH$DIFF (.PTR0, .ESC_PTR); ; 1802 ; 1803 IF .INDEX NEQ (NUM_CHR_IN = .NUM_CHR_IN - 1) ; 1804 THEN ; 1805 BEGIN ; 1806 CH$COPY (.NUM_CHR_IN - .INDEX, CH$PLUS (.ESC_PTR, 1), 0, ; 1807 .NUM_CHR_IN - .INDEX, .ESC_PTR); ; 1808 END ; 1809 ELSE ! ESCAPE_CHR was last character. ; 1810 BEGIN ; 1811 ESC_FLG = TRUE; ; 1812 RETURN FALSE; ; 1813 END; ; 1814 ; 1815 END; ; 1816 ; 1817 SELECTONE CH$RCHAR (.ESC_PTR) OF ; 1818 SET ; 1819 ; 1820 ['C', 'c'] : ; 1821 BEGIN ; 1822 NUM_CHR_IN = .INDEX; ; 1823 RETURN TRUE; ; 1824 END; ; 1825 ; 1826 [.ESCAPE_CHR] : ; 1827 CH$WCHAR (.ESCAPE_CHR, .ESC_PTR); ; 1828 ; 1829 [OTHERWISE] : ; 1830 BEGIN ! Send a bell char. to MY_TERM ; 1831 INP_BUF [TRM, NUM_IN_BUF] = CHR_BEL; ; 1832 STORE_INPUT (TRM, NUM_IN_BUF, 1); ; 1833 ; 1834 IF (NUM_CHR_IN = .NUM_CHR_IN - 1) EQL .INDEX THEN RETURN FALSE; ; 1835 ; 1836 CH$COPY (.NUM_CHR_IN - .INDEX, CH$PLUS (.ESC_PTR, 1), 0, .NUM_CHR_IN - .INDEX, ; 1837 .ESC_PTR); ; 1838 END; ; 1839 TES; ; 1840 ; 1841 RETURN FALSE; ; 1842 END; ! End of CHK_FOR_EXIT .PSECT $OWN$,NOEXE,2 ;STATUS U.47: .BLKB 4 ;NUM_CHR_IN U.48: .BLKB 4 .PSECT $CODE$,NOWRT,2 ;CHK_FOR_EXIT U.49: .WORD ^M ;Save R2,R3,R4,R5,R6,R7,R8,R9 ; 1770 MOVAB W^ESCAPE_CHR, R9 ;ESCAPE_CHR, R9 ; MOVAB W^U.48, R8 ;U.48, R8 ; CLRL R7 ;INDEX ; 1778 MULL3 #25, 4(AP), R0 ;#25, INP_BUFNUM, R0 ; 1785 MOVAB -540(R8)[R0], R2 ;INP_BUF[R0], PTR0 ; CMPL -608(R8), #1 ;ESC_FLG, #1 ; 1787 BNEQ 1$ ;1$ ; CLRL R7 ;INDEX ; 1790 MOVL R2, R6 ;PTR0, ESC_PTR ; 1791 CLRL -608(R8) ;ESC_FLG ; 1792 BRB 4$ ;4$ ; 1787 1$: LOCC (R9), (R8), (R2) ;ESCAPE_CHR, NUM_CHR_IN, (PTR0) ; 1796 BNEQ 2$ ;2$ ; CLRL R1 ;R1 ; 2$: MOVL R1, R6 ;R1, ESC_PTR ; BEQL 8$ ;8$ ; SUBL3 R6, R2, R7 ;ESC_PTR, PTR0, INDEX ; 1801 SUBL3 #1, (R8), R0 ;#1, NUM_CHR_IN, R0 ; 1803 MOVL R0, (R8) ;R0, NUM_CHR_IN ; CMPL R7, R0 ;INDEX, R0 ; BEQL 3$ ;3$ ; SUBL3 R7, (R8), R0 ;INDEX, NUM_CHR_IN, R0 ; 1806 MOVC3 R0, 1(R6), (R6) ;R0, 1(ESC_PTR), (ESC_PTR) ; BRB 4$ ;4$ ; 1803 3$: MOVL #1, -608(R8) ;#1, ESC_FLG ; 1811 BRB 8$ ;8$ ; 1810 4$: CMPB (R6), #67 ;(ESC_PTR), #67 ; 1817 BEQL 5$ ;5$ ; CMPB (R6), #99 ;(ESC_PTR), #99 ; BNEQ 6$ ;6$ ; 5$: MOVL R7, (R8) ;INDEX, NUM_CHR_IN ; 1822 MOVL #1, R0 ;#1, R0 ; 1821 RET ; ; 6$: CMPZV #0, #8, (R6), (R9) ;#0, #8, (ESC_PTR), ESCAPE_CHR ; 1817 BNEQ 7$ ;7$ ; MOVB (R9), (R6) ;ESCAPE_CHR, (ESC_PTR) ; 1827 BRB 8$ ;8$ ; 1817 7$: MOVL #7, -439(R8) ;#7, INP_BUF+101 ; 1831 PUSHL #1 ;#1 ; 1832 PUSHL #2 ;#2 ; PUSHL #1 ;#1 ; CALLS #3, W^U.45 ;#3, U.45 ; SUBL3 #1, (R8), R0 ;#1, NUM_CHR_IN, R0 ; 1834 MOVL R0, (R8) ;R0, NUM_CHR_IN ; CMPL R0, R7 ;R0, INDEX ; BEQL 8$ ;8$ ; SUBL3 R7, (R8), R0 ;INDEX, NUM_CHR_IN, R0 ; 1836 MOVC3 R0, 1(R6), (R6) ;R0, 1(ESC_PTR), (ESC_PTR) ; 8$: CLRL R0 ;R0 ; 1770 RET ; ; ; Routine Size: 161 bytes, Routine Base: $CODE$ + 083A ; 1843 %SBTTL 'TERM_CONNECT -- MYTINP' ; 1844 ! Main portion of MYTINP ; 1845 ; 1846 IF (STATUS = $READEF (EFN = XITEFN, STATE = STATE)) NEQ SS$_WASCLR THEN RETURN .STATUS; ; 1847 ; 1848 NUM_CHR_IN = .IN_IOSB [MYT, .INP_BUFNUM, OFFSET] + .IN_IOSB [MYT, .INP_BUFNUM, EOFSIZ]; ; 1849 ; 1850 IF .NUM_CHR_IN NEQ 0 ; 1851 THEN ; 1852 ; 1853 IF CHK_FOR_EXIT (.INP_BUFNUM) ; 1854 THEN ; 1855 BEGIN ; 1856 $CANTIM (); ; 1857 $SETEF (EFN = XITEFN); ! Exit characters typed. Set flag. ; 1858 RETURN 1; ; 1859 END ; 1860 ELSE ; 1861 STORE_INPUT (MYT, .INP_BUFNUM, .NUM_CHR_IN); ! Store char. ; 1862 ; 1863 IF (STATUS = $READEF (EFN = XITEFN, STATE = STATE)) EQL SS$_WASCLR ; 1864 THEN ; P 1865 STATUS = $QIO (CHAN = .MYT_CHAN, FUNC = IO$M_NOECHO OR IO$M_TIMED OR IO$_TTYREADALL, ; P 1866 ASTADR = MYTINP, P1 = INP_BUF [MYT, .INP_BUFNUM], P2 = INP_BUFSIZ, P3 = TIMEUP, ; 1867 ASTPRM = .INP_BUFNUM, IOSB = IN_IOSB [MYT, .INP_BUFNUM, 0]); ; 1868 ; 1869 IF NOT .STATUS ; 1870 THEN ; 1871 BEGIN ; 1872 LIB$SIGNAL (.STATUS); ; 1873 $SETEF (EFN = XITEFN); ; 1874 END; ; 1875 ; 1876 RETURN .STATUS; ; 1877 END; ! End of MYTINP ;MYTINP U.46: .WORD ^M ;Save R2,R3,R4,R5 ; 1754 MOVAB G^SYS$SETEF, R5 ;SYS$SETEF, R5 ; MOVAB G^SYS$READEF, R4 ;SYS$READEF, R4 ; MOVAB W^U.47, R3 ;U.47, R3 ; PUSHAB -4(R3) ;STATE ; 1846 PUSHL #5 ;#5 ; CALLS #2, (R4) ;#2, SYS$READEF ; MOVL R0, (R3) ;R0, STATUS ; CMPL R0, #1 ;R0, #1 ; BEQL 1$ ;1$ ; BRW 5$ ;5$ ; 1$: MOVL 4(AP), R2 ;INP_BUFNUM, R2 ; 1848 PUSHAQ -566(R3)[R2] ;IN_IOSB+2[R2] ; MOVZWL @(SP)+, R0 ;@(SP)+, R0 ; PUSHAQ -562(R3)[R2] ;IN_IOSB+6[R2] ; MOVZWL @(SP)+, R1 ;@(SP)+, R1 ; ADDL3 R1, R0, 4(R3) ;R1, R0, NUM_CHR_IN ; BEQL 3$ ;3$ ; 1850 PUSHL R2 ;R2 ; 1853 CALLS #1, W^U.49 ;#1, U.49 ; BLBC R0, 2$ ;R0, 2$ ; CLRQ -(SP) ;-(SP) ; 1856 CALLS #2, G^SYS$CANTIM ;#2, SYS$CANTIM ; PUSHL #5 ;#5 ; 1857 CALLS #1, (R5) ;#1, SYS$SETEF ; MOVL #1, R0 ;#1, R0 ; 1855 RET ; ; 2$: PUSHL 4(R3) ;NUM_CHR_IN ; 1861 PUSHL R2 ;R2 ; CLRL -(SP) ;-(SP) ; CALLS #3, W^U.45 ;#3, U.45 ; 3$: PUSHAB -4(R3) ;STATE ; 1863 PUSHL #5 ;#5 ; CALLS #2, (R4) ;#2, SYS$READEF ; MOVL R0, (R3) ;R0, STATUS ; CMPL R0, #1 ;R0, #1 ; BNEQ 4$ ;4$ ; CLRQ -(SP) ;-(SP) ; 1867 MOVQ #1, -(SP) ;#1, -(SP) ; PUSHL #25 ;#25 ; MULL3 #25, R2, R0 ;#25, R2, R0 ; PUSHAB -536(R3)[R0] ;INP_BUF[R0] ; PUSHL R2 ;R2 ; PUSHAB W^U.46 ;U.46 ; PUSHAQ -568(R3)[R2] ;IN_IOSB[R2] ; MOVZBL #250, -(SP) ;#250, -(SP) ; PUSHL -612(R3) ;MYT_CHAN ; CLRL -(SP) ;-(SP) ; CALLS #12, G^SYS$QIO ;#12, SYS$QIO ; MOVL R0, (R3) ;R0, STATUS ; 4$: BLBS (R3), 5$ ;STATUS, 5$ ; 1869 PUSHL (R3) ;STATUS ; 1872 CALLS #1, G^LIB$SIGNAL ;#1, LIB$SIGNAL ; PUSHL #5 ;#5 ; 1873 CALLS #1, (R5) ;#1, SYS$SETEF ; 5$: MOVL (R3), R0 ;STATUS, R0 ; 1763 RET ; ; 1754 ; Routine Size: 191 bytes, Routine Base: $CODE$ + 08DB ; 1878 %SBTTL 'TERM_CONNECT -- TRMINP' ; 1879 ROUTINE TRMINP (INP_BUFNUM) = ; 1880 ; 1881 !++ ; 1882 ! This AST routine receives characters from the channel TERM_CHAN and ; 1883 ! outputs the characters to the channel MYT_CHAN. INP_BUFNUM contains ; 1884 ! the number of the input buffer. ; 1885 !-- ; 1886 ; 1887 BEGIN ; 1888 ; 1889 LOCAL ; 1890 NUM_CHR_IN, ; 1891 STATUS; ; 1892 ; 1893 IF (STATUS = $READEF (EFN = XITEFN, STATE = STATE)) NEQ SS$_WASCLR THEN RETURN .STATUS; ; 1894 ; 1895 NUM_CHR_IN = .IN_IOSB [TRM, .INP_BUFNUM, OFFSET] + .IN_IOSB [TRM, .INP_BUFNUM, EOFSIZ]; ; 1896 ; 1897 IF .NUM_CHR_IN NEQ 0 THEN STORE_INPUT (TRM, .INP_BUFNUM, .NUM_CHR_IN); ; 1898 ; 1899 IF (STATUS = $READEF (EFN = XITEFN, STATE = STATE)) EQL SS$_WASCLR ; 1900 THEN ; P 1901 STATUS = $QIO (CHAN = .TERM_CHAN, FUNC = IO$_TTYREADALL OR IO$M_NOECHO OR IO$M_TIMED, ; P 1902 ASTADR = TRMINP, P1 = INP_BUF [TRM, .INP_BUFNUM], P2 = INP_BUFSIZ, P3 = TIMEUP, ; 1903 IOSB = IN_IOSB [TRM, .INP_BUFNUM, 0], ASTPRM = .INP_BUFNUM); ; 1904 ; 1905 IF NOT .STATUS ; 1906 THEN ; 1907 BEGIN ; 1908 LIB$SIGNAL (.STATUS); ; 1909 $SETEF (EFN = XITEFN); ; 1910 END; ; 1911 ; 1912 RETURN .STATUS; ; 1913 END; ! End of TRMINP ;TRMINP U.50: .WORD ^M ;Save R2,R3,R4 ; 1879 MOVAB G^SYS$READEF, R4 ;SYS$READEF, R4 ; PUSHAB W^U.39 ;U.39 ; 1893 PUSHL #5 ;#5 ; CALLS #2, (R4) ;#2, SYS$READEF ; MOVL R0, R3 ;R0, STATUS ; CMPL R3, #1 ;STATUS, #1 ; BNEQ 3$ ;3$ ; MOVL 4(AP), R2 ;INP_BUFNUM, R2 ; 1895 PUSHAQ W^U.31+18[R2] ;U.31+18[R2] ; MOVZWL @(SP)+, R0 ;@(SP)+, NUM_CHR_IN ; PUSHAQ W^U.31+22[R2] ;U.31+22[R2] ; MOVZWL @(SP)+, R1 ;@(SP)+, R1 ; ADDL2 R1, R0 ;R1, NUM_CHR_IN ; BEQL 1$ ;1$ ; 1897 PUSHL R0 ;NUM_CHR_IN ; PUSHL R2 ;R2 ; PUSHL #1 ;#1 ; CALLS #3, W^U.45 ;#3, U.45 ; 1$: PUSHAB W^U.39 ;U.39 ; 1899 PUSHL #5 ;#5 ; CALLS #2, (R4) ;#2, SYS$READEF ; MOVL R0, R3 ;R0, STATUS ; CMPL R3, #1 ;STATUS, #1 ; BNEQ 2$ ;2$ ; CLRQ -(SP) ;-(SP) ; 1903 MOVQ #1, -(SP) ;#1, -(SP) ; PUSHL #25 ;#25 ; MULL3 #25, R2, R0 ;#25, R2, R0 ; PUSHAB W^U.32+51[R0] ;U.32+51[R0] ; PUSHL R2 ;R2 ; PUSHAB B^U.50 ;U.50 ; PUSHAQ W^U.31+16[R2] ;U.31+16[R2] ; MOVZBL #250, -(SP) ;#250, -(SP) ; PUSHL W^U.3 ;U.3 ; CLRL -(SP) ;-(SP) ; CALLS #12, G^SYS$QIO ;#12, SYS$QIO ; MOVL R0, R3 ;R0, STATUS ; 2$: BLBS R3, 3$ ;STATUS, 3$ ; 1905 PUSHL R3 ;STATUS ; 1908 CALLS #1, G^LIB$SIGNAL ;#1, LIB$SIGNAL ; PUSHL #5 ;#5 ; 1909 CALLS #1, G^SYS$SETEF ;#1, SYS$SETEF ; 3$: MOVL R3, R0 ;STATUS, R0 ; 1887 RET ; ; 1879 ; Routine Size: 150 bytes, Routine Base: $CODE$ + 099A ; 1914 %SBTTL 'TERM_CONNECT -- ESC_MSG' ; 1915 ROUTINE ESC_MSG : NOVALUE = ; 1916 BEGIN ; 1917 ; 1918 LOCAL ; 1919 ESC_LEN; ; 1920 ; 1921 ESC_LEN = 0; ; 1922 ; 1923 SELECTONE .ESCAPE_CHR OF ; 1924 SET ; 1925 ; 1926 [CHR_NUL, 0] : ; 1927 BEGIN ; 1928 ESC_LEN = 28; ; 1929 CH$MOVE (.ESC_LEN, CH$PTR (PLIT ('ctrl-@ or on VT-100 ctrl-spc')), ; 1930 CH$PTR (ESC_CHR_MSG)); ; 1931 END; ; 1932 ; 1933 [CHR_RS, %O'36'] : ; 1934 BEGIN ; 1935 ESC_LEN = 26; ; 1936 CH$MOVE (.ESC_LEN, CH$PTR (PLIT ('ctrl-^ or on VT-100 ctrl-~')), ; 1937 CH$PTR (ESC_CHR_MSG)); ; 1938 END; ; 1939 ; 1940 [CHR_US, %O'37'] : ; 1941 BEGIN ; 1942 ESC_LEN = 26; ; 1943 CH$MOVE (.ESC_LEN, CH$PTR (PLIT ('ctrl-- or on VT-100 ctrl-?')), ; 1944 CH$PTR (ESC_CHR_MSG)); ; 1945 END; ; 1946 ; 1947 [1 TO %O'37'] : ; 1948 BEGIN ; 1949 ESC_LEN = 6; ; 1950 CH$MOVE (.ESC_LEN, CH$PTR (PLIT ('ctrl-')), CH$PTR (ESC_CHR_MSG)); ; 1951 ESC_CHR_MSG [5] = .ESCAPE_CHR + %O'100'; ; 1952 END; ; 1953 ; 1954 [%O'40' TO %O'176'] : ; 1955 BEGIN ; 1956 ESC_LEN = 3; ; 1957 ESC_CHR_MSG = '"'; ; 1958 ESC_CHR_MSG [1] = .ESCAPE_CHR; ; 1959 ESC_CHR_MSG [2] = '"'; ; 1960 END; ; 1961 ; 1962 [CHR_DEL, %O'177'] : ; 1963 BEGIN ; 1964 ESC_LEN = 3; ; 1965 ESC_CHR_MSG = 'DEL'; ; 1966 END; ; 1967 TES; ; 1968 ; 1969 MSG_DES [DSC$B_CLASS] = DSC$K_CLASS_S; ; 1970 MSG_DES [DSC$B_DTYPE] = DSC$K_DTYPE_T; ; 1971 MSG_DES [DSC$A_POINTER] = MSG; ; 1972 MSG_DES [DSC$W_LENGTH] = .ESC_LEN + 34; ; 1973 CH$COPY (14, CH$PTR (UPLIT (' Type ')), .ESC_LEN, CH$PTR (ESC_CHR_MSG), 20, ; 1974 CH$PTR (UPLIT (' and "C" to exit. ]')), 0, .MSG_DES [DSC$W_LENGTH], CH$PTR (MSG)); ; 1975 LIB$PUT_OUTPUT (MSG_DES); ; 1976 END; ! End of ESC_MSG .PSECT $PLIT$,NOWRT,NOEXE,2 .LONG 7 ; ; P.AAL: .ASCII \ctrl-@ or on VT-100 ctrl-spc\ ; ; .LONG 7 ; ; P.AAM: .ASCII \ctrl-^ or on VT-100 ctrl-~\<0><0> ; ; .LONG 7 ; ; P.AAN: .ASCII \ctrl-- or on VT-100 ctrl-?\<0><0> ; ; .LONG 2 ; ; P.AAO: .ASCII \ctrl-\<0><0><0> ; ; P.AAP: .ASCII \ Type \<0><0> ; ; P.AAQ: .ASCII \ and "C" to exit. ]\<0> ; ; .PSECT $CODE$,NOWRT,2 ;ESC_MSG U.51: .WORD ^M ;Save R2,R3,R4,R5,R6,R7,R8,R9,R10 ; 1915 MOVAB W^P.AAL, R10 ;P.AAL, R10 ; MOVAB W^U.30, R9 ;U.30, R9 ; CLRL R7 ;ESC_LEN ; 1921 MOVL W^ESCAPE_CHR, R6 ;ESCAPE_CHR, R6 ; 1923 BNEQ 1$ ;1$ ; MOVL #28, R7 ;#28, ESC_LEN ; 1928 MOVC3 R7, (R10), (R9) ;ESC_LEN, P.AAL, ESC_CHR_MSG ; 1929 BRB 6$ ;6$ ; 1923 1$: CMPL R6, #30 ;R6, #30 ; BNEQ 2$ ;2$ ; MOVL #26, R7 ;#26, ESC_LEN ; 1935 MOVC3 R7, 32(R10), (R9) ;ESC_LEN, P.AAM, ESC_CHR_MSG ; 1936 BRB 6$ ;6$ ; 1923 2$: CMPL R6, #31 ;R6, #31 ; BNEQ 3$ ;3$ ; MOVL #26, R7 ;#26, ESC_LEN ; 1942 MOVC3 R7, 64(R10), (R9) ;ESC_LEN, P.AAN, ESC_CHR_MSG ; 1943 BRB 6$ ;6$ ; 1923 3$: TSTL R6 ;R6 ; BLEQ 4$ ;4$ ; CMPL R6, #31 ;R6, #31 ; BGTR 4$ ;4$ ; MOVL #6, R7 ;#6, ESC_LEN ; 1949 MOVC3 R7, 96(R10), (R9) ;ESC_LEN, P.AAO, ESC_CHR_MSG ; 1950 ADDB3 #64, R6, 5(R9) ;#64, R6, ESC_CHR_MSG+5 ; 1951 BRB 6$ ;6$ ; 1923 4$: CMPL R6, #32 ;R6, #32 ; BLSS 5$ ;5$ ; CMPL R6, #126 ;R6, #126 ; BGTR 5$ ;5$ ; MOVL #3, R7 ;#3, ESC_LEN ; 1956 MOVL #34, (R9) ;#34, ESC_CHR_MSG ; 1957 MOVB R6, 1(R9) ;R6, ESC_CHR_MSG+1 ; 1958 MOVB #34, 2(R9) ;#34, ESC_CHR_MSG+2 ; 1959 BRB 6$ ;6$ ; 1923 5$: CMPL R6, #127 ;R6, #127 ; BNEQ 6$ ;6$ ; MOVL #3, R7 ;#3, ESC_LEN ; 1964 MOVL #4998468, (R9) ;#4998468, ESC_CHR_MSG ; 1965 6$: MOVW #270, 250(R9) ;#270, MSG_DES+2 ; 1970 MOVAB 168(R9), 252(R9) ;MSG, MSG_DES+4 ; 1971 ADDW3 #34, R7, 248(R9) ;#34, ESC_LEN, MSG_DES ; 1972 MOVZWL 248(R9), R8 ;MSG_DES, R8 ; 1974 MOVAB 168(R9), R6 ;MSG, R6 ; MOVC5 #14, 104(R10), #0, R8, (R6) ;#14, P.AAP, #0, R8, (R6) ; 1973 BGEQ 7$ ;7$ ; ADDL2 #14, R6 ;#14, R6 ; SUBL2 #14, R8 ;#14, R8 ; MOVC5 R7, (R9), #0, R8, (R6) ;ESC_LEN, ESC_CHR_MSG, #0, R8, (R6) ; BGEQ 7$ ;7$ ; ADDL2 R7, R6 ;ESC_LEN, R6 ; SUBL2 R7, R8 ;ESC_LEN, R8 ; MOVC5 #20, 120(R10), #0, R8, (R6) ;#20, P.AAQ, #0, R8, (R6) ; 7$: PUSHAB 248(R9) ;MSG_DES ; 1975 CALLS #1, G^LIB$PUT_OUTPUT ;#1, LIB$PUT_OUTPUT ; RET ; ; 1915 ; Routine Size: 212 bytes, Routine Base: $CODE$ + 0A30 ; 1977 %SBTTL 'TERM_CONNECT -- INITIALIZATION' ; 1978 ! Initialize variables ; 1979 CHR_COUNT [0] = 0; ; 1980 CHR_COUNT [1] = 0; ; 1981 ESC_FLG = FALSE; ; 1982 OUT_BUFNUM [0] = 0; ; 1983 OUT_BUFNUM [1] = 0; ; 1984 OUT_EFN [0] = 1; ; 1985 OUT_EFN [1] = T_EFN_DISP + 1; ; 1986 OUT_PTR [0] = CH$PTR (OUT_BUF [0, .OUT_BUFNUM [0]]); ; 1987 OUT_PTR [1] = CH$PTR (OUT_BUF [1, .OUT_BUFNUM [1]]); ; 1988 $BINTIM (TIMBUF = ATIMUP, TIMADR = BTIMUP); ; 1989 ! Initialize Connect message ; 1990 CON_MSG_DESC [DSC$B_CLASS] = DSC$K_CLASS_S; ; 1991 CON_MSG_DESC [DSC$B_DTYPE] = DSC$K_DTYPE_T; ; 1992 CON_MSG_DESC [DSC$A_POINTER] = CON_MSG; ; 1993 CON_MSG_DESC [DSC$W_LENGTH] = .TERM_DESC [DSC$W_LENGTH] + 48; ; 1994 CH$COPY (46, CH$PTR (UPLIT ('[ CONNECT running on VAX host. Connecting to ')), ; 1995 .TERM_DESC [DSC$W_LENGTH], CH$PTR (TERM_NAME), 0, .CON_MSG_DESC [DSC$W_LENGTH], ; 1996 CH$PTR (CON_MSG)); ; 1997 ! Assign channels to devices TERM_NAME and MY_TERM. ; 1998 STATUS = TERM_OPEN (); ; 1999 ; 2000 IF .CONNECT_FLAG ! Check if TERM_NAME is TT: ; 2001 THEN ; 2002 BEGIN ; 2003 TERM_CLOSE (); ; 2004 LIB$SIGNAL (KER_CON_SAME); ; 2005 RETURN KER_CON_SAME; ; 2006 END; ; 2007 ; 2008 IF NOT .STATUS ; 2009 THEN ; 2010 BEGIN ; 2011 LIB$SIGNAL (.STATUS); ; 2012 RETURN .STATUS; ; 2013 END; ; 2014 ; 2015 STATUS = $CANCEL (CHAN = .TERM_CHAN); ! Kill all pending QIOs for terminal ; 2016 CHANNEL [0] = .TERM_CHAN; ; 2017 CHANNEL [1] = .CONS_CHAN; ; 2018 STATUS = $CANCEL (CHAN = .CONS_CHAN); ! Kill pending QIOs for console as well ; 2019 ! STATUS = $ASSIGN (DEVNAM = MY_TERM, CHAN = MYT_CHAN); ; 2020 ; 2021 IF NOT .STATUS ; 2022 THEN ; 2023 BEGIN ; 2024 TERM_CLOSE (); ; 2025 LIB$SIGNAL (.STATUS); ; 2026 RETURN .STATUS; ; 2027 END; ; 2028 ; 2029 ! Prepare event flags ; 2030 $CLREF (EFN = XITEFN); ; 2031 ; 2032 INCR FLAG FROM 1 TO XITEFN - 1 DO ; 2033 $SETEF (EFN = .FLAG); ; 2034 ; 2035 ! Connect streams ; 2036 CONN_STREAMS : ; 2037 BEGIN ; 2038 ! Send connect message ; 2039 LIB$PUT_OUTPUT (%ASCID''); ; 2040 LIB$PUT_OUTPUT (CON_MSG_DESC); ; 2041 ESC_MSG (); ! Type escape character message ; 2042 LIB$PUT_OUTPUT (%ASCID''); ; 2043 $SETAST (ENBFLG = 0); ! Disable AST until after all QIOs ; 2044 ; 2045 INCR INP_BUFNUM FROM 0 TO NUM_IN_BUF - 1 DO ; 2046 BEGIN ; P 2047 STATUS = $QIO (CHAN = .MYT_CHAN, FUNC = IO$_TTYREADALL OR IO$M_NOECHO OR IO$M_TIMED, ; P 2048 ASTADR = MYTINP, P1 = INP_BUF [MYT, .INP_BUFNUM], P2 = INP_BUFSIZ, P3 = TIMEUP, ; 2049 IOSB = IN_IOSB [MYT, .INP_BUFNUM, 0], ASTPRM = .INP_BUFNUM); ; 2050 ; 2051 IF NOT .STATUS THEN LEAVE CONN_STREAMS; ; 2052 ; P 2053 STATUS = $QIO (CHAN = .TERM_CHAN, FUNC = IO$_TTYREADALL OR IO$M_NOECHO OR IO$M_TIMED, ; P 2054 ASTADR = TRMINP, P1 = INP_BUF [TRM, .INP_BUFNUM], P2 = INP_BUFSIZ, P3 = TIMEUP, ; 2055 IOSB = IN_IOSB [TRM, .INP_BUFNUM, 0], ASTPRM = .INP_BUFNUM); ; 2056 ; 2057 IF NOT .STATUS THEN LEAVE CONN_STREAMS; ; 2058 ; 2059 END; ; 2060 ; 2061 $SETAST (ENBFLG = 1); ! Enable AST ; 2062 $WAITFR (EFN = XITEFN); ! Wait for exit flag ; 2063 $WFLAND (EFN = 0, MASK = EFN_MASK); ! Go when outputs completed ; 2064 LIB$PUT_OUTPUT (%ASCID'[ Exiting from CONNECT. Returning to host. ]'); ; 2065 LIB$PUT_OUTPUT (%ASCID''); ; 2066 END; ; 2067 ! ; 2068 ! Program end -- Close both channels and return with STATUS ; 2069 ! ; 2070 $CANTIM (); ; 2071 $CANCEL (CHAN = .TERM_CHAN); ; 2072 $CANCEL (CHAN = .MYT_CHAN); ; 2073 ; 2074 IF NOT .STATUS THEN LIB$SIGNAL (.STATUS); ; 2075 ; 2076 STATUS = $DASSGN (CHAN = .TERM_CHAN); ; 2077 ; 2078 IF NOT .STATUS THEN LIB$SIGNAL (.STATUS); ; 2079 ; 2080 TERM_FLAG = FALSE; ; 2081 STATUS = $DASSGN (CHAN = .MYT_CHAN); ; 2082 ; 2083 IF NOT .STATUS THEN LIB$SIGNAL (.STATUS); ; 2084 ; 2085 $SETAST (ENBFLG = 1); ; 2086 RETURN .STATUS; ; 2087 END; ! End of TERM_CONNECT .PSECT $PLIT$,NOWRT,NOEXE,2 P.AAR: .ASCII \[ CONNECT running on VAX host. Connecting to \<0><0> ; ; P.AAT: .BLKB 0 ; ; P.AAS: .LONG 17694720 ; ; .ADDRESS P.AAT ; ; P.AAV: .BLKB 0 ; ; P.AAU: .LONG 17694720 ; ; .ADDRESS P.AAV ; ; P.AAX: .ASCII \[ Exiting from CONNECT. Returning to host. ]\<0><0> ; ; P.AAW: .LONG 17694766 ; ; .ADDRESS P.AAX ; ; P.AAZ: .BLKB 0 ; ; P.AAY: .LONG 17694720 ; ; .ADDRESS P.AAZ ; ; .EXTRN SYS$BINTIM, SYS$SETAST, SYS$WFLAND .PSECT $CODE$,NOWRT,2 .ENTRY TERM_CONNECT, ^M ; ; MOVAB G^LIB$PUT_OUTPUT, R11 ;LIB$PUT_OUTPUT, R11 ; MOVAB G^LIB$SIGNAL, R10 ;LIB$SIGNAL, R10 ; MOVAB W^U.3, R9 ;U.3, R9 ; MOVAB -88(SP), SP ;-88(SP), SP ; CLRQ 192(R9) ;CHR_COUNT ; 1979 CLRW 780(R9) ;OUT_BUFNUM ; 1982 MOVW #769, 784(R9) ;#769, OUT_EFN ; 1984 MOVZBL 780(R9), R0 ;OUT_BUFNUM, R0 ; 1986 MULL2 #80, R0 ;#80, R0 ; MOVAB 456(R9)[R0], 788(R9) ;OUT_BUF[R0], OUT_PTR ; MOVZBL 781(R9), R0 ;OUT_BUFNUM+1, R0 ; 1987 MULL2 #80, R0 ;#80, R0 ; MOVAB 617(R9)[R0], 792(R9) ;OUT_BUF+161[R0], OUT_PTR+4 ; PUSHAB 176(R9) ;BTIMUP ; 1988 PUSHAB W^U.40 ;U.40 ; CALLS #2, G^SYS$BINTIM ;#2, SYS$BINTIM ; MOVW #270, 2(SP) ;#270, CON_MSG_DESC+2 ; 1991 MOVAB 8(SP), 4(SP) ;CON_MSG, CON_MSG_DESC+4 ; 1992 ADDW3 #48, W^TERM_DESC, (SP) ;#48, TERM_DESC, CON_MSG_DESC ; 1993 MOVZWL W^TERM_DESC, R8 ;TERM_DESC, R8 ; 1995 MOVZWL (SP), R7 ;CON_MSG_DESC, R7 ; MOVAB 8(SP), R6 ;CON_MSG, R6 ; 1996 MOVC5 #46, W^P.AAR, #0, R7, (R6) ;#46, P.AAR, #0, R7, (R6) ; 1994 BGEQ 1$ ;1$ ; ADDL2 #46, R6 ;#46, R6 ; SUBL2 #46, R7 ;#46, R7 ; MOVC5 R8, W^TERM_NAME, #0, R7, (R6) ;R8, TERM_NAME, #0, R7, (R6) ; 1$: CALLS #0, W^TERM_OPEN ;#0, TERM_OPEN ; 1998 MOVL R0, R4 ;R0, STATUS ; BLBC W^CONNECT_FLAG, 2$ ;CONNECT_FLAG, 2$ ; 2000 CALLS #0, W^TERM_CLOSE ;#0, TERM_CLOSE ; 2003 PUSHL #134316258 ;#134316258 ; 2004 CALLS #1, (R10) ;#1, LIB$SIGNAL ; MOVL #134316258, R0 ;#134316258, R0 ; 2002 RET ; ; 2$: BLBC R4, 3$ ;STATUS, 3$ ; 2008 PUSHL (R9) ;TERM_CHAN ; 2015 CALLS #1, G^SYS$CANCEL ;#1, SYS$CANCEL ; MOVL R0, R4 ;R0, STATUS ; MOVQ (R9), 184(R9) ;TERM_CHAN, CHANNEL ; 2016 PUSHL 4(R9) ;CONS_CHAN ; 2018 CALLS #1, G^SYS$CANCEL ;#1, SYS$CANCEL ; MOVL R0, R4 ;R0, STATUS ; BLBS R4, 4$ ;STATUS, 4$ ; 2021 CALLS #0, W^TERM_CLOSE ;#0, TERM_CLOSE ; 2024 3$: PUSHL R4 ;STATUS ; 2025 CALLS #1, (R10) ;#1, LIB$SIGNAL ; BRW 11$ ;11$ ; 2023 4$: PUSHL #5 ;#5 ; 2030 CALLS #1, G^SYS$CLREF ;#1, SYS$CLREF ; MOVL #1, R2 ;#1, FLAG ; 2032 5$: PUSHL R2 ;FLAG ; 2033 CALLS #1, G^SYS$SETEF ;#1, SYS$SETEF ; AOBLEQ #4, R2, 5$ ;#4, FLAG, 5$ ; 2032 PUSHAB W^P.AAS ;P.AAS ; 2039 CALLS #1, (R11) ;#1, LIB$PUT_OUTPUT ; PUSHL SP ;SP ; 2040 CALLS #1, (R11) ;#1, LIB$PUT_OUTPUT ; CALLS #0, W^U.51 ;#0, U.51 ; 2041 PUSHAB W^P.AAU ;P.AAU ; 2042 CALLS #1, (R11) ;#1, LIB$PUT_OUTPUT ; CLRL -(SP) ;-(SP) ; 2043 CALLS #1, G^SYS$SETAST ;#1, SYS$SETAST ; CLRL R3 ;INP_BUFNUM ; 2045 6$: CLRQ -(SP) ;-(SP) ; 2049 MOVQ #1, -(SP) ;#1, -(SP) ; PUSHL #25 ;#25 ; MULL3 #25, R3, R2 ;#25, INP_BUFNUM, R2 ; PUSHAB 264(R9)[R2] ;INP_BUF[R2] ; PUSHL R3 ;INP_BUFNUM ; PUSHAB W^U.46 ;U.46 ; PUSHAQ 232(R9)[R3] ;IN_IOSB[INP_BUFNUM] ; MOVZBL #250, -(SP) ;#250, -(SP) ; PUSHL 188(R9) ;MYT_CHAN ; CLRL -(SP) ;-(SP) ; CALLS #12, G^SYS$QIO ;#12, SYS$QIO ; MOVL R0, R4 ;R0, STATUS ; BLBC R4, 7$ ;STATUS, 7$ ; 2051 CLRQ -(SP) ;-(SP) ; 2055 MOVQ #1, -(SP) ;#1, -(SP) ; PUSHL #25 ;#25 ; PUSHAB 315(R9)[R2] ;INP_BUF+51[R2] ; PUSHL R3 ;INP_BUFNUM ; PUSHAB W^U.50 ;U.50 ; PUSHAQ 248(R9)[R3] ;IN_IOSB+16[INP_BUFNUM] ; MOVZBL #250, -(SP) ;#250, -(SP) ; PUSHL (R9) ;TERM_CHAN ; CLRL -(SP) ;-(SP) ; CALLS #12, G^SYS$QIO ;#12, SYS$QIO ; MOVL R0, R4 ;R0, STATUS ; BLBC R4, 7$ ;STATUS, 7$ ; 2057 AOBLEQ #1, R3, 6$ ;#1, INP_BUFNUM, 6$ ; 2045 PUSHL #1 ;#1 ; 2061 CALLS #1, G^SYS$SETAST ;#1, SYS$SETAST ; PUSHL #5 ;#5 ; 2062 CALLS #1, G^SYS$WAITFR ;#1, SYS$WAITFR ; PUSHL #30 ;#30 ; 2063 CLRL -(SP) ;-(SP) ; CALLS #2, G^SYS$WFLAND ;#2, SYS$WFLAND ; PUSHAB W^P.AAW ;P.AAW ; 2064 CALLS #1, (R11) ;#1, LIB$PUT_OUTPUT ; PUSHAB W^P.AAY ;P.AAY ; 2065 CALLS #1, (R11) ;#1, LIB$PUT_OUTPUT ; 7$: CLRQ -(SP) ;-(SP) ; 2070 CALLS #2, G^SYS$CANTIM ;#2, SYS$CANTIM ; PUSHL (R9) ;TERM_CHAN ; 2071 CALLS #1, G^SYS$CANCEL ;#1, SYS$CANCEL ; PUSHL 188(R9) ;MYT_CHAN ; 2072 CALLS #1, G^SYS$CANCEL ;#1, SYS$CANCEL ; BLBS R4, 8$ ;STATUS, 8$ ; 2074 PUSHL R4 ;STATUS ; CALLS #1, (R10) ;#1, LIB$SIGNAL ; 8$: PUSHL (R9) ;TERM_CHAN ; 2076 CALLS #1, G^SYS$DASSGN ;#1, SYS$DASSGN ; MOVL R0, R4 ;R0, STATUS ; BLBS R4, 9$ ;STATUS, 9$ ; 2078 PUSHL R4 ;STATUS ; CALLS #1, (R10) ;#1, LIB$SIGNAL ; 9$: CLRL W^TERM_FLAG ;TERM_FLAG ; 2080 PUSHL 188(R9) ;MYT_CHAN ; 2081 CALLS #1, G^SYS$DASSGN ;#1, SYS$DASSGN ; MOVL R0, R4 ;R0, STATUS ; BLBS R4, 10$ ;STATUS, 10$ ; 2083 PUSHL R4 ;STATUS ; CALLS #1, (R10) ;#1, LIB$SIGNAL ; 10$: PUSHL #1 ;#1 ; 2085 CALLS #1, G^SYS$SETAST ;#1, SYS$SETAST ; 11$: MOVL R4, R0 ;STATUS, R0 ; 1575 RET ; ; 1531 ; Routine Size: 529 bytes, Routine Base: $CODE$ + 0B04 ; 2088 ; 2089 %SBTTL 'End of KERTRM' ; 2090 END ! End of module ; 2091 ; 2092 ELUDOM ; PSECT SUMMARY ; ; Name Bytes Attributes ; ; $OWN$ 820 NOVEC, WRT, RD ,NOEXE,NOSHR, LCL, REL, CON,NOPIC,ALIGN(2) ; $GLOBAL$ 4 NOVEC, WRT, RD ,NOEXE,NOSHR, LCL, REL, CON,NOPIC,ALIGN(2) ; $PLIT$ 356 NOVEC,NOWRT, RD ,NOEXE,NOSHR, LCL, REL, CON,NOPIC,ALIGN(2) ; $CODE$ 3349 NOVEC,NOWRT, RD , EXE,NOSHR, LCL, REL, CON,NOPIC,ALIGN(2) ; . ABS . 0 NOVEC,NOWRT,NORD ,NOEXE,NOSHR, LCL, ABS, CON,NOPIC,ALIGN(0) ; LIBRARY STATISTICS ; ; -------- Symbols -------- Blocks ; File Total Loaded Percent Read ; ; SYS$SYSROOT:[SYSLIB]STARLET.L32;1 5809 49 0 250 ; COMMAND QUALIFIERS ; BLISS KERTRM/LIST=KERTRM.MAR/MACHINE_CODE=(ASSEM,NOBINARY,UNIQUE)/NOOBJECT/SOURCE=NOHEADER ; Compilation Complete .END