; 0001 MODULE KERMIT (IDENT = '2.0.011', ; 0002 MAIN = MAIN_ROUTINE ; 0003 ) = ; 0004 BEGIN ; 0005 ; 0006 !++ ; 0007 ! FACILITY: ; 0008 ! KERMIT-32 ; 0009 ! ; 0010 ! ABSTRACT: ; 0011 ! KERMIT-32 is an implementation of the KERMIT protocal to allow the ; 0012 ! transfer of files from micro computers to the DECsystem-10, DECSYSTEM-20 ; 0013 ! and now the VAX/VMS systems. ; 0014 ! ; 0015 ! ENVIRONMENT: ; 0016 ! User mode ; 0017 ! ; 0018 ! AUTHOR: Robert C. McQueen, CREATION DATE: 24-January-1983 ; 0019 ! ; 0020 ! MODIFIED BY: ; 0021 ! ; 0022 !-- ; 0023 ; 0024 %SBTTL 'Table of Contents' ; 0025 %SBTTL 'Revision History' ; 0026 ; 0027 !++ ; 0028 ! Start of version 1. ; 0029 ! ; 0030 ! 1.0.000 By: Robert C. McQueen On: 4-Jan-1983 ; 0031 ! Create this program. ; 0032 ! ; 0033 ! 1.0.001 By: Robert C. McQueen On: 4-May-1983 ; 0034 ! Allow RECEIVE without a file specification to mean ; 0035 ! use what ever the remote says. ; 0036 ! ; 0037 ! 1.1.002 By: W. Hom On: 6-July-1983 ; 0038 ! Implement CONNECT command. ; 0039 ! ; 0040 ! 1.2.003 By: Robert C. McQueen On: 15-Aug-1983 ; 0041 ! Add SET PARITY command and SHOW PARITY to support ; 0042 ! eight bit quoting. ; 0043 ! ; 0044 ! 1.2.004 By: Robert C. McQueen On: 23-August-1983 ; 0045 ! Add dummy routine SY_TIME. ; 0046 ! ; 0047 ! 1.2.005 By: Robert C. McQueen On: 23-August-1983 ; 0048 ! Add SET [SEND | RECEIVE] EIGHT-BIT-QUOTE ; 0049 ! command. Add message for SHOW RECEIVE and SHOW SEND parameters ; 0050 ! ; 0051 ! 1.2.006 By: Robert C. McQueen On: 26-August-1983 ; 0052 ! Add BYE, FINISH and LOGOUT commands. These commands call ; 0053 ! DO_GENERIC to send generic functions to remote servers. ; 0054 ! ; 0055 ! 1.2.007 By: Robert C. McQueen On: 16-September-1983 ; 0056 ! Implement SY_TIME, and XFR_STATUS routines. ; 0057 ! Add more stat type out. ; 0058 ! ; 0059 ! 1.2.008 By: Robert C. McQueen On: 19-September-1983 ; 0060 ! Add the SET RETRY command and the SHOW RETRY command. ; 0061 ! ; 0062 ! 1.2.009 By: Robert C. McQueen On: 20-September-1983 ; 0063 ! Add CRCCLC routine for calculating CRC-CCITT. ; 0064 ! Set SET BLOCK_CHECK_TYPE and SHOW BLOCK_CHECK_TYPE commands. ; 0065 ! ; 0066 ! 1.2.010 By: Nick Bush On: 3-October-1983 ; 0067 ! SERVER (in KERMSG) actually returns a value. If it ; 0068 ! is "ABORTED", then we should prompt again. This allows ; 0069 ! a ^Y typed to the server to put it back into command ; 0070 ! level. (If you want to type out statistics or whatever). ; 0071 ! ; 0072 ! 2.0.011 Release VAX/VMS Kermit-32 version 2.0 ; 0073 !-- ; 0074 ; 0075 %SBTTL 'Routine definitions -- Forwards' ; 0076 ! ; 0077 ! ; 0078 ! Forward definitions ; 0079 ! ; 0080 ; 0081 ! Command processing routines ; 0082 ; 0083 FORWARD ROUTINE ; 0084 COMND, ! Process a command ; 0085 COMND_HELP : NOVALUE, ! Process the HELP command ; 0086 COMND_SHOW : NOVALUE, ! Process the SHOW command ; 0087 COMND_STATUS : NOVALUE, ! Process the STATUS command ; 0088 STORE_TEXT, ! Routine to store a file name ; 0089 COPY_TERM_NAME, ! Copy device name (TERM_xxxx) ; 0090 COPY_FILE, ! Copy file name (FILE_xxx) ; 0091 STORE_DEBUG, ! Store the debuging flag ; 0092 STORE_FTP, ! Store the file type ; 0093 STORE_ECHO, ! Store the local echo flag ; 0094 STORE_PARITY, ! Store the parity type ; 0095 STORE_CHK, ! This routine will store the checksum type. ; 0096 STORE_ABT, ! This routine will store the aborted file disposition ; 0097 STORE_IBM, ! Store IBM flag ; 0098 STORE_MSG_FIL, ! Store TY_FIL ; 0099 STORE_MSG_PKT, ! Store TY_PKT ; 0100 CHECK_PACKET_LEN, ! Validate PACKET length given ; 0101 CHECK_NPAD, ! Validate the number of pad characters ; 0102 CHECK_PAD_CHAR, ! Validate the padding character being set ; 0103 CHECK_EOL, ! Validate EOL character given. ; 0104 CHECK_SOH, ! Validate the start of packet character given ; 0105 HELP_START, ! Start of the HELP command (set TPA$V_BLANK) ; 0106 HELP_DONE; ! End of the HELP command (clear TPA$V_BLANK) ; 0107 ; 0108 ! ; 0109 ! Error handling routines ; 0110 ! ; 0111 ; 0112 FORWARD ROUTINE ; 0113 KERM_HANDLER; ! Condition handler ; 0114 %SBTTL 'Include files' ; 0115 ; 0116 ! ; 0117 ! INCLUDE FILES: ; 0118 ! ; 0119 ; 0120 LIBRARY 'SYS$LIBRARY:STARLET'; ; 0121 ; 0122 LIBRARY 'SYS$LIBRARY:TPAMAC'; ; 0123 ; 0124 REQUIRE 'KERCOM'; ! Common definitions ; 0294 ; 0295 REQUIRE 'KERERR'; ! Error message symbol definitions ; 0347 ; 0348 %SBTTL 'Structure definitions -- $GETDVI arguments' ; 0349 ! ; 0350 ! $GETDVI interface fields and structure definition ; 0351 ! ; 0352 ; 0353 LITERAL ; 0354 DVI_SIZE = 3; ! Length of a DVI item list entry ; 0355 ; 0356 ! ; 0357 ! Fields for accessing the items in a DVI item list ; 0358 ! ; 0359 ; 0360 FIELD ; 0361 DVI_FIELDS = ; 0362 SET ; 0363 DVI_BFR_LENGTH = [0, 0, 16, 0], ; 0364 DVI_ITEM_CODE = [0, 16, 16, 0], ; 0365 DVI_BFR_ADDRESS = [1, 0, 32, 0], ; 0366 DVI_RTN_LENGTH = [2, 0, 32, 0] ; 0367 TES; ; 0368 ; 0369 ! ; 0370 ! Structure definition for item list ; 0371 ; 0372 STRUCTURE ; 0373 DVI_ITEM_LIST [I, O, P, S, E; N] = ; 0374 [(N + 1)*DVI_SIZE*4] ; 0375 (DVI_ITEM_LIST + ((I*DVI_SIZE) + O)*4); ; 0376 ; 0377 %SBTTL 'Macro definitions' ; 0378 ; 0379 ! ; 0380 ! MACROS: ; 0381 ! ; 0382 ; 0383 MACRO ; M 0384 TPARSE_ARGS = ; M 0385 BUILTIN AP; ; M 0386 MAP AP : REF BLOCK [,BYTE]; ; 0387 %; ; 0388 %SBTTL 'Equated symbols -- Command types' ; 0389 ; 0390 ! ; 0391 ! EQUATED SYMBOLS: ; 0392 ! ; 0393 ! Command offsets ; 0394 ; 0395 LITERAL ; 0396 CMD_CONN = 1, ! Connect command ; 0397 CMD_EXIT = 2, ! Exit command ; 0398 CMD_HELP = 3, ! Help command ; 0399 CMD_RECEIVE = 4, ! Receive command ; 0400 CMD_SET = 5, ! Set command ; 0401 CMD_SEND = 6, ! Send command ; 0402 CMD_SHOW = 7, ! Show command ; 0403 CMD_SERVER = 8, ! SERVER command ; 0404 CMD_STATUS = 9, ! STATUS command ; 0405 CMD_LOGOUT = 10, ! Generic LOGOUT command ; 0406 CMD_BYE = 11, ! Generic LOGOUT command and EXIT ; 0407 CMD_FINISH = 12; ! Generic EXIT command ; 0408 ! Items to show ; 0409 ; 0410 LITERAL ; 0411 SHOW_ALL = 1, ! Show everything ; 0412 SHOW_DEB = 2, ! Show debugging flag ; 0413 SHOW_DEL = 3, ! Show delay ; 0414 SHOW_ESC = 4, ! Show ESCAPE character ; 0415 SHOW_FTP = 5, ! Show the file type ; 0416 SHOW_LIN = 6, ! Show the line we are using ; 0417 SHOW_ECH = 7, ! Show the echo flag ; 0418 SHOW_SEN = 8, ! Show send parameters ; 0419 SHOW_REC = 9, ! Show the receive parameters ; 0420 SHOW_PAR = 10, ! Show the parity setting ; 0421 SHOW_RTY = 11, ! Show retry counters ; 0422 SHOW_CHK = 12, ! Show block-check-type ; 0423 SHOW_ABT = 13, ! Show aborted file disposition ; 0424 SHOW_FIL = 14, ! Show file parameters ; 0425 SHOW_PAC = 15, ! Show packet parameters ; 0426 SHOW_COM = 16; ! Show communications parameters ; 0427 %SBTTL 'Equated symbols -- Constants' ; 0428 ; 0429 ! Constants ; 0430 ; 0431 LITERAL ; 0432 CMD_BFR_LENGTH = 132, ! Command buffer length ; 0433 OUT_BFR_LENGTH = 80, ! Output buffer length (SHOW cmd) ; 0434 TERM_LENGTH = 80, ! Length of a terminal name ; 0435 HELP_LENGTH = 132, ! Length of the help buffer ; 0436 TEMP_LENGTH = 132; ! Length of the temporary area ; 0437 %SBTTL 'Storage -- Global' ; 0438 ; 0439 ! ; 0440 ! ; 0441 ! GLOBAL STORAGE: ; 0442 ! ; 0443 ; 0444 GLOBAL ; 0445 ESCAPE_CHR, ! Escape character for CONNECT ; 0446 TERM_NAME : VECTOR [CH$ALLOCATION(TERM_LENGTH)], ; 0447 TERM_DESC : BLOCK [8, BYTE]; ! Terminal name descriptor ; 0448 %SBTTL 'Storage -- Local' ; 0449 ; 0450 ! ; 0451 ! OWN STORAGE: ; 0452 ! ; 0453 ; 0454 OWN ; 0455 ; 0456 ! Command scanning information ; 0457 ; 0458 TPARSE_BLOCK : BLOCK [TPA$K_LENGTH0, BYTE] ; 0459 INITIAL (TPA$K_COUNT0, ! Longword count ; 0460 TPA$M_ABBREV), ! Allow abbreviations ; 0461 COMMAND, ! Type of command we are doing ; 0462 SHOW_TYPE, ! Type of show command ; 0463 ! ; 0464 ! Output data area ; 0465 ! ; 0466 OUTPUT_LINE : VECTOR [OUT_BFR_LENGTH, BYTE, UNSIGNED], ; 0467 OUTPUT_DESC : BLOCK [8, BYTE], ; 0468 OUTPUT_SIZE : WORD UNSIGNED, ; 0469 ; 0470 ! Misc constants. ; 0471 ; 0472 CRC_TABLE : BLOCK [16, LONG], ! CRC-CCITT table ; 0473 TIMER_HANDLE, ! Pointer to the TIMER block ; 0474 TEMP_DESC : BLOCK [8, BYTE], ! Temporary descriptor ; 0475 TEMP_NAME : VECTOR [CH$ALLOCATION(TEMP_LENGTH)]; ; 0476 ; 0477 ! ; 0478 %SBTTL 'External routines' ; 0479 ! ; 0480 ! EXTERNAL REFERENCES: ; 0481 ! ; 0482 ; 0483 EXTERNAL ROUTINE ; 0484 ! ; 0485 ! Library routines ; 0486 ! ; 0487 LIB$INIT_TIMER : ADDRESSING_MODE (GENERAL), ; 0488 LIB$STAT_TIMER : ADDRESSING_MODE (GENERAL), ; 0489 LIB$FREE_TIMER : ADDRESSING_MODE (GENERAL), ; 0490 LIB$EDIV : ADDRESSING_MODE (GENERAL), ; 0491 LIB$GET_FOREIGN : ADDRESSING_MODE (GENERAL), ; 0492 LIB$GET_INPUT : ADDRESSING_MODE (GENERAL), ; 0493 LIB$PUT_OUTPUT : ADDRESSING_MODE (GENERAL), ; 0494 LIB$TPARSE : ADDRESSING_MODE (GENERAL), ; 0495 LIB$CRC_TABLE : ADDRESSING_MODE (GENERAL), ; 0496 LIB$CRC : ADDRESSING_MODE (GENERAL), ; 0497 LIB$SIGNAL : ADDRESSING_MODE (GENERAL) NOVALUE, ; 0498 LIB$ESTABLISH : ADDRESSING_MODE (GENERAL), ; 0499 ! ; 0500 ! KERMSG - KERMIT Message processing routines ; 0501 ! ; 0502 SEND_SWITCH, ! Send a file ; 0503 REC_SWITCH, ! Receive a file ; 0504 DO_GENERIC, ! Send generic functions ; 0505 SERVER, ! Server mode processing ; 0506 SND_ERROR : NOVALUE, ! Send E packet to remote ; 0507 MSG_INIT : NOVALUE, ! Initialization routine ; 0508 ! ; 0509 ! KERFIL - File processing. ; 0510 ! ; 0511 FILE_INIT : NOVALUE, ! Initialization routine ; 0512 ! ; 0513 ! KERTRM - Terminal processing. ; 0514 ! ; 0515 TERM_INIT : NOVALUE, ! Initialize the terminal processing ; 0516 TERM_OPEN, ! Open the terminal line ; 0517 TERM_CLOSE, ! Close the terminal line ; 0518 TERM_CONNECT, ! Impliments CONNECT command ; 0519 ! ; 0520 ! KERTT - Text processing ; 0521 ! ; 0522 TT_INIT : NOVALUE, ! Initialization routine ; 0523 TT_TEXT : NOVALUE, ! Output a text string ; 0524 TT_NUMBER : NOVALUE, ! Output a number ; 0525 TT_CHAR : NOVALUE, ! Output a single character ; 0526 TT_OUTPUT : NOVALUE, ! Routine to dump the current ; 0527 ! text line. ; 0528 TT_CRLF : NOVALUE; ! Output the line ; 0529 ; 0530 %SBTTL 'External storage' ; 0531 ! ; 0532 ! EXTERNAL Storage: ; 0533 ! ; 0534 ; 0535 EXTERNAL ; 0536 ! ; 0537 ! KERMSG storage ; 0538 ! ; 0539 ! Receive parameters ; 0540 RCV_PKT_SIZE, ! Receive packet size ; 0541 RCV_NPAD, ! Padding length ; 0542 RCV_PADCHAR, ! Padding character ; 0543 RCV_TIMEOUT, ! Time out ; 0544 RCV_EOL, ! EOL character ; 0545 RCV_QUOTE_CHR, ! Quote character ; 0546 RCV_8QUOTE_CHR, ! 8-bit quoting character ; 0547 RCV_SOH, ! Start of packet header ; 0548 ! ; 0549 ! Send parameters ; 0550 ! ; 0551 SND_PKT_SIZE, ! Send packet size ; 0552 SND_NPAD, ! Padding length ; 0553 SND_PADCHAR, ! Padding character ; 0554 SND_TIMEOUT, ! Time out ; 0555 SND_EOL, ! EOL character ; 0556 SND_QUOTE_CHR, ! Quote character ; 0557 SND_SOH, ! Packet start of header ; 0558 ! ; 0559 ! Misc. packet parameters ; 0560 ! ; 0561 SET_REPT_CHR, ! Desired repeat character ; 0562 ! ; 0563 ! Statistics ; 0564 ! ; 0565 SND_TOTAL_CHARS, ! Total characters sent ; 0566 RCV_TOTAL_CHARS, ! Total characters received ; 0567 SND_DATA_CHARS, ! Total number of data characters sent ; 0568 RCV_DATA_CHARS, ! Total number of data characters received ; 0569 SMSG_TOTAL_CHARS, ! Total chars sent this file xfer ; 0570 RMSG_TOTAL_CHARS, ! Total chars rcvd this file xfer ; 0571 SMSG_DATA_CHARS, ! Total data chars this file xfer ; 0572 RMSG_DATA_CHARS, ! Total data chars this file xfer ; 0573 RCV_NAKS, ! Total number of NAKs received ; 0574 SND_NAKS, ! Total number of NAKs sent ; 0575 RMSG_NAKS, ! Number of NAKs received ; 0576 SMSG_NAKS, ! Number of NAKs sent ; 0577 RCV_COUNT, ! Number of packets received ; 0578 SND_COUNT, ! Number of packets sent ; 0579 XFR_TIME, ! Amount of time the last transfer took ; 0580 TOTAL_TIME, ! Total time the transfers have taken ; 0581 LAST_ERROR : VECTOR [CH$ALLOCATION (MAX_MSG + 1)], ! Last error message ; 0582 TY_PKT, ! Flag that packet numbers should be typed ; 0583 TY_FIL, ! Flag that file names should be typed ; 0584 ; 0585 ! ; 0586 ! Misc constants. ; 0587 ! ; 0588 FILE_SIZE, ! Number of characters in FILE_NAME ; 0589 FILE_NAME : VECTOR [CH$ALLOCATION (MAX_FILE_NAME)], ; 0590 SI_RETRIES, ! Initial connection max retries ; 0591 PKT_RETRIES, ! Packet max retries ; 0592 DELAY, ! Amount of time to delay ; 0593 DEBUG_FLAG, ! Debugging mode on/off ; 0594 CHKTYPE, ! Type of block-check-type wanted ; 0595 ABT_FLAG, ! Aborted file disposition ; 0596 IBM_FLAG, ! IBM mode flag ; 0597 WARN_FLAG, ! File warning flag ; 0598 PARITY_TYPE, ! Type of parity we are using ; 0599 ECHO_FLAG, ! Local echo flag ; 0600 CONNECT_FLAG; ! True if SYS$OUTPUT and line ; 0601 ! xfering over are the same. ; 0602 ! ; 0603 ! KERFIL storage ; 0604 ! ; 0605 ; 0606 EXTERNAL ; 0607 FILE_TYPE, ! Type of file being processed ; 0608 FILE_DESC : BLOCK [8, BYTE]; ! Descriptor for the file name ; 0609 ; 0610 ! ; 0611 ! KERTRM storage ; 0612 ! ; 0613 ; 0614 EXTERNAL ; 0615 TERM_FLAG; ! Terminal open flag ; 0616 ; 0617 %SBTTL 'Command parsing tables' ; 0618 ! ; 0619 !++ ; 0620 ! ; 0621 !The following are the command state tables for the KERMIT-32 ; 0622 !command processing. ; 0623 ! ; 0624 !-- ; 0625 ; 0626 $INIT_STATE (KERMIT_STATE, KERMIT_KEY); ; 0627 ; P 0628 $STATE (START, ; P 0629 ('BYE', DONE_STATE, , CMD_BYE, COMMAND), ; P 0630 ('CONNECT', CONN_STATE, , CMD_CONN, COMMAND), ; P 0631 ('EXIT', DONE_STATE, , CMD_EXIT, COMMAND), ; P 0632 ('FINISH', DONE_STATE, , CMD_FINISH, COMMAND), ; P 0633 ('GET', REC_STATE, , CMD_RECEIVE, COMMAND), ; P 0634 ('HELP', HELP_STATE, HELP_START, CMD_HELP, COMMAND), ; P 0635 ('LOGOUT', DONE_STATE, , CMD_LOGOUT, COMMAND), ; P 0636 ('QUIT', DONE_STATE, , CMD_EXIT, COMMAND), ; P 0637 ('RECEIVE', REC_STATE, , CMD_RECEIVE, COMMAND), ; P 0638 ('SET', SET_STATE, , CMD_SET, COMMAND), ; P 0639 ('SEND', SEND_STATE, , CMD_SEND, COMMAND), ; P 0640 ('SERVER', DONE_STATE, , CMD_SERVER, COMMAND), ; P 0641 ('SHOW', SHOW_STATE, , CMD_SHOW, COMMAND), ; P 0642 ('STATUS', DONE_STATE, , CMD_STATUS, COMMAND) ; 0643 ) ; 0644 ; 0645 !++ ; 0646 ! CONNECT command. Format is: ; 0647 ! ; 0648 ! Kermit-32>CONNECT device ; 0649 ! ; 0650 ! Where: ; 0651 ! Device - Terminal line to connect to ; 0652 ! ; 0653 !-- ; 0654 ; P 0655 $STATE (CONN_STATE, ; P 0656 (TPA$_EOS, DONE_STATE), ; P 0657 (TPA$_LAMBDA, SET_LIN_STATE) ; 0658 ) ; 0659 ; 0660 !++ ; 0661 ! EXIT command. Format is: ; 0662 ! ; 0663 ! Kermit-32>EXIT ; 0664 ! ; 0665 ! Just exit back to VMS. ; 0666 ! ; 0667 !-- ; 0668 ; 0669 !++ ; 0670 ! HELP command. Format is: ; 0671 ! ; 0672 ! Kermit-32>HELP ; 0673 ! ; 0674 ! Do HELP processing for KERMIT-32. ; 0675 ! ; 0676 !-- ; 0677 ; P 0678 $STATE (HELP_STATE, ; P 0679 (TPA$_ANY, HELP_STATE, STORE_TEXT), ; P 0680 (TPA$_LAMBDA, DONE_STATE, HELP_DONE) ; 0681 ) ; 0682 ; 0683 %SBTTL 'QUIT command table' ; 0684 ; 0685 !++ ; 0686 ! QUIT command. Format is: ; 0687 ! ; 0688 ! Kermit-32>QUIT ; 0689 ! ; 0690 ! This command will just exit back to VMS. ; 0691 ! ; 0692 !-- ; 0693 %SBTTL 'RECEIVE command table' ; 0694 ; 0695 !++ ; 0696 ! RECEIVE command. Format is: ; 0697 ! ; 0698 ! Kermit-32>RECEIVE file-specification ; 0699 ! ; 0700 ! This command will cause KERMIT to receive a file from the micro. ; 0701 ! It will assume that it is to used what ever line it currently is ; 0702 ! associated with (CONNECT or SET LINE). ; 0703 ! ; 0704 !-- ; 0705 ; P 0706 $STATE (REC_STATE, ; P 0707 (TPA$_ANY, REC1_STATE, STORE_TEXT), ; P 0708 (TPA$_LAMBDA, DONE_STATE) ; 0709 ) ; 0710 ; 0711 ; P 0712 $STATE (REC1_STATE, ; P 0713 (TPA$_ANY, REC1_STATE, STORE_TEXT), ; P 0714 (TPA$_LAMBDA, DONE_STATE, COPY_FILE) ; 0715 ) ; 0716 %SBTTL 'SET command tables' ; 0717 ; 0718 !++ ; 0719 ! SET command. Format is: ; 0720 ! ; 0721 ! Kermit-32>SET parameter ; 0722 ! ; 0723 ! Where: ; 0724 ! Parameter - One of the following: ; 0725 ! DEBUGGING ; 0726 ! DELAY ; 0727 ! LINE ; 0728 ! PARITY ; 0729 ! SEND ; 0730 ! RECEIVE ; 0731 ! ; 0732 !-- ; 0733 ; P 0734 $STATE (SET_STATE, ; P 0735 ('BLOCK_CHECK_TYPE', SET_CHK_STATE), ; P 0736 ('DEBUGGING', SET_DEB_STATE), ; P 0737 ('DELAY', SET_DEL_STATE), ; P 0738 ('ESCAPE', SET_ESC_STATE), ; P 0739 ('FILE_TYPE', SET_FIL_STATE), ; P 0740 ('IBM_MODE', SET_IBM_STATE), ; P 0741 ('INCOMPLETE_FILE_DISPOSITION', SET_ABT_STATE), ; P 0742 ('LINE', SET_LIN_STATE), ; P 0743 ('LOCAL_ECHO', SET_ECH_STATE), ; P 0744 ('MESSAGE', SET_MSG_STATE), ; P 0745 ('PARITY', SET_PAR_STATE), ; P 0746 ('RECEIVE', SET_REC_STATE), ; P 0747 ('REPEAT_QUOTE',SET_RPT_STATE), ; P 0748 ('RETRY', SET_RTY_STATE), ; P 0749 ('SEND', SET_SND_STATE) ; 0750 ) ; 0751 ; 0752 !++ ; 0753 ! ; 0754 ! SET INCOMPLETE_FILE [disposition] command. The possible arguments are ; 0755 ! KEEP or DISCARD. ; 0756 ! ; 0757 !-- ; 0758 ; P 0759 $STATE (SET_ABT_STATE, ; P 0760 ('DISCARD', DONE_STATE, STORE_ABT,, ,TRUE), ; P 0761 ('KEEP', DONE_STATE, STORE_ABT,, ,FALSE) ; 0762 ) ; 0763 ; 0764 !++ ; 0765 ! ; 0766 ! SET BLOCK_CHECK_TYPE [type] command. The format is: ; 0767 ! ; 0768 ! Kermit-32>SET BLOCK_CHECK_TYPE [1_CHARACTER_CHECKSUM | ....] ; 0769 ! ; 0770 !-- ; 0771 ; P 0772 $STATE (SET_CHK_STATE, ; P 0773 ('1_CHARACTER_CHECKSUM', DONE_STATE, STORE_CHK,, ,CHK_1CHAR), ; P 0774 ('2_CHARACTER_CHECKSUM', DONE_STATE, STORE_CHK,, ,CHK_2CHAR), ; P 0775 ('3_CHARACTER_CRC_CCITT', DONE_STATE, STORE_CHK,, ,CHK_CRC), ; P 0776 ('ONE_CHARACTER_CHECKSUM', DONE_STATE, STORE_CHK,, ,CHK_1CHAR), ; P 0777 ('THREE_CHARACTER_CRC_CCITT', DONE_STATE, STORE_CHK,, ,CHK_CRC), ; P 0778 ('TWO_CHARACTER_CHECKSUM', DONE_STATE, STORE_CHK,, ,CHK_2CHAR) ; 0779 ) ; 0780 ; 0781 !++ ; 0782 ! ; 0783 ! SET DEBUGGING command. The format is: ; 0784 ! ; 0785 ! Kermit-32>SET DEBUGGING (on/off) ; 0786 ! ; 0787 ! Where: ; 0788 ! on/off is either the ON or OFF keyword. ; 0789 ! ; 0790 !-- ; 0791 ; P 0792 $STATE (SET_DEB_STATE, ; P 0793 ('OFF', DONE_STATE, STORE_DEBUG, , ,FALSE), ; P 0794 ('ON', DONE_STATE, STORE_DEBUG, , ,TRUE) ; 0795 ) ; 0796 ; 0797 !++ ; 0798 ! ; 0799 ! SET IBM_MODE command. The format is: ; 0800 ! ; 0801 ! Kermit-32>SET IBM_MODE (on/off) ; 0802 ! ; 0803 ! Where: ; 0804 ! on/off is either the ON or OFF keyword. ; 0805 ! ; 0806 !-- ; 0807 ; P 0808 $STATE (SET_IBM_STATE, ; P 0809 ('OFF', DONE_STATE, STORE_IBM, , ,FALSE), ; P 0810 ('ON', DONE_STATE, STORE_IBM, , ,TRUE) ; 0811 ) ; 0812 ; 0813 !++ ; 0814 ! ; 0815 ! SET DELAY command. The format is: ; 0816 ! ; 0817 ! Kermit-32>SET DELAY ; 0818 ! ; 0819 ! Where: ; 0820 ! is the number of seconds to delay before sending the ; 0821 ! SEND-INIT packet. ; 0822 !-- ; 0823 ; P 0824 $STATE (SET_DEL_STATE, ; P 0825 (TPA$_DECIMAL, DONE_STATE, , ,DELAY) ; 0826 ) ; 0827 ; 0828 !++ ; 0829 ! ; 0830 ! SET ESCAPE command. The format is: ; 0831 ! ; 0832 ! Kermit-32>SET ESCAPE ; 0833 ! ; 0834 ! Where: ; 0835 ! is the octal number representing the escape character ; 0836 ! for the CONNECT command processing. The default escape character ; 0837 ! is Control-]. ; 0838 !-- ; 0839 ; P 0840 $STATE (SET_ESC_STATE, ; P 0841 (TPA$_OCTAL, DONE_STATE, , ,ESCAPE_CHR) ; 0842 ) ; 0843 !++ ; 0844 ! ; 0845 ! SET FILE-TYPE command. The format is: ; 0846 ! ; 0847 ! Kermit-32>SET FILE-TYPE ; 0848 ! ; 0849 ! Where: ; 0850 ! is one of the following: ; 0851 ! ASCII - Normal ASCII file (stream ascii) ; 0852 ! BINARY - Micro binary file. ; 0853 !-- ; 0854 ; P 0855 $STATE (SET_FIL_STATE, ; P 0856 ('ASCII', DONE_STATE, STORE_FTP, , ,FILE_ASC), ; P 0857 ('BINARY', DONE_STATE, STORE_FTP, , ,FILE_BIN), ; P 0858 ('BLOCK', DONE_STATE, STORE_FTP, , ,FILE_BLK) ; 0859 ) ; 0860 ; 0861 !++ ; 0862 ! SET LINE command. Format is: ; 0863 ! ; 0864 ! Kermit-32>SET LINE terminal-device: ; 0865 ! ; 0866 ! Where: ; 0867 ! Terminal-device: is the terminal line to use to the transfer of ; 0868 ! the data and to use in the CONNECT command. ; 0869 ! ; 0870 !-- ; 0871 ; P 0872 $STATE (SET_LIN_STATE, ; P 0873 (TPA$_ANY, SET_LIN_STATE, STORE_TEXT), ; P 0874 (TPA$_LAMBDA, DONE_STATE, COPY_TERM_NAME) ; 0875 ) ; 0876 ; 0877 !++ ; 0878 ! SET LOCAL-ECHO command. Format is: ; 0879 ! ; 0880 ! Kermit-32>SET LOCAL-ECHO state ; 0881 ! ; 0882 ! Where: ; 0883 ! STATE is either the keyword ON or OFF. ; 0884 ! ; 0885 !- ; 0886 ; P 0887 $STATE (SET_ECH_STATE, ; P 0888 ('OFF', DONE_STATE, STORE_ECHO, , ,FALSE), ; P 0889 ('ON', DONE_STATE, STORE_ECHO, , ,TRUE) ; 0890 ) ; 0891 ; 0892 ; 0893 !++ ; 0894 ! SET MESSAGE command. Format is: ; 0895 ! ; 0896 ! Kermit-32>SET MESSAGE ; 0897 ! ; 0898 ! Where the keyword is: ; 0899 ! ; 0900 ! FILE_NAMES - Type out file names being transferred ; 0901 ! PACKET_NUMBERS - Type out packet counts ; 0902 !-- ; 0903 ; P 0904 $STATE (SET_MSG_STATE, ; P 0905 ('FILE_NAMES', SET_MSG_FIL_STATE), ; 0906 ('PACKET_NUMBERS', SET_MSG_PKT_STATE)) ; 0907 ; P 0908 $STATE (SET_MSG_FIL_STATE, ; P 0909 ('OFF', DONE_STATE, STORE_MSG_FIL, , ,FALSE), ; P 0910 ('ON', DONE_STATE, STORE_MSG_FIL, , ,TRUE) ; 0911 ) ; 0912 ; P 0913 $STATE (SET_MSG_PKT_STATE, ; P 0914 ('OFF', DONE_STATE, STORE_MSG_PKT, , ,FALSE), ; P 0915 ('ON', DONE_STATE, STORE_MSG_PKT, , ,TRUE) ; 0916 ) ; 0917 ; 0918 !++ ; 0919 ! SET REPEAT_QUOTE command. Format is: ; 0920 ! ; 0921 ! Kermit-32>SET REPEAT_QUOTE ; 0922 ! ; 0923 !-- ; 0924 ; P 0925 $STATE (SET_RPT_STATE, ; P 0926 (TPA$_OCTAL, DONE_STATE, , ,SET_REPT_CHR) ; 0927 ) ; 0928 ; 0929 !++ ; 0930 ! SET RETRY command. Format is: ; 0931 ! ; 0932 ! Kermit-32>SET RETRY ; 0933 ! ; 0934 ! Where the keyword is: ; 0935 ! ; 0936 ! INITIAL_CONNECTION - set number of initial connection retries. ; 0937 ! PACKET - set the number of packet retries. ; 0938 !-- ; 0939 ; P 0940 $STATE (SET_RTY_STATE, ; P 0941 ('INITIAL_CONNECTION', SET_RTY_INI_STATE), ; P 0942 ('PACKET', SET_RTY_PKT_STATE) ; 0943 ) ; 0944 ; 0945 ; P 0946 $STATE (SET_RTY_INI_STATE, ; P 0947 (TPA$_DECIMAL, DONE_STATE, , ,SI_RETRIES) ; 0948 ) ; 0949 ; P 0950 $STATE (SET_RTY_PKT_STATE, ; P 0951 (TPA$_DECIMAL, DONE_STATE, , ,PKT_RETRIES) ; 0952 ) ; 0953 %SBTTL 'SET PARITY type' ; 0954 ; 0955 !++ ; 0956 ! SET PARITY command. Format is: ; 0957 ! ; 0958 ! Kermit-32>SET PARITY type ; 0959 ! ; 0960 ! The type can be: ; 0961 ! ; 0962 ! NONE - No parity processing ; 0963 ! MARK - Mark parity ; 0964 ! SPACE - Space parity ; 0965 ! EVEN - Even parity ; 0966 ! ODD - Odd parity ; 0967 ! ; 0968 !-- ; 0969 ; P 0970 $STATE (SET_PAR_STATE, ; P 0971 ('EVEN', DONE_STATE, STORE_PARITY, , ,PR_EVEN), ; P 0972 ('MARK', DONE_STATE, STORE_PARITY, , ,PR_MARK), ; P 0973 ('NONE', DONE_STATE, STORE_PARITY, , ,PR_NONE), ; P 0974 ('ODD', DONE_STATE, STORE_PARITY, , ,PR_NONE), ; P 0975 ('SPACE', DONE_STATE, STORE_PARITY, , ,PR_SPACE) ; 0976 ) ; 0977 %SBTTL 'SET RECEIVE table' ; 0978 ; 0979 !++ ; 0980 ! SET RECEIVE command. Format is: ; 0981 ! ; 0982 ! Kermit-32>SET RECEIVE item ; 0983 ! ; 0984 ! Where: ; 0985 ! Item - One of the following: ; 0986 ! PACKET-LENGTH ; 0987 ! PADDING ; 0988 ! PADCHAR ; 0989 ! TIMEOUT ; 0990 ! END-OF-LINE ; 0991 ! QUOTE ; 0992 ! ; 0993 !-- ; 0994 ; P 0995 $STATE (SET_REC_STATE, ; P 0996 ('EIGHT-BIT-QUOTE', SR_8QU_STATE), ; P 0997 ('END_OF_LINE', SR_EOL_STATE), ; P 0998 ('PACKET_LENGTH', SR_PKT_STATE), ; P 0999 ('PADCHAR', SR_PDC_STATE), ; P 1000 ('PADDING', SR_PAD_STATE), ; P 1001 ('QUOTE', SR_QUO_STATE), ; P 1002 ('START_OF_PACKET', SR_SOH_STATE), ; P 1003 ('TIMEOUT', SR_TIM_STATE) ; 1004 ) ; 1005 ; 1006 !++ ; 1007 ! ; 1008 ! SET RECEIVE PACKET-LENGTH command. Format is: ; 1009 ! ; 1010 ! Kermit-32>SET RECEIVE PACKET-LENGTH ; 1011 ! ; 1012 ! Where: ; 1013 ! is a decimal number that specifies the length of a ; 1014 ! receive packet. ; 1015 ! ; 1016 !-- ; 1017 ; P 1018 $STATE (SR_PKT_STATE, ; P 1019 (TPA$_DECIMAL, DONE_STATE, CHECK_PACKET_LEN, ,RCV_PKT_SIZE) ; 1020 ) ; 1021 ; 1022 ; 1023 !++ ; 1024 ! ; 1025 ! SET RECEIVE PADDING command. The format of this command is: ; 1026 ! ; 1027 ! Kermit-32>SET RECEIVE PADDING ; 1028 ! ; 1029 ! Where: ; 1030 ! is the decimal number of padding characters to output. ; 1031 ! ; 1032 !-- ; 1033 ; P 1034 $STATE (SR_PAD_STATE, ; P 1035 (TPA$_DECIMAL, DONE_STATE, CHECK_NPAD, ,RCV_NPAD) ; 1036 ) ; 1037 ; 1038 !++ ; 1039 ! ; 1040 ! SET RECEIVE PADCHAR command. Format is: ; 1041 ! ; 1042 ! Kermit-32>SET RECEIVE PADCHAR ; 1043 ! ; 1044 ! Where: ; 1045 ! is the octal representation of the padding character ; 1046 ! that is to be used. ; 1047 ! ; 1048 !-- ; 1049 ; P 1050 $STATE (SR_PDC_STATE, ; P 1051 (TPA$_OCTAL, DONE_STATE, CHECK_PAD_CHAR, ,RCV_PADCHAR) ; 1052 ) ; 1053 !++ ; 1054 ! ; 1055 ! SET RECEIVE START_OF_PACKET command. Format is: ; 1056 ! ; 1057 ! Kermit-32>SET RECEIVE START_OF_PACKET ; 1058 ! ; 1059 ! Where: ; 1060 ! is the octal representation of the padding character ; 1061 ! that is to be used. ; 1062 ! ; 1063 !-- ; 1064 ; P 1065 $STATE (SR_SOH_STATE, ; P 1066 (TPA$_OCTAL, DONE_STATE, CHECK_SOH, ,RCV_SOH) ; 1067 ) ; 1068 ; 1069 !++ ; 1070 ! ; 1071 ! SET RECEIVE TIMEOUT command. The format is: ; 1072 ! ; 1073 ! Kermit-32>SET RECEIVE TIMEOUT ; 1074 ! ; 1075 ! Where: ; 1076 ! is the number of seconds before KERMIT-32 should time out ; 1077 ! attempting to receive a correct message. ; 1078 ! ; 1079 !-- ; 1080 ; P 1081 $STATE (SR_TIM_STATE, ; P 1082 (TPA$_DECIMAL, DONE_STATE, , ,RCV_TIMEOUT) ; 1083 ) ; 1084 ; 1085 !++ ; 1086 ! SET END-OF-LINE command. Format is: ; 1087 ! ; 1088 ! Kermit-32>SET RECEIVE END-OF-LINE ; 1089 ! ; 1090 ! Where: ; 1091 ! is the octal number representation of the character ; 1092 ! that is the end of line character. ; 1093 ! ; 1094 !-- ; 1095 ; P 1096 $STATE (SR_EOL_STATE, ; P 1097 (TPA$_OCTAL, DONE_STATE, CHECK_EOL, ,RCV_EOL) ; 1098 ) ; 1099 ; 1100 !++ ; 1101 ! SET RECEIVE QUOTE command. The format is: ; 1102 ! ; 1103 ! Kermit-32>SET RECEIVE QUOTE ; 1104 ! ; 1105 ! Where: ; 1106 ! is the octal number representing the quoting character. ; 1107 ! ; 1108 !-- ; 1109 ; P 1110 $STATE (SR_QUO_STATE, ; P 1111 (TPA$_OCTAL, DONE_STATE, , ,RCV_QUOTE_CHR) ; 1112 ) ; 1113 %SBTTL 'SET RECEIVE EIGHT-BIT-QUOTE' ; 1114 ; 1115 !++ ; 1116 ! This routine will handle the setting of the eight bit quoting character. ; 1117 ! ; 1118 ! Kermit-32>SET RECEIVE EIGHT-BIT-QUOTE ; 1119 ! ; 1120 ! Where: ; 1121 ! is the octal number representing the quoting character. ; 1122 ! ; 1123 !-- ; 1124 ; P 1125 $STATE (SR_8QU_STATE, ; P 1126 (TPA$_OCTAL, DONE_STATE, , ,RCV_8QUOTE_CHR) ; 1127 ) ; 1128 %SBTTL 'SET SEND tables' ; 1129 ; 1130 !++ ; 1131 ! SET SEND command. Format is: ; 1132 ! ; 1133 ! Kermit-32>SET SEND item ; 1134 ! ; 1135 ! Where: ; 1136 ! Item - One of the following: ; 1137 ! PACKET-LENGTH ; 1138 ! PADDING ; 1139 ! PADCHAR ; 1140 ! TIMEOUT ; 1141 ! END-OF-LINE ; 1142 ! QUOTE ; 1143 ! ; 1144 !-- ; 1145 ; P 1146 $STATE (SET_SND_STATE, ; P 1147 ('END_OF_LINE', SS_EOL_STATE), ; P 1148 ('PACKET_LENGTH', SS_PKT_STATE), ; P 1149 ('PADCHAR', SS_PDC_STATE), ; P 1150 ('PADDING', SS_PAD_STATE), ; P 1151 ('QUOTE', SS_QUO_STATE), ; P 1152 ('START_OF_PACKET', SS_SOH_STATE), ; P 1153 ('TIMEOUT', SS_TIM_STATE) ; 1154 ) ; 1155 ; 1156 ; 1157 ; 1158 !++ ; 1159 ! ; 1160 ! SET SEND PACKET-LENGTH command. Format is: ; 1161 ! ; 1162 ! Kermit-32>SET SEND PACKET-LENGTH ; 1163 ! ; 1164 ! Where: ; 1165 ! is a decimal number that specifies the length of a ; 1166 ! receive packet. ; 1167 ! ; 1168 !-- ; 1169 ; P 1170 $STATE (SS_PKT_STATE, ; P 1171 (TPA$_DECIMAL, DONE_STATE, CHECK_PACKET_LEN, ,SND_PKT_SIZE) ; 1172 ) ; 1173 ; 1174 ; 1175 !++ ; 1176 ! ; 1177 ! SET SEND PADDING command. The format of this command is: ; 1178 ! ; 1179 ! Kermit-32>SET SEND PADDING ; 1180 ! ; 1181 ! Where: ; 1182 ! is the decimal number of padding characters to output. ; 1183 ! ; 1184 !-- ; 1185 ; P 1186 $STATE (SS_PAD_STATE, ; P 1187 (TPA$_DECIMAL, DONE_STATE, CHECK_NPAD, ,SND_NPAD) ; 1188 ) ; 1189 ; 1190 !++ ; 1191 ! ; 1192 ! SET SEND PADCHAR command. Format is: ; 1193 ! ; 1194 ! Kermit-32>SET SEND PADCHAR ; 1195 ! ; 1196 ! Where: ; 1197 ! is the octal representation of the padding character ; 1198 ! that is to be used. ; 1199 ! ; 1200 !-- ; 1201 ; P 1202 $STATE (SS_PDC_STATE, ; P 1203 (TPA$_OCTAL, DONE_STATE, CHECK_PAD_CHAR, ,SND_PADCHAR) ; 1204 ) ; 1205 !++ ; 1206 ! ; 1207 ! SET RECEIVE START_OF_PACKET command. Format is: ; 1208 ! ; 1209 ! Kermit-32>SET RECEIVE START_OF_PACKET ; 1210 ! ; 1211 ! Where: ; 1212 ! is the octal representation of the padding character ; 1213 ! that is to be used. ; 1214 ! ; 1215 !-- ; 1216 ; P 1217 $STATE (SS_SOH_STATE, ; P 1218 (TPA$_OCTAL, DONE_STATE, CHECK_SOH, ,RCV_SOH) ; 1219 ) ; 1220 ; 1221 !++ ; 1222 ! ; 1223 ! SET SEND TIMEOUT command. The format is: ; 1224 ! ; 1225 ! Kermit-32>SET SEND TIMEOUT ; 1226 ! ; 1227 ! Where: ; 1228 ! is the number of seconds before KERMIT-32 should time out ; 1229 ! attempting to receive a correct message. ; 1230 ! ; 1231 !-- ; 1232 ; P 1233 $STATE (SS_TIM_STATE, ; P 1234 (TPA$_DECIMAL, DONE_STATE, , ,SND_TIMEOUT) ; 1235 ) ; 1236 ; 1237 !++ ; 1238 ! SET SEND END-OF-LINE command. Format is: ; 1239 ! ; 1240 ! Kermit-32>SET SEND END-OF-LINE ; 1241 ! ; 1242 ! Where: ; 1243 ! is the octal number representation of the character ; 1244 ! that is the end of line character. ; 1245 ! ; 1246 !-- ; 1247 ; P 1248 $STATE (SS_EOL_STATE, ; P 1249 (TPA$_OCTAL, DONE_STATE, CHECK_EOL, ,SND_EOL) ; 1250 ) ; 1251 ; 1252 !++ ; 1253 ! SET SEND QUOTA command. The format is: ; 1254 ! ; 1255 ! Kermit-32>SET SEND QUOTA ; 1256 ! ; 1257 ! Where: ; 1258 ! is the octal number representing the quoting character. ; 1259 ! ; 1260 !-- ; 1261 ; P 1262 $STATE (SS_QUO_STATE, ; P 1263 (TPA$_OCTAL, DONE_STATE, , ,SND_QUOTE_CHR) ; 1264 ) ; 1265 ; 1266 %SBTTL 'SEND command' ; 1267 ; 1268 !++ ; 1269 ! SEND command. The format is: ; 1270 ! ; 1271 ! Kermit-32>SEND file-specification ; 1272 ! ; 1273 ! Where: ; 1274 ! FILE-SPECIFICATION is any valid VAX/VMS file specification. ; 1275 ! ; 1276 !-- ; 1277 ; P 1278 $STATE (SEND_STATE, ; P 1279 (TPA$_ANY, SEND_STATE, STORE_TEXT), ; P 1280 (TPA$_LAMBDA, DONE_STATE, COPY_FILE) ; 1281 ) ; 1282 %SBTTL 'SHOW command' ; 1283 ; 1284 !++ ; 1285 ! SHOW command. The format is: ; 1286 ! ; 1287 ! Kermit-32>SHOW ; 1288 ! ; 1289 ! Where: ; 1290 ! is one of the following: ; 1291 ! SEND - Send parameters ; 1292 ! RECEIVE - Receive parameters ; 1293 ! DEBUGGING - State of the debugging flag ; 1294 ! FILE-TYPE - Type of the file ; 1295 ! LOCAL-ECHO - Local echo flag ; 1296 ! LINE - Current line associated ; 1297 ! ESCAPE - Current escape character ; 1298 ! DELAY - Delay parameter. ; 1299 ! ; 1300 !-- ; 1301 ; P 1302 $STATE (SHOW_STATE, ; P 1303 ('ALL', DONE_STATE, ,SHOW_ALL, SHOW_TYPE), ; P 1304 ('BLOCK_CHECK_TYPE', DONE_STATE, ,SHOW_CHK, SHOW_TYPE), ; P 1305 ('COMMUNICATIONS', DONE_STATE, ,SHOW_COM, SHOW_TYPE), ; P 1306 ('DEBUGGING', DONE_STATE, ,SHOW_DEB, SHOW_TYPE), ; P 1307 ('DELAY', DONE_STATE, ,SHOW_DEL, SHOW_TYPE), ; P 1308 ('ESCAPE', DONE_STATE, ,SHOW_ESC, SHOW_TYPE), ; P 1309 ('FILE_TYPE', DONE_STATE, ,SHOW_FTP, SHOW_TYPE), ; P 1310 ('FILE_PARAMETERS', DONE_STATE, ,SHOW_FIL, SHOW_TYPE), ; P 1311 ('INCOMPLETE_FILE_DISPOSITION',DONE_STATE, ,SHOW_ABT, SHOW_TYPE), ; P 1312 ('LINE', DONE_STATE, ,SHOW_LIN, SHOW_TYPE), ; P 1313 ('LOCAL_ECHO', DONE_STATE, ,SHOW_ECH, SHOW_TYPE), ; P 1314 ('PACKET', DONE_STATE, ,SHOW_PAC, SHOW_TYPE), ; P 1315 ('PARITY', DONE_STATE, ,SHOW_PAR, SHOW_TYPE), ; P 1316 ('SEND', DONE_STATE, ,SHOW_SEN, SHOW_TYPE), ; P 1317 ('RECEIVE', DONE_STATE, ,SHOW_REC, SHOW_TYPE), ; P 1318 ('RETRY', DONE_STATE, ,SHOW_RTY, SHOW_TYPE) ; 1319 ) ; 1320 %SBTTL 'Done state' ; 1321 ; 1322 !++ ; 1323 ! This is the single state that is the required CONFIRM for the end ; 1324 ! of the commands. ; 1325 !-- ; 1326 ; P 1327 $STATE (DONE_STATE, ; P 1328 (TPA$_EOS, TPA$_EXIT) ; 1329 ) ; 1330 ; 1331 !++ ; 1332 ! ; 1333 ! End of the KERMIT-32 command definitions ; 1334 ! ; 1335 !-- ; 1336 ; 1337 PSECT OWN = $OWN$; ; 1338 PSECT GLOBAL = $GLOBAL$; ; 1339 ; 1340 ! ; 1341 ROUTINE MAIN_ROUTINE : NOVALUE = ; 1342 ; 1343 !++ ; 1344 ! FUNCTIONAL DESCRIPTION: ; 1345 ! ; 1346 ! This is the main routine for KERMIT-32. This routine will ; 1347 ! initialize the various parameters and then call the command ; 1348 ! scanner to process commands. ; 1349 ! ; 1350 ! FORMAL PARAMETERS: ; 1351 ! ; 1352 ! None. ; 1353 ! ; 1354 ! IMPLICIT INPUTS: ; 1355 ! ; 1356 ! None. ; 1357 ! ; 1358 ! IMPLICIT OUTPUTS: ; 1359 ! ; 1360 ! None. ; 1361 ! ; 1362 ! ROUTINE VALUE and ; 1363 ! COMPLETION CODES: ; 1364 ! ; 1365 ! None. ; 1366 ! ; 1367 ! SIDE EFFECTS: ; 1368 ! ; 1369 ! None. ; 1370 ! ; 1371 !-- ; 1372 ; 1373 BEGIN ; 1374 ; 1375 LOCAL ; 1376 STATUS, ! Returned status ; 1377 CRC_BIT_MASK, ! Bit mask for CRC initialization ; 1378 LOOP_FLAG; ; 1379 ; 1380 ! ; 1381 ! Initialize some variables ; 1382 ! ; 1383 MSG_INIT (); ! Initialize message processing ; 1384 TERM_INIT (); ! Init terminal processing ; 1385 TT_INIT (); ! Init text processing ; 1386 FILE_INIT (); ! Init file processing ; 1387 ESCAPE_CHR = CHR_ESCAPE; ; 1388 ! ; 1389 ! Initialize some VAX/VMS interface items ; 1390 ! ; 1391 CRC_BIT_MASK = %O'102010'; ! CRC bit mask ; 1392 LIB$CRC_TABLE (CRC_BIT_MASK, CRC_TABLE); ; 1393 LIB$ESTABLISH (KERM_HANDLER); ; 1394 TIMER_HANDLE = 0; ! Clear to get free block ; 1395 STATUS = LIB$INIT_TIMER (TIMER_HANDLE); ! Initialize ; 1396 ! ; 1397 ! Main command loop ; 1398 ! ; 1399 COMND (); ; 1400 END; ! end of routine MAIN_ROUTINE .TITLE KERMIT .IDENT \2.0.011\ .PSECT _LIB$KEY1$,NOWRT, SHR, PIC,0 ;TPA$KEYST0 U.40: .BLKB 0 ;TPA$KEYST U.42: .ASCII \BYE\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.48: .BLKB 0 ;TPA$KEYST U.50: .ASCII \CONNECT\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.56: .BLKB 0 ;TPA$KEYST U.58: .ASCII \EXIT\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.63: .BLKB 0 ;TPA$KEYST U.65: .ASCII \FINISH\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.70: .BLKB 0 ;TPA$KEYST U.72: .ASCII \GET\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.78: .BLKB 0 ;TPA$KEYST U.80: .ASCII \HELP\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.87: .BLKB 0 ;TPA$KEYST U.89: .ASCII \LOGOUT\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.94: .BLKB 0 ;TPA$KEYST U.96: .ASCII \QUIT\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.101: .BLKB 0 ;TPA$KEYST U.103: .ASCII \RECEIVE\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.108: .BLKB 0 ;TPA$KEYST U.110: .ASCII \SET\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.116: .BLKB 0 ;TPA$KEYST U.118: .ASCII \SEND\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.124: .BLKB 0 ;TPA$KEYST U.126: .ASCII \SERVER\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.131: .BLKB 0 ;TPA$KEYST U.133: .ASCII \SHOW\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.139: .BLKB 0 ;TPA$KEYST U.141: .ASCII \STATUS\ ; ; .BYTE -1 ; ; ;TPA$KEYFILL U.146: .BYTE -1 ; ; ;TPA$KEYST0 U.170: .BLKB 0 ;TPA$KEYST U.172: .ASCII \BLOCK_CHECK_TYPE\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.176: .BLKB 0 ;TPA$KEYST U.178: .ASCII \DEBUGGING\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.182: .BLKB 0 ;TPA$KEYST U.184: .ASCII \DELAY\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.188: .BLKB 0 ;TPA$KEYST U.190: .ASCII \ESCAPE\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.194: .BLKB 0 ;TPA$KEYST U.196: .ASCII \FILE_TYPE\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.200: .BLKB 0 ;TPA$KEYST U.202: .ASCII \IBM_MODE\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.206: .BLKB 0 ;TPA$KEYST U.208: .ASCII \INCOMPLETE_FILE_DISPOSITION\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.212: .BLKB 0 ;TPA$KEYST U.214: .ASCII \LINE\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.217: .BLKB 0 ;TPA$KEYST U.219: .ASCII \LOCAL_ECHO\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.223: .BLKB 0 ;TPA$KEYST U.225: .ASCII \MESSAGE\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.229: .BLKB 0 ;TPA$KEYST U.231: .ASCII \PARITY\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.235: .BLKB 0 ;TPA$KEYST U.237: .ASCII \RECEIVE\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.241: .BLKB 0 ;TPA$KEYST U.243: .ASCII \REPEAT_QUOTE\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.247: .BLKB 0 ;TPA$KEYST U.249: .ASCII \RETRY\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.253: .BLKB 0 ;TPA$KEYST U.255: .ASCII \SEND\ ; ; .BYTE -1 ; ; ;TPA$KEYFILL U.259: .BYTE -1 ; ; ;TPA$KEYST0 U.260: .BLKB 0 ;TPA$KEYST U.262: .ASCII \DISCARD\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.268: .BLKB 0 ;TPA$KEYST U.270: .ASCII \KEEP\ ; ; .BYTE -1 ; ; ;TPA$KEYFILL U.276: .BYTE -1 ; ; ;TPA$KEYST0 U.277: .BLKB 0 ;TPA$KEYST U.279: .ASCII \1_CHARACTER_CHECKSUM\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.285: .BLKB 0 ;TPA$KEYST U.287: .ASCII \2_CHARACTER_CHECKSUM\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.293: .BLKB 0 ;TPA$KEYST U.295: .ASCII \3_CHARACTER_CRC_CCITT\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.301: .BLKB 0 ;TPA$KEYST U.303: .ASCII \ONE_CHARACTER_CHECKSUM\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.309: .BLKB 0 ;TPA$KEYST U.311: .ASCII \THREE_CHARACTER_CRC_CCITT\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.317: .BLKB 0 ;TPA$KEYST U.319: .ASCII \TWO_CHARACTER_CHECKSUM\ ; ; .BYTE -1 ; ; ;TPA$KEYFILL U.325: .BYTE -1 ; ; ;TPA$KEYST0 U.326: .BLKB 0 ;TPA$KEYST U.328: .ASCII \OFF\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.334: .BLKB 0 ;TPA$KEYST U.336: .ASCII \ON\ ; ; .BYTE -1 ; ; ;TPA$KEYFILL U.342: .BYTE -1 ; ; ;TPA$KEYST0 U.343: .BLKB 0 ;TPA$KEYST U.345: .ASCII \OFF\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.351: .BLKB 0 ;TPA$KEYST U.353: .ASCII \ON\ ; ; .BYTE -1 ; ; ;TPA$KEYFILL U.359: .BYTE -1 ; ; ;TPA$KEYST0 U.366: .BLKB 0 ;TPA$KEYST U.368: .ASCII \ASCII\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.374: .BLKB 0 ;TPA$KEYST U.376: .ASCII \BINARY\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.382: .BLKB 0 ;TPA$KEYST U.384: .ASCII \BLOCK\ ; ; .BYTE -1 ; ; ;TPA$KEYFILL U.390: .BYTE -1 ; ; ;TPA$KEYST0 U.397: .BLKB 0 ;TPA$KEYST U.399: .ASCII \OFF\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.405: .BLKB 0 ;TPA$KEYST U.407: .ASCII \ON\ ; ; .BYTE -1 ; ; ;TPA$KEYFILL U.413: .BYTE -1 ; ; ;TPA$KEYST0 U.414: .BLKB 0 ;TPA$KEYST U.416: .ASCII \FILE_NAMES\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.420: .BLKB 0 ;TPA$KEYST U.422: .ASCII \PACKET_NUMBERS\ ; ; .BYTE -1 ; ; ;TPA$KEYFILL U.426: .BYTE -1 ; ; ;TPA$KEYST0 U.427: .BLKB 0 ;TPA$KEYST U.429: .ASCII \OFF\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.435: .BLKB 0 ;TPA$KEYST U.437: .ASCII \ON\ ; ; .BYTE -1 ; ; ;TPA$KEYFILL U.443: .BYTE -1 ; ; ;TPA$KEYST0 U.444: .BLKB 0 ;TPA$KEYST U.446: .ASCII \OFF\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.452: .BLKB 0 ;TPA$KEYST U.454: .ASCII \ON\ ; ; .BYTE -1 ; ; ;TPA$KEYFILL U.460: .BYTE -1 ; ; ;TPA$KEYST0 U.464: .BLKB 0 ;TPA$KEYST U.466: .ASCII \INITIAL_CONNECTION\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.470: .BLKB 0 ;TPA$KEYST U.472: .ASCII \PACKET\ ; ; .BYTE -1 ; ; ;TPA$KEYFILL U.476: .BYTE -1 ; ; ;TPA$KEYST0 U.483: .BLKB 0 ;TPA$KEYST U.485: .ASCII \EVEN\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.491: .BLKB 0 ;TPA$KEYST U.493: .ASCII \MARK\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.499: .BLKB 0 ;TPA$KEYST U.501: .ASCII \NONE\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.507: .BLKB 0 ;TPA$KEYST U.509: .ASCII \ODD\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.515: .BLKB 0 ;TPA$KEYST U.517: .ASCII \SPACE\ ; ; .BYTE -1 ; ; ;TPA$KEYFILL U.523: .BYTE -1 ; ; ;TPA$KEYST0 U.524: .BLKB 0 ;TPA$KEYST U.526: .ASCII \EIGHT-BIT-QUOTE\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.530: .BLKB 0 ;TPA$KEYST U.532: .ASCII \END_OF_LINE\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.536: .BLKB 0 ;TPA$KEYST U.538: .ASCII \PACKET_LENGTH\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.542: .BLKB 0 ;TPA$KEYST U.544: .ASCII \PADCHAR\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.548: .BLKB 0 ;TPA$KEYST U.550: .ASCII \PADDING\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.554: .BLKB 0 ;TPA$KEYST U.556: .ASCII \QUOTE\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.560: .BLKB 0 ;TPA$KEYST U.562: .ASCII \START_OF_PACKET\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.566: .BLKB 0 ;TPA$KEYST U.568: .ASCII \TIMEOUT\ ; ; .BYTE -1 ; ; ;TPA$KEYFILL U.572: .BYTE -1 ; ; ;TPA$KEYST0 U.602: .BLKB 0 ;TPA$KEYST U.604: .ASCII \END_OF_LINE\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.608: .BLKB 0 ;TPA$KEYST U.610: .ASCII \PACKET_LENGTH\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.614: .BLKB 0 ;TPA$KEYST U.616: .ASCII \PADCHAR\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.620: .BLKB 0 ;TPA$KEYST U.622: .ASCII \PADDING\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.626: .BLKB 0 ;TPA$KEYST U.628: .ASCII \QUOTE\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.632: .BLKB 0 ;TPA$KEYST U.634: .ASCII \START_OF_PACKET\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.638: .BLKB 0 ;TPA$KEYST U.640: .ASCII \TIMEOUT\ ; ; .BYTE -1 ; ; ;TPA$KEYFILL U.644: .BYTE -1 ; ; ;TPA$KEYST0 U.677: .BLKB 0 ;TPA$KEYST U.679: .ASCII \ALL\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.684: .BLKB 0 ;TPA$KEYST U.686: .ASCII \BLOCK_CHECK_TYPE\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.691: .BLKB 0 ;TPA$KEYST U.693: .ASCII \COMMUNICATIONS\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.698: .BLKB 0 ;TPA$KEYST U.700: .ASCII \DEBUGGING\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.705: .BLKB 0 ;TPA$KEYST U.707: .ASCII \DELAY\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.712: .BLKB 0 ;TPA$KEYST U.714: .ASCII \ESCAPE\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.719: .BLKB 0 ;TPA$KEYST U.721: .ASCII \FILE_TYPE\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.726: .BLKB 0 ;TPA$KEYST U.728: .ASCII \FILE_PARAMETERS\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.733: .BLKB 0 ;TPA$KEYST U.735: .ASCII \INCOMPLETE_FILE_DISPOSITION\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.740: .BLKB 0 ;TPA$KEYST U.742: .ASCII \LINE\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.747: .BLKB 0 ;TPA$KEYST U.749: .ASCII \LOCAL_ECHO\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.754: .BLKB 0 ;TPA$KEYST U.756: .ASCII \PACKET\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.761: .BLKB 0 ;TPA$KEYST U.763: .ASCII \PARITY\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.768: .BLKB 0 ;TPA$KEYST U.770: .ASCII \SEND\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.775: .BLKB 0 ;TPA$KEYST U.777: .ASCII \RECEIVE\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.782: .BLKB 0 ;TPA$KEYST U.784: .ASCII \RETRY\ ; ; .BYTE -1 ; ; ;TPA$KEYFILL U.789: .BYTE -1 ; ; .PSECT _LIB$STATE$,NOWRT, SHR, PIC,0 KERMIT_STATE:: .BLKB 0 START: .BLKB 0 ;TPA$TYPE U.43: .WORD 28928 ; ; ;TPA$ADDR U.44: .LONG <-4> ; ; ;TPA$MASK U.45: .LONG 11 ; ; ;TPA$TARGET U.47: .WORD <-2> ; ; ;TPA$TYPE U.51: .WORD 28929 ; ; ;TPA$ADDR U.52: .LONG <-4> ; ; ;TPA$MASK U.53: .LONG 1 ; ; ;TPA$TARGET U.55: .WORD <-2> ; ; ;TPA$TYPE U.59: .WORD 28930 ; ; ;TPA$ADDR U.60: .LONG <-4> ; ; ;TPA$MASK U.61: .LONG 2 ; ; ;TPA$TARGET U.62: .WORD <-2> ; ; ;TPA$TYPE U.66: .WORD 28931 ; ; ;TPA$ADDR U.67: .LONG <-4> ; ; ;TPA$MASK U.68: .LONG 12 ; ; ;TPA$TARGET U.69: .WORD <-2> ; ; ;TPA$TYPE U.73: .WORD 28932 ; ; ;TPA$ADDR U.74: .LONG <-4> ; ; ;TPA$MASK U.75: .LONG 4 ; ; ;TPA$TARGET U.77: .WORD <-2> ; ; ;TPA$TYPE U.81: .WORD -3835 ; ; ;TPA$ACTION U.82: .LONG <-4> ; ; ;TPA$ADDR U.83: .LONG <-4> ; ; ;TPA$MASK U.84: .LONG 3 ; ; ;TPA$TARGET U.86: .WORD <-2> ; ; ;TPA$TYPE U.90: .WORD 28934 ; ; ;TPA$ADDR U.91: .LONG <-4> ; ; ;TPA$MASK U.92: .LONG 10 ; ; ;TPA$TARGET U.93: .WORD <-2> ; ; ;TPA$TYPE U.97: .WORD 28935 ; ; ;TPA$ADDR U.98: .LONG <-4> ; ; ;TPA$MASK U.99: .LONG 2 ; ; ;TPA$TARGET U.100: .WORD <-2> ; ; ;TPA$TYPE U.104: .WORD 28936 ; ; ;TPA$ADDR U.105: .LONG <-4> ; ; ;TPA$MASK U.106: .LONG 4 ; ; ;TPA$TARGET U.107: .WORD <-2> ; ; ;TPA$TYPE U.111: .WORD 28937 ; ; ;TPA$ADDR U.112: .LONG <-4> ; ; ;TPA$MASK U.113: .LONG 5 ; ; ;TPA$TARGET U.115: .WORD <-2> ; ; ;TPA$TYPE U.119: .WORD 28938 ; ; ;TPA$ADDR U.120: .LONG <-4> ; ; ;TPA$MASK U.121: .LONG 6 ; ; ;TPA$TARGET U.123: .WORD <-2> ; ; ;TPA$TYPE U.127: .WORD 28939 ; ; ;TPA$ADDR U.128: .LONG <-4> ; ; ;TPA$MASK U.129: .LONG 8 ; ; ;TPA$TARGET U.130: .WORD <-2> ; ; ;TPA$TYPE U.134: .WORD 28940 ; ; ;TPA$ADDR U.135: .LONG <-4> ; ; ;TPA$MASK U.136: .LONG 7 ; ; ;TPA$TARGET U.138: .WORD <-2> ; ; ;TPA$TYPE U.142: .WORD 29965 ; ; ;TPA$ADDR U.143: .LONG <-4> ; ; ;TPA$MASK U.144: .LONG 9 ; ; ;TPA$TARGET U.145: .WORD <-2> ; ; ;CONN_STATE U.54: .BLKB 0 ;TPA$TYPE U.147: .WORD 4599 ; ; ;TPA$TARGET U.148: .WORD <-2> ; ; ;TPA$TYPE U.149: .WORD 5622 ; ; ;TPA$TARGET U.151: .WORD <-2> ; ; ;HELP_STATE U.85: .BLKB 0 ;TPA$TYPE U.152: .WORD -28179 ; ; ;TPA$ACTION U.153: .LONG <-4> ; ; ;TPA$TARGET U.154: .WORD <-2> ; ; ;TPA$TYPE U.155: .WORD -27146 ; ; ;TPA$ACTION U.156: .LONG <-4> ; ; ;TPA$TARGET U.157: .WORD <-2> ; ; ;REC_STATE U.76: .BLKB 0 ;TPA$TYPE U.158: .WORD -28179 ; ; ;TPA$ACTION U.159: .LONG <-4> ; ; ;TPA$TARGET U.161: .WORD <-2> ; ; ;TPA$TYPE U.162: .WORD 5622 ; ; ;TPA$TARGET U.163: .WORD <-2> ; ; ;REC1_STATE U.160: .BLKB 0 ;TPA$TYPE U.164: .WORD -28179 ; ; ;TPA$ACTION U.165: .LONG <-4> ; ; ;TPA$TARGET U.166: .WORD <-2> ; ; ;TPA$TYPE U.167: .WORD -27146 ; ; ;TPA$ACTION U.168: .LONG <-4> ; ; ;TPA$TARGET U.169: .WORD <-2> ; ; ;SET_STATE U.114: .BLKB 0 ;TPA$TYPE U.173: .WORD 4366 ; ; ;TPA$TARGET U.175: .WORD <-2> ; ; ;TPA$TYPE U.179: .WORD 4367 ; ; ;TPA$TARGET U.181: .WORD <-2> ; ; ;TPA$TYPE U.185: .WORD 4368 ; ; ;TPA$TARGET U.187: .WORD <-2> ; ; ;TPA$TYPE U.191: .WORD 4369 ; ; ;TPA$TARGET U.193: .WORD <-2> ; ; ;TPA$TYPE U.197: .WORD 4370 ; ; ;TPA$TARGET U.199: .WORD <-2> ; ; ;TPA$TYPE U.203: .WORD 4371 ; ; ;TPA$TARGET U.205: .WORD <-2> ; ; ;TPA$TYPE U.209: .WORD 4372 ; ; ;TPA$TARGET U.211: .WORD <-2> ; ; ;TPA$TYPE U.215: .WORD 4373 ; ; ;TPA$TARGET U.216: .WORD <-2> ; ; ;TPA$TYPE U.220: .WORD 4374 ; ; ;TPA$TARGET U.222: .WORD <-2> ; ; ;TPA$TYPE U.226: .WORD 4375 ; ; ;TPA$TARGET U.228: .WORD <-2> ; ; ;TPA$TYPE U.232: .WORD 4376 ; ; ;TPA$TARGET U.234: .WORD <-2> ; ; ;TPA$TYPE U.238: .WORD 4377 ; ; ;TPA$TARGET U.240: .WORD <-2> ; ; ;TPA$TYPE U.244: .WORD 4378 ; ; ;TPA$TARGET U.246: .WORD <-2> ; ; ;TPA$TYPE U.250: .WORD 4379 ; ; ;TPA$TARGET U.252: .WORD <-2> ; ; ;TPA$TYPE U.256: .WORD 5404 ; ; ;TPA$TARGET U.258: .WORD <-2> ; ; ;SET_ABT_STATE U.210: .BLKB 0 ;TPA$TYPE U.263: .WORD -27875 ; ; ;TPA$FLAGS2 U.264: .BYTE 1 ; ; ;TPA$PARAM U.265: .LONG 1 ; ; ;TPA$ACTION U.266: .LONG <-4> ; ; ;TPA$TARGET U.267: .WORD <-2> ; ; ;TPA$TYPE U.271: .WORD -26850 ; ; ;TPA$FLAGS2 U.272: .BYTE 1 ; ; ;TPA$PARAM U.273: .LONG 0 ; ; ;TPA$ACTION U.274: .LONG <-4> ; ; ;TPA$TARGET U.275: .WORD <-2> ; ; ;SET_CHK_STATE U.174: .BLKB 0 ;TPA$TYPE U.280: .WORD -27873 ; ; ;TPA$FLAGS2 U.281: .BYTE 1 ; ; ;TPA$PARAM U.282: .LONG 49 ; ; ;TPA$ACTION U.283: .LONG <-4> ; ; ;TPA$TARGET U.284: .WORD <-2> ; ; ;TPA$TYPE U.288: .WORD -27872 ; ; ;TPA$FLAGS2 U.289: .BYTE 1 ; ; ;TPA$PARAM U.290: .LONG 50 ; ; ;TPA$ACTION U.291: .LONG <-4> ; ; ;TPA$TARGET U.292: .WORD <-2> ; ; ;TPA$TYPE U.296: .WORD -27871 ; ; ;TPA$FLAGS2 U.297: .BYTE 1 ; ; ;TPA$PARAM U.298: .LONG 51 ; ; ;TPA$ACTION U.299: .LONG <-4> ; ; ;TPA$TARGET U.300: .WORD <-2> ; ; ;TPA$TYPE U.304: .WORD -27870 ; ; ;TPA$FLAGS2 U.305: .BYTE 1 ; ; ;TPA$PARAM U.306: .LONG 49 ; ; ;TPA$ACTION U.307: .LONG <-4> ; ; ;TPA$TARGET U.308: .WORD <-2> ; ; ;TPA$TYPE U.312: .WORD -27869 ; ; ;TPA$FLAGS2 U.313: .BYTE 1 ; ; ;TPA$PARAM U.314: .LONG 51 ; ; ;TPA$ACTION U.315: .LONG <-4> ; ; ;TPA$TARGET U.316: .WORD <-2> ; ; ;TPA$TYPE U.320: .WORD -26844 ; ; ;TPA$FLAGS2 U.321: .BYTE 1 ; ; ;TPA$PARAM U.322: .LONG 50 ; ; ;TPA$ACTION U.323: .LONG <-4> ; ; ;TPA$TARGET U.324: .WORD <-2> ; ; ;SET_DEB_STATE U.180: .BLKB 0 ;TPA$TYPE U.329: .WORD -27867 ; ; ;TPA$FLAGS2 U.330: .BYTE 1 ; ; ;TPA$PARAM U.331: .LONG 0 ; ; ;TPA$ACTION U.332: .LONG <-4> ; ; ;TPA$TARGET U.333: .WORD <-2> ; ; ;TPA$TYPE U.337: .WORD -26842 ; ; ;TPA$FLAGS2 U.338: .BYTE 1 ; ; ;TPA$PARAM U.339: .LONG 1 ; ; ;TPA$ACTION U.340: .LONG <-4> ; ; ;TPA$TARGET U.341: .WORD <-2> ; ; ;SET_IBM_STATE U.204: .BLKB 0 ;TPA$TYPE U.346: .WORD -27865 ; ; ;TPA$FLAGS2 U.347: .BYTE 1 ; ; ;TPA$PARAM U.348: .LONG 0 ; ; ;TPA$ACTION U.349: .LONG <-4> ; ; ;TPA$TARGET U.350: .WORD <-2> ; ; ;TPA$TYPE U.354: .WORD -26840 ; ; ;TPA$FLAGS2 U.355: .BYTE 1 ; ; ;TPA$PARAM U.356: .LONG 1 ; ; ;TPA$ACTION U.357: .LONG <-4> ; ; ;TPA$TARGET U.358: .WORD <-2> ; ; ;SET_DEL_STATE U.186: .BLKB 0 ;TPA$TYPE U.360: .WORD 22003 ; ; ;TPA$ADDR U.361: .LONG <-4> ; ; ;TPA$TARGET U.362: .WORD <-2> ; ; ;SET_ESC_STATE U.192: .BLKB 0 ;TPA$TYPE U.363: .WORD 22004 ; ; ;TPA$ADDR U.364: .LONG <-4> ; ; ;TPA$TARGET U.365: .WORD <-2> ; ; ;SET_FIL_STATE U.198: .BLKB 0 ;TPA$TYPE U.369: .WORD -27863 ; ; ;TPA$FLAGS2 U.370: .BYTE 1 ; ; ;TPA$PARAM U.371: .LONG 1 ; ; ;TPA$ACTION U.372: .LONG <-4> ; ; ;TPA$TARGET U.373: .WORD <-2> ; ; ;TPA$TYPE U.377: .WORD -27862 ; ; ;TPA$FLAGS2 U.378: .BYTE 1 ; ; ;TPA$PARAM U.379: .LONG 2 ; ; ;TPA$ACTION U.380: .LONG <-4> ; ; ;TPA$TARGET U.381: .WORD <-2> ; ; ;TPA$TYPE U.385: .WORD -26837 ; ; ;TPA$FLAGS2 U.386: .BYTE 1 ; ; ;TPA$PARAM U.387: .LONG 3 ; ; ;TPA$ACTION U.388: .LONG <-4> ; ; ;TPA$TARGET U.389: .WORD <-2> ; ; ;SET_LIN_STATE U.150: .BLKB 0 ;TPA$TYPE U.391: .WORD -28179 ; ; ;TPA$ACTION U.392: .LONG <-4> ; ; ;TPA$TARGET U.393: .WORD <-2> ; ; ;TPA$TYPE U.394: .WORD -27146 ; ; ;TPA$ACTION U.395: .LONG <-4> ; ; ;TPA$TARGET U.396: .WORD <-2> ; ; ;SET_ECH_STATE U.221: .BLKB 0 ;TPA$TYPE U.400: .WORD -27860 ; ; ;TPA$FLAGS2 U.401: .BYTE 1 ; ; ;TPA$PARAM U.402: .LONG 0 ; ; ;TPA$ACTION U.403: .LONG <-4> ; ; ;TPA$TARGET U.404: .WORD <-2> ; ; ;TPA$TYPE U.408: .WORD -26835 ; ; ;TPA$FLAGS2 U.409: .BYTE 1 ; ; ;TPA$PARAM U.410: .LONG 1 ; ; ;TPA$ACTION U.411: .LONG <-4> ; ; ;TPA$TARGET U.412: .WORD <-2> ; ; ;SET_MSG_STATE U.227: .BLKB 0 ;TPA$TYPE U.417: .WORD 4398 ; ; ;TPA$TARGET U.419: .WORD <-2> ; ; ;TPA$TYPE U.423: .WORD 5423 ; ; ;TPA$TARGET U.425: .WORD <-2> ; ; ;SET_MSG_FIL_STATE U.418: .BLKB 0 ;TPA$TYPE U.430: .WORD -27856 ; ; ;TPA$FLAGS2 U.431: .BYTE 1 ; ; ;TPA$PARAM U.432: .LONG 0 ; ; ;TPA$ACTION U.433: .LONG <-4> ; ; ;TPA$TARGET U.434: .WORD <-2> ; ; ;TPA$TYPE U.438: .WORD -26831 ; ; ;TPA$FLAGS2 U.439: .BYTE 1 ; ; ;TPA$PARAM U.440: .LONG 1 ; ; ;TPA$ACTION U.441: .LONG <-4> ; ; ;TPA$TARGET U.442: .WORD <-2> ; ; ;SET_MSG_PKT_STATE U.424: .BLKB 0 ;TPA$TYPE U.447: .WORD -27854 ; ; ;TPA$FLAGS2 U.448: .BYTE 1 ; ; ;TPA$PARAM U.449: .LONG 0 ; ; ;TPA$ACTION U.450: .LONG <-4> ; ; ;TPA$TARGET U.451: .WORD <-2> ; ; ;TPA$TYPE U.455: .WORD -26829 ; ; ;TPA$FLAGS2 U.456: .BYTE 1 ; ; ;TPA$PARAM U.457: .LONG 1 ; ; ;TPA$ACTION U.458: .LONG <-4> ; ; ;TPA$TARGET U.459: .WORD <-2> ; ; ;SET_RPT_STATE U.245: .BLKB 0 ;TPA$TYPE U.461: .WORD 22004 ; ; ;TPA$ADDR U.462: .LONG <-4> ; ; ;TPA$TARGET U.463: .WORD <-2> ; ; ;SET_RTY_STATE U.251: .BLKB 0 ;TPA$TYPE U.467: .WORD 4404 ; ; ;TPA$TARGET U.469: .WORD <-2> ; ; ;TPA$TYPE U.473: .WORD 5429 ; ; ;TPA$TARGET U.475: .WORD <-2> ; ; ;SET_RTY_INI_STATE U.468: .BLKB 0 ;TPA$TYPE U.477: .WORD 22003 ; ; ;TPA$ADDR U.478: .LONG <-4> ; ; ;TPA$TARGET U.479: .WORD <-2> ; ; ;SET_RTY_PKT_STATE U.474: .BLKB 0 ;TPA$TYPE U.480: .WORD 22003 ; ; ;TPA$ADDR U.481: .LONG <-4> ; ; ;TPA$TARGET U.482: .WORD <-2> ; ; ;SET_PAR_STATE U.233: .BLKB 0 ;TPA$TYPE U.486: .WORD -27850 ; ; ;TPA$FLAGS2 U.487: .BYTE 1 ; ; ;TPA$PARAM U.488: .LONG 2 ; ; ;TPA$ACTION U.489: .LONG <-4> ; ; ;TPA$TARGET U.490: .WORD <-2> ; ; ;TPA$TYPE U.494: .WORD -27849 ; ; ;TPA$FLAGS2 U.495: .BYTE 1 ; ; ;TPA$PARAM U.496: .LONG 1 ; ; ;TPA$ACTION U.497: .LONG <-4> ; ; ;TPA$TARGET U.498: .WORD <-2> ; ; ;TPA$TYPE U.502: .WORD -27848 ; ; ;TPA$FLAGS2 U.503: .BYTE 1 ; ; ;TPA$PARAM U.504: .LONG 0 ; ; ;TPA$ACTION U.505: .LONG <-4> ; ; ;TPA$TARGET U.506: .WORD <-2> ; ; ;TPA$TYPE U.510: .WORD -27847 ; ; ;TPA$FLAGS2 U.511: .BYTE 1 ; ; ;TPA$PARAM U.512: .LONG 0 ; ; ;TPA$ACTION U.513: .LONG <-4> ; ; ;TPA$TARGET U.514: .WORD <-2> ; ; ;TPA$TYPE U.518: .WORD -26822 ; ; ;TPA$FLAGS2 U.519: .BYTE 1 ; ; ;TPA$PARAM U.520: .LONG 4 ; ; ;TPA$ACTION U.521: .LONG <-4> ; ; ;TPA$TARGET U.522: .WORD <-2> ; ; ;SET_REC_STATE U.239: .BLKB 0 ;TPA$TYPE U.527: .WORD 4411 ; ; ;TPA$TARGET U.529: .WORD <-2> ; ; ;TPA$TYPE U.533: .WORD 4412 ; ; ;TPA$TARGET U.535: .WORD <-2> ; ; ;TPA$TYPE U.539: .WORD 4413 ; ; ;TPA$TARGET U.541: .WORD <-2> ; ; ;TPA$TYPE U.545: .WORD 4414 ; ; ;TPA$TARGET U.547: .WORD <-2> ; ; ;TPA$TYPE U.551: .WORD 4415 ; ; ;TPA$TARGET U.553: .WORD <-2> ; ; ;TPA$TYPE U.557: .WORD 4416 ; ; ;TPA$TARGET U.559: .WORD <-2> ; ; ;TPA$TYPE U.563: .WORD 4417 ; ; ;TPA$TARGET U.565: .WORD <-2> ; ; ;TPA$TYPE U.569: .WORD 5442 ; ; ;TPA$TARGET U.571: .WORD <-2> ; ; ;SR_PKT_STATE U.540: .BLKB 0 ;TPA$TYPE U.573: .WORD -10765 ; ; ;TPA$ACTION U.574: .LONG <-4> ; ; ;TPA$ADDR U.575: .LONG <-4> ; ; ;TPA$TARGET U.576: .WORD <-2> ; ; ;SR_PAD_STATE U.552: .BLKB 0 ;TPA$TYPE U.577: .WORD -10765 ; ; ;TPA$ACTION U.578: .LONG <-4> ; ; ;TPA$ADDR U.579: .LONG <-4> ; ; ;TPA$TARGET U.580: .WORD <-2> ; ; ;SR_PDC_STATE U.546: .BLKB 0 ;TPA$TYPE U.581: .WORD -10764 ; ; ;TPA$ACTION U.582: .LONG <-4> ; ; ;TPA$ADDR U.583: .LONG <-4> ; ; ;TPA$TARGET U.584: .WORD <-2> ; ; ;SR_SOH_STATE U.564: .BLKB 0 ;TPA$TYPE U.585: .WORD -10764 ; ; ;TPA$ACTION U.586: .LONG <-4> ; ; ;TPA$ADDR U.587: .LONG <-4> ; ; ;TPA$TARGET U.588: .WORD <-2> ; ; ;SR_TIM_STATE U.570: .BLKB 0 ;TPA$TYPE U.589: .WORD 22003 ; ; ;TPA$ADDR U.590: .LONG <-4> ; ; ;TPA$TARGET U.591: .WORD <-2> ; ; ;SR_EOL_STATE U.534: .BLKB 0 ;TPA$TYPE U.592: .WORD -10764 ; ; ;TPA$ACTION U.593: .LONG <-4> ; ; ;TPA$ADDR U.594: .LONG <-4> ; ; ;TPA$TARGET U.595: .WORD <-2> ; ; ;SR_QUO_STATE U.558: .BLKB 0 ;TPA$TYPE U.596: .WORD 22004 ; ; ;TPA$ADDR U.597: .LONG <-4> ; ; ;TPA$TARGET U.598: .WORD <-2> ; ; ;SR_8QU_STATE U.528: .BLKB 0 ;TPA$TYPE U.599: .WORD 22004 ; ; ;TPA$ADDR U.600: .LONG <-4> ; ; ;TPA$TARGET U.601: .WORD <-2> ; ; ;SET_SND_STATE U.257: .BLKB 0 ;TPA$TYPE U.605: .WORD 4419 ; ; ;TPA$TARGET U.607: .WORD <-2> ; ; ;TPA$TYPE U.611: .WORD 4420 ; ; ;TPA$TARGET U.613: .WORD <-2> ; ; ;TPA$TYPE U.617: .WORD 4421 ; ; ;TPA$TARGET U.619: .WORD <-2> ; ; ;TPA$TYPE U.623: .WORD 4422 ; ; ;TPA$TARGET U.625: .WORD <-2> ; ; ;TPA$TYPE U.629: .WORD 4423 ; ; ;TPA$TARGET U.631: .WORD <-2> ; ; ;TPA$TYPE U.635: .WORD 4424 ; ; ;TPA$TARGET U.637: .WORD <-2> ; ; ;TPA$TYPE U.641: .WORD 5449 ; ; ;TPA$TARGET U.643: .WORD <-2> ; ; ;SS_PKT_STATE U.612: .BLKB 0 ;TPA$TYPE U.645: .WORD -10765 ; ; ;TPA$ACTION U.646: .LONG <-4> ; ; ;TPA$ADDR U.647: .LONG <-4> ; ; ;TPA$TARGET U.648: .WORD <-2> ; ; ;SS_PAD_STATE U.624: .BLKB 0 ;TPA$TYPE U.649: .WORD -10765 ; ; ;TPA$ACTION U.650: .LONG <-4> ; ; ;TPA$ADDR U.651: .LONG <-4> ; ; ;TPA$TARGET U.652: .WORD <-2> ; ; ;SS_PDC_STATE U.618: .BLKB 0 ;TPA$TYPE U.653: .WORD -10764 ; ; ;TPA$ACTION U.654: .LONG <-4> ; ; ;TPA$ADDR U.655: .LONG <-4> ; ; ;TPA$TARGET U.656: .WORD <-2> ; ; ;SS_SOH_STATE U.636: .BLKB 0 ;TPA$TYPE U.657: .WORD -10764 ; ; ;TPA$ACTION U.658: .LONG <-4> ; ; ;TPA$ADDR U.659: .LONG <-4> ; ; ;TPA$TARGET U.660: .WORD <-2> ; ; ;SS_TIM_STATE U.642: .BLKB 0 ;TPA$TYPE U.661: .WORD 22003 ; ; ;TPA$ADDR U.662: .LONG <-4> ; ; ;TPA$TARGET U.663: .WORD <-2> ; ; ;SS_EOL_STATE U.606: .BLKB 0 ;TPA$TYPE U.664: .WORD -10764 ; ; ;TPA$ACTION U.665: .LONG <-4> ; ; ;TPA$ADDR U.666: .LONG <-4> ; ; ;TPA$TARGET U.667: .WORD <-2> ; ; ;SS_QUO_STATE U.630: .BLKB 0 ;TPA$TYPE U.668: .WORD 22004 ; ; ;TPA$ADDR U.669: .LONG <-4> ; ; ;TPA$TARGET U.670: .WORD <-2> ; ; ;SEND_STATE U.122: .BLKB 0 ;TPA$TYPE U.671: .WORD -28179 ; ; ;TPA$ACTION U.672: .LONG <-4> ; ; ;TPA$TARGET U.673: .WORD <-2> ; ; ;TPA$TYPE U.674: .WORD -27146 ; ; ;TPA$ACTION U.675: .LONG <-4> ; ; ;TPA$TARGET U.676: .WORD <-2> ; ; ;SHOW_STATE U.137: .BLKB 0 ;TPA$TYPE U.680: .WORD 29002 ; ; ;TPA$ADDR U.681: .LONG <-4> ; ; ;TPA$MASK U.682: .LONG 1 ; ; ;TPA$TARGET U.683: .WORD <-2> ; ; ;TPA$TYPE U.687: .WORD 29003 ; ; ;TPA$ADDR U.688: .LONG <-4> ; ; ;TPA$MASK U.689: .LONG 12 ; ; ;TPA$TARGET U.690: .WORD <-2> ; ; ;TPA$TYPE U.694: .WORD 29004 ; ; ;TPA$ADDR U.695: .LONG <-4> ; ; ;TPA$MASK U.696: .LONG 16 ; ; ;TPA$TARGET U.697: .WORD <-2> ; ; ;TPA$TYPE U.701: .WORD 29005 ; ; ;TPA$ADDR U.702: .LONG <-4> ; ; ;TPA$MASK U.703: .LONG 2 ; ; ;TPA$TARGET U.704: .WORD <-2> ; ; ;TPA$TYPE U.708: .WORD 29006 ; ; ;TPA$ADDR U.709: .LONG <-4> ; ; ;TPA$MASK U.710: .LONG 3 ; ; ;TPA$TARGET U.711: .WORD <-2> ; ; ;TPA$TYPE U.715: .WORD 29007 ; ; ;TPA$ADDR U.716: .LONG <-4> ; ; ;TPA$MASK U.717: .LONG 4 ; ; ;TPA$TARGET U.718: .WORD <-2> ; ; ;TPA$TYPE U.722: .WORD 29008 ; ; ;TPA$ADDR U.723: .LONG <-4> ; ; ;TPA$MASK U.724: .LONG 5 ; ; ;TPA$TARGET U.725: .WORD <-2> ; ; ;TPA$TYPE U.729: .WORD 29009 ; ; ;TPA$ADDR U.730: .LONG <-4> ; ; ;TPA$MASK U.731: .LONG 14 ; ; ;TPA$TARGET U.732: .WORD <-2> ; ; ;TPA$TYPE U.736: .WORD 29010 ; ; ;TPA$ADDR U.737: .LONG <-4> ; ; ;TPA$MASK U.738: .LONG 13 ; ; ;TPA$TARGET U.739: .WORD <-2> ; ; ;TPA$TYPE U.743: .WORD 29011 ; ; ;TPA$ADDR U.744: .LONG <-4> ; ; ;TPA$MASK U.745: .LONG 6 ; ; ;TPA$TARGET U.746: .WORD <-2> ; ; ;TPA$TYPE U.750: .WORD 29012 ; ; ;TPA$ADDR U.751: .LONG <-4> ; ; ;TPA$MASK U.752: .LONG 7 ; ; ;TPA$TARGET U.753: .WORD <-2> ; ; ;TPA$TYPE U.757: .WORD 29013 ; ; ;TPA$ADDR U.758: .LONG <-4> ; ; ;TPA$MASK U.759: .LONG 15 ; ; ;TPA$TARGET U.760: .WORD <-2> ; ; ;TPA$TYPE U.764: .WORD 29014 ; ; ;TPA$ADDR U.765: .LONG <-4> ; ; ;TPA$MASK U.766: .LONG 10 ; ; ;TPA$TARGET U.767: .WORD <-2> ; ; ;TPA$TYPE U.771: .WORD 29015 ; ; ;TPA$ADDR U.772: .LONG <-4> ; ; ;TPA$MASK U.773: .LONG 8 ; ; ;TPA$TARGET U.774: .WORD <-2> ; ; ;TPA$TYPE U.778: .WORD 29016 ; ; ;TPA$ADDR U.779: .LONG <-4> ; ; ;TPA$MASK U.780: .LONG 9 ; ; ;TPA$TARGET U.781: .WORD <-2> ; ; ;TPA$TYPE U.785: .WORD 30041 ; ; ;TPA$ADDR U.786: .LONG <-4> ; ; ;TPA$MASK U.787: .LONG 11 ; ; ;TPA$TARGET U.788: .WORD <-2> ; ; ;DONE_STATE U.46: .BLKB 0 ;TPA$TYPE U.790: .WORD 5623 ; ; ;TPA$TARGET U.791: .WORD -1 ; ; .PSECT _LIB$KEY0$,NOWRT, SHR, PIC,1 KERMIT_KEY:: .BLKB 0 ;TPA$KEY0 U.39: .BLKB 0 ;TPA$KEY U.41: .WORD ; ; ;TPA$KEY U.49: .WORD ; ; ;TPA$KEY U.57: .WORD ; ; ;TPA$KEY U.64: .WORD ; ; ;TPA$KEY U.71: .WORD ; ; ;TPA$KEY U.79: .WORD ; ; ;TPA$KEY U.88: .WORD ; ; ;TPA$KEY U.95: .WORD ; ; ;TPA$KEY U.102: .WORD ; ; ;TPA$KEY U.109: .WORD ; ; ;TPA$KEY U.117: .WORD ; ; ;TPA$KEY U.125: .WORD ; ; ;TPA$KEY U.132: .WORD ; ; ;TPA$KEY U.140: .WORD ; ; ;TPA$KEY U.171: .WORD ; ; ;TPA$KEY U.177: .WORD ; ; ;TPA$KEY U.183: .WORD ; ; ;TPA$KEY U.189: .WORD ; ; ;TPA$KEY U.195: .WORD ; ; ;TPA$KEY U.201: .WORD ; ; ;TPA$KEY U.207: .WORD ; ; ;TPA$KEY U.213: .WORD ; ; ;TPA$KEY U.218: .WORD ; ; ;TPA$KEY U.224: .WORD ; ; ;TPA$KEY U.230: .WORD ; ; ;TPA$KEY U.236: .WORD ; ; ;TPA$KEY U.242: .WORD ; ; ;TPA$KEY U.248: .WORD ; ; ;TPA$KEY U.254: .WORD ; ; ;TPA$KEY U.261: .WORD ; ; ;TPA$KEY U.269: .WORD ; ; ;TPA$KEY U.278: .WORD ; ; ;TPA$KEY U.286: .WORD ; ; ;TPA$KEY U.294: .WORD ; ; ;TPA$KEY U.302: .WORD ; ; ;TPA$KEY U.310: .WORD ; ; ;TPA$KEY U.318: .WORD ; ; ;TPA$KEY U.327: .WORD ; ; ;TPA$KEY U.335: .WORD ; ; ;TPA$KEY U.344: .WORD ; ; ;TPA$KEY U.352: .WORD ; ; ;TPA$KEY U.367: .WORD ; ; ;TPA$KEY U.375: .WORD ; ; ;TPA$KEY U.383: .WORD ; ; ;TPA$KEY U.398: .WORD ; ; ;TPA$KEY U.406: .WORD ; ; ;TPA$KEY U.415: .WORD ; ; ;TPA$KEY U.421: .WORD ; ; ;TPA$KEY U.428: .WORD ; ; ;TPA$KEY U.436: .WORD ; ; ;TPA$KEY U.445: .WORD ; ; ;TPA$KEY U.453: .WORD ; ; ;TPA$KEY U.465: .WORD ; ; ;TPA$KEY U.471: .WORD ; ; ;TPA$KEY U.484: .WORD ; ; ;TPA$KEY U.492: .WORD ; ; ;TPA$KEY U.500: .WORD ; ; ;TPA$KEY U.508: .WORD ; ; ;TPA$KEY U.516: .WORD ; ; ;TPA$KEY U.525: .WORD ; ; ;TPA$KEY U.531: .WORD ; ; ;TPA$KEY U.537: .WORD ; ; ;TPA$KEY U.543: .WORD ; ; ;TPA$KEY U.549: .WORD ; ; ;TPA$KEY U.555: .WORD ; ; ;TPA$KEY U.561: .WORD ; ; ;TPA$KEY U.567: .WORD ; ; ;TPA$KEY U.603: .WORD ; ; ;TPA$KEY U.609: .WORD ; ; ;TPA$KEY U.615: .WORD ; ; ;TPA$KEY U.621: .WORD ; ; ;TPA$KEY U.627: .WORD ; ; ;TPA$KEY U.633: .WORD ; ; ;TPA$KEY U.639: .WORD ; ; ;TPA$KEY U.678: .WORD ; ; ;TPA$KEY U.685: .WORD ; ; ;TPA$KEY U.692: .WORD ; ; ;TPA$KEY U.699: .WORD ; ; ;TPA$KEY U.706: .WORD ; ; ;TPA$KEY U.713: .WORD ; ; ;TPA$KEY U.720: .WORD ; ; ;TPA$KEY U.727: .WORD ; ; ;TPA$KEY U.734: .WORD ; ; ;TPA$KEY U.741: .WORD ; ; ;TPA$KEY U.748: .WORD ; ; ;TPA$KEY U.755: .WORD ; ; ;TPA$KEY U.762: .WORD ; ; ;TPA$KEY U.769: .WORD ; ; ;TPA$KEY U.776: .WORD ; ; ;TPA$KEY U.783: .WORD ; ; .PSECT $OWN$,NOEXE,2 ;TPARSE_BLOCK U.28: .LONG 8, 2 ; ; .BLKB 28 ;COMMAND U.29: .BLKB 4 ;SHOW_TYPE U.30: .BLKB 4 ;OUTPUT_LINE U.31: .BLKB 80 ;OUTPUT_DESC U.32: .BLKB 8 ;OUTPUT_SIZE U.33: .BLKB 2 .BLKB 2 ;CRC_TABLE U.34: .BLKB 64 ;TIMER_HANDLE U.35: .BLKB 4 ;TEMP_DESC U.36: .BLKB 8 ;TEMP_NAME U.37: .BLKB 132 .PSECT $GLOBAL$,NOEXE,2 ESCAPE_CHR:: .BLKB 4 TERM_NAME:: .BLKB 80 TERM_DESC:: .BLKB 8 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$INIT_TIMER, LIB$STAT_TIMER, LIB$FREE_TIMER, LIB$EDIV, LIB$GET_FOREIGN, LIB$GET_INPUT .EXTRN LIB$PUT_OUTPUT, LIB$TPARSE, LIB$CRC_TABLE, LIB$CRC, LIB$SIGNAL, LIB$ESTABLISH, SEND_SWITCH .EXTRN REC_SWITCH, DO_GENERIC, SERVER, SND_ERROR, MSG_INIT, FILE_INIT, TERM_INIT, TERM_OPEN .EXTRN TERM_CLOSE, TERM_CONNECT, TT_INIT, TT_TEXT, TT_NUMBER, TT_CHAR, TT_OUTPUT, TT_CRLF .EXTRN RCV_PKT_SIZE, RCV_NPAD, RCV_PADCHAR, RCV_TIMEOUT, RCV_EOL, RCV_QUOTE_CHR, RCV_8QUOTE_CHR .EXTRN RCV_SOH, SND_PKT_SIZE, SND_NPAD, SND_PADCHAR, SND_TIMEOUT, SND_EOL, SND_QUOTE_CHR .EXTRN SND_SOH, SET_REPT_CHR, SND_TOTAL_CHARS, RCV_TOTAL_CHARS, SND_DATA_CHARS, RCV_DATA_CHARS .EXTRN SMSG_TOTAL_CHARS, RMSG_TOTAL_CHARS, SMSG_DATA_CHARS, RMSG_DATA_CHARS, RCV_NAKS, SND_NAKS .EXTRN RMSG_NAKS, SMSG_NAKS, RCV_COUNT, SND_COUNT, XFR_TIME, TOTAL_TIME, LAST_ERROR, TY_PKT .EXTRN TY_FIL, FILE_SIZE, FILE_NAME, SI_RETRIES, PKT_RETRIES, DELAY, DEBUG_FLAG, CHKTYPE .EXTRN ABT_FLAG, IBM_FLAG, WARN_FLAG, PARITY_TYPE, ECHO_FLAG, CONNECT_FLAG, FILE_TYPE, FILE_DESC .EXTRN TERM_FLAG .PSECT $CODE$,NOWRT,2 MAIN_ROUTINE: .WORD ^M<> ;Save nothing ; 1341 SUBL2 #4, SP ;#4, SP ; CALLS #0, W^MSG_INIT ;#0, MSG_INIT ; 1383 CALLS #0, W^TERM_INIT ;#0, TERM_INIT ; 1384 CALLS #0, W^TT_INIT ;#0, TT_INIT ; 1385 CALLS #0, W^FILE_INIT ;#0, FILE_INIT ; 1386 MOVL #29, W^ESCAPE_CHR ;#29, ESCAPE_CHR ; 1387 MOVZWL #33800, (SP) ;#33800, CRC_BIT_MASK ; 1391 PUSHAB W^U.34 ;U.34 ; 1392 PUSHAB 4(SP) ;CRC_BIT_MASK ; CALLS #2, G^LIB$CRC_TABLE ;#2, LIB$CRC_TABLE ; PUSHAB W^U.24 ;U.24 ; 1393 CALLS #1, G^LIB$ESTABLISH ;#1, LIB$ESTABLISH ; CLRL W^U.35 ;U.35 ; 1394 PUSHAB W^U.35 ;U.35 ; 1395 CALLS #1, G^LIB$INIT_TIMER ;#1, LIB$INIT_TIMER ; CALLS #0, W^U.1 ;#0, U.1 ; 1399 RET ; ; 1341 ; Routine Size: 81 bytes, Routine Base: $CODE$ + 0000 ; 1401 %SBTTL 'COMND' ; 1402 ROUTINE COMND = ; 1403 ; 1404 !++ ; 1405 ! FUNCTIONAL DESCRIPTION: ; 1406 ! This routine will do the command scanning for KERMIT-32. It ; 1407 ! will call the correct routines to process the commands. ; 1408 ! ; 1409 ! CALLING SEQUENCE: ; 1410 ! ; 1411 ! COMND(); ; 1412 ! ; 1413 ! INPUT PARAMETERS: ; 1414 ! ; 1415 ! None. ; 1416 ! ; 1417 ! IMPLICIT INPUTS: ; 1418 ! ; 1419 ! None. ; 1420 ! ; 1421 ! OUTPUT PARAMETERS: ; 1422 ! ; 1423 ! None. ; 1424 ! ; 1425 ! IMPLICIT OUTPUTS: ; 1426 ! ; 1427 ! None. ; 1428 ! ; 1429 ! COMPLETION CODES: ; 1430 ! ; 1431 ! None. ; 1432 ! ; 1433 ! SIDE EFFECTS: ; 1434 ! ; 1435 ! None. ; 1436 ! ; 1437 !-- ; 1438 ; 1439 BEGIN ; 1440 ; 1441 BIND ; 1442 SERVER_TEXT = %ASCID'[Kermit Server running on VAX host. Please type your escape sequence to', ; 1443 SERVER_TEXT_1 = %ASCID' return to your local machine. Shut down the server by typing the Kermit BYE', ; 1444 SERVER_TEXT_2 = %ASCID' command on your local machine.]'; ; 1445 ; 1446 OWN ; 1447 DESC : BLOCK [8, BYTE], ; 1448 CMD_BUF : VECTOR [80, BYTE, UNSIGNED], ; 1449 CMD_SIZE : UNSIGNED WORD, ; 1450 FORCE_PROMPT, ! Cause prompt to be forced ; 1451 STATUS : UNSIGNED LONG; ; 1452 ; 1453 FORCE_PROMPT = 0; ; 1454 RETURN ; 1455 ; 1456 WHILE TRUE DO ; 1457 BEGIN ; 1458 ! Initialize some per-command data areas. ; 1459 TEMP_DESC [DSC$B_CLASS] = DSC$K_CLASS_S; ; 1460 TEMP_DESC [DSC$B_DTYPE] = DSC$K_DTYPE_T; ; 1461 TEMP_DESC [DSC$W_LENGTH] = 0; ; 1462 TEMP_DESC [DSC$A_POINTER] = TEMP_NAME; ; 1463 COMMAND = 0; ; 1464 SHOW_TYPE = 0; ; 1465 ! Initialize variables for the scanning of a command. ; 1466 DESC [DSC$B_CLASS] = DSC$K_CLASS_S; ; 1467 DESC [DSC$B_DTYPE] = DSC$K_DTYPE_T; ; 1468 DESC [DSC$W_LENGTH] = 80; ; 1469 DESC [DSC$A_POINTER] = CMD_BUF; ; 1470 FILE_SIZE = 0; ; 1471 ; 1472 DO ; 1473 STATUS = LIB$GET_FOREIGN (DESC, %ASCID'Kermit-32>', CMD_SIZE, FORCE_PROMPT) ; 1474 UNTIL (.CMD_SIZE NEQ 0 OR .STATUS NEQ SS$_NORMAL); ; 1475 ; 1476 IF .STATUS EQL RMS$_EOF THEN EXITLOOP SS$_NORMAL; ; 1477 ; 1478 DESC [DSC$W_LENGTH] = .CMD_SIZE; ; 1479 ; 1480 IF .STATUS ; 1481 THEN ; 1482 BEGIN ; 1483 TPARSE_BLOCK [TPA$L_STRINGCNT] = .CMD_SIZE; ; 1484 TPARSE_BLOCK [TPA$L_STRINGPTR] = CMD_BUF; ; 1485 STATUS = LIB$TPARSE (TPARSE_BLOCK, KERMIT_STATE, KERMIT_KEY); ; 1486 ; 1487 IF .STATUS ; 1488 THEN ; 1489 BEGIN ; 1490 ; 1491 SELECTONE .COMMAND OF ; 1492 SET ; 1493 ; 1494 [CMD_BYE] : ; 1495 BEGIN ; 1496 ; 1497 IF TERM_OPEN () ; 1498 THEN ; 1499 BEGIN ; 1500 DO_GENERIC (GC_LOGOUT); ; 1501 TERM_CLOSE () ; 1502 END; ; 1503 ; 1504 EXITLOOP KER_NORMAL; ; 1505 END; ; 1506 ; 1507 [CMD_CONN] : ; 1508 TERM_CONNECT (); ; 1509 ; 1510 [CMD_EXIT] : ; 1511 EXITLOOP KER_NORMAL; ; 1512 ; 1513 [CMD_FINISH] : ; 1514 ; 1515 IF TERM_OPEN () ; 1516 THEN ; 1517 BEGIN ; 1518 DO_GENERIC (GC_EXIT); ; 1519 TERM_CLOSE () ; 1520 END; ; 1521 ; 1522 [CMD_HELP] : ; 1523 COMND_HELP (); ; 1524 ; 1525 [CMD_LOGOUT] : ; 1526 ; 1527 IF TERM_OPEN () ; 1528 THEN ; 1529 BEGIN ; 1530 DO_GENERIC (GC_LOGOUT); ; 1531 TERM_CLOSE () ; 1532 END; ; 1533 ; 1534 [CMD_RECEIVE] : ; 1535 ; 1536 IF TERM_OPEN () ; 1537 THEN ; 1538 BEGIN ; 1539 REC_SWITCH (); ; 1540 TERM_CLOSE (); ; 1541 END; ; 1542 ; 1543 [CMD_SEND] : ; 1544 ; 1545 IF TERM_OPEN () ; 1546 THEN ; 1547 BEGIN ; 1548 SEND_SWITCH (); ; 1549 TERM_CLOSE (); ; 1550 END; ; 1551 ; 1552 [CMD_SERVER] : ; 1553 BEGIN ; 1554 STATUS = LIB$PUT_OUTPUT (SERVER_TEXT); ; 1555 STATUS = LIB$PUT_OUTPUT (SERVER_TEXT_1); ; 1556 STATUS = LIB$PUT_OUTPUT (SERVER_TEXT_2); ; 1557 ; 1558 IF TERM_OPEN () ; 1559 THEN ; 1560 BEGIN ; 1561 STATUS = SERVER (); ; 1562 TERM_CLOSE (); ; 1563 IF .STATUS NEQ KER_ABORTED THEN ; 1564 EXITLOOP KER_NORMAL; ; 1565 END; ; 1566 ; 1567 END; ; 1568 ; 1569 [CMD_SHOW] : ; 1570 COMND_SHOW (); ; 1571 ; 1572 [CMD_STATUS] : ; 1573 COMND_STATUS (); ; 1574 TES; ; 1575 ; 1576 END ; 1577 ELSE ; 1578 LIB$SIGNAL (.STATUS); ; 1579 ; 1580 END ; 1581 ELSE ; 1582 LIB$SIGNAL (.STATUS); ; 1583 ; 1584 END; ! End of WHILE TRUE DO BEGIN ; 1585 ; 1586 END; ! End of COMND .PSECT $PLIT$,NOWRT,NOEXE,2 P.AAB: .ASCII \[Kermit Server running on VAX host. Please type your escape sequence to\ ; ; P.AAA: .LONG 17694792 ; ; .ADDRESS P.AAB ; ; P.AAD: .ASCII \ return to your local machine. Shut down the server by typing the Kermit BYE\<0><0><0> ; ; P.AAC: .LONG 17694797 ; ; .ADDRESS P.AAD ; ; P.AAF: .ASCII \ command on your local machine.]\ ; ; P.AAE: .LONG 17694752 ; ; .ADDRESS P.AAF ; ; P.AAH: .ASCII \Kermit-32>\<0><0> ; ; P.AAG: .LONG 17694730 ; ; .ADDRESS P.AAH ; ; .PSECT $OWN$,NOEXE,2 DESC: .BLKB 8 CMD_BUF:.BLKB 80 CMD_SIZE: .BLKB 2 .BLKB 2 FORCE_PROMPT: .BLKB 4 STATUS: .BLKB 4 SERVER_TEXT= P.AAA SERVER_TEXT_1= P.AAC SERVER_TEXT_2= P.AAE .PSECT $CODE$,NOWRT,2 ;COMND U.1: .WORD ^M ;Save R2,R3,R4,R5,R6 ; 1402 MOVAB W^TERM_CLOSE, R6 ;TERM_CLOSE, R6 ; MOVAB G^LIB$PUT_OUTPUT, R5 ;LIB$PUT_OUTPUT, R5 ; MOVAB W^TERM_OPEN, R4 ;TERM_OPEN, R4 ; MOVAB W^STATUS, R3 ;STATUS, R3 ; CLRL -4(R3) ;FORCE_PROMPT ; 1453 1$: MOVL #17694720, -236(R3) ;#17694720, TEMP_DESC ; 1461 MOVAB -228(R3), -232(R3) ;TEMP_NAME, TEMP_DESC+4 ; 1462 CLRQ -404(R3) ;COMMAND ; 1463 MOVL #17694800, -96(R3) ;#17694800, DESC ; 1468 MOVAB -88(R3), -92(R3) ;CMD_BUF, DESC+4 ; 1469 CLRL W^FILE_SIZE ;FILE_SIZE ; 1470 2$: PUSHAB -4(R3) ;FORCE_PROMPT ; 1473 PUSHAB -8(R3) ;CMD_SIZE ; PUSHAB W^P.AAG ;P.AAG ; PUSHAB -96(R3) ;DESC ; CALLS #4, G^LIB$GET_FOREIGN ;#4, LIB$GET_FOREIGN ; MOVL R0, (R3) ;R0, STATUS ; MOVZWL -8(R3), R0 ;CMD_SIZE, R0 ; 1474 BNEQ 3$ ;3$ ; CMPL (R3), #1 ;STATUS, #1 ; BEQL 2$ ;2$ ; 3$: MOVL (R3), R1 ;STATUS, R1 ; 1476 CMPL R1, #98938 ;R1, #98938 ; BNEQ 4$ ;4$ ; MOVL #1, R0 ;#1, R0 ; RET ; ; 4$: MOVW R0, -96(R3) ;R0, DESC ; 1478 BLBS R1, 5$ ;R1, 5$ ; 1480 BRW 25$ ;25$ ; 5$: MOVL R0, -432(R3) ;R0, TPARSE_BLOCK+8 ; 1483 MOVAB -88(R3), -428(R3) ;CMD_BUF, TPARSE_BLOCK+12 ; 1484 PUSHAB W^KERMIT_KEY ;KERMIT_KEY ; 1485 PUSHAB W^KERMIT_STATE ;KERMIT_STATE ; PUSHAB -440(R3) ;TPARSE_BLOCK ; CALLS #3, G^LIB$TPARSE ;#3, LIB$TPARSE ; MOVL R0, (R3) ;R0, STATUS ; BLBS (R3), 6$ ;STATUS, 6$ ; 1487 BRW 24$ ;24$ ; 6$: MOVL -404(R3), R2 ;COMMAND, R2 ; 1491 CMPL R2, #11 ;R2, #11 ; BNEQ 8$ ;8$ ; CALLS #0, (R4) ;#0, TERM_OPEN ; 1497 BLBC R0, 7$ ;R0, 7$ ; CLRL -(SP) ;-(SP) ; 1500 CALLS #1, W^DO_GENERIC ;#1, DO_GENERIC ; CALLS #0, (R6) ;#0, TERM_CLOSE ; 1501 7$: BRW 19$ ;19$ ; 1495 8$: CMPL R2, #1 ;R2, #1 ; 1491 BNEQ 9$ ;9$ ; CALLS #0, W^TERM_CONNECT ;#0, TERM_CONNECT ; 1508 BRB 16$ ;16$ ; 1491 9$: CMPL R2, #2 ;R2, #2 ; BEQL 7$ ;7$ ; CMPL R2, #12 ;R2, #12 ; BNEQ 10$ ;10$ ; CALLS #0, (R4) ;#0, TERM_OPEN ; 1515 BLBC R0, 18$ ;R0, 18$ ; PUSHL #1 ;#1 ; 1518 BRB 12$ ;12$ ; 10$: CMPL R2, #3 ;R2, #3 ; 1491 BNEQ 11$ ;11$ ; CALLS #0, W^U.2 ;#0, U.2 ; 1523 BRB 16$ ;16$ ; 1491 11$: CMPL R2, #10 ;R2, #10 ; BNEQ 13$ ;13$ ; CALLS #0, (R4) ;#0, TERM_OPEN ; 1527 BLBC R0, 21$ ;R0, 21$ ; CLRL -(SP) ;-(SP) ; 1530 12$: CALLS #1, W^DO_GENERIC ;#1, DO_GENERIC ; BRB 15$ ;15$ ; 1531 13$: CMPL R2, #4 ;R2, #4 ; 1491 BNEQ 14$ ;14$ ; CALLS #0, (R4) ;#0, TERM_OPEN ; 1536 BLBC R0, 23$ ;R0, 23$ ; CALLS #0, W^REC_SWITCH ;#0, REC_SWITCH ; 1539 BRB 15$ ;15$ ; 1540 14$: CMPL R2, #6 ;R2, #6 ; 1491 BNEQ 17$ ;17$ ; CALLS #0, (R4) ;#0, TERM_OPEN ; 1545 BLBC R0, 27$ ;R0, 27$ ; CALLS #0, W^SEND_SWITCH ;#0, SEND_SWITCH ; 1548 15$: CALLS #0, (R6) ;#0, TERM_CLOSE ; 1549 16$: BRB 27$ ;27$ ; 1491 17$: CMPL R2, #8 ;R2, #8 ; BNEQ 20$ ;20$ ; PUSHAB W^SERVER_TEXT ;SERVER_TEXT ; 1554 CALLS #1, (R5) ;#1, LIB$PUT_OUTPUT ; MOVL R0, (R3) ;R0, STATUS ; PUSHAB W^SERVER_TEXT_1 ;SERVER_TEXT_1 ; 1555 CALLS #1, (R5) ;#1, LIB$PUT_OUTPUT ; MOVL R0, (R3) ;R0, STATUS ; PUSHAB W^SERVER_TEXT_2 ;SERVER_TEXT_2 ; 1556 CALLS #1, (R5) ;#1, LIB$PUT_OUTPUT ; MOVL R0, (R3) ;R0, STATUS ; CALLS #0, (R4) ;#0, TERM_OPEN ; 1558 18$: BLBC R0, 27$ ;R0, 27$ ; CALLS #0, W^SERVER ;#0, SERVER ; 1561 MOVL R0, (R3) ;R0, STATUS ; CALLS #0, (R6) ;#0, TERM_CLOSE ; 1562 CMPL (R3), #134316242 ;STATUS, #134316242 ; 1563 BEQL 27$ ;27$ ; 19$: MOVL #134316043, R0 ;#134316043, R0 ; 1564 RET ; ; 20$: CMPL R2, #7 ;R2, #7 ; 1491 BNEQ 22$ ;22$ ; CALLS #0, W^U.3 ;#0, U.3 ; 1570 21$: BRB 27$ ;27$ ; 1491 22$: CMPL R2, #9 ;R2, #9 ; BNEQ 27$ ;27$ ; CALLS #0, W^U.4 ;#0, U.4 ; 1573 23$: BRB 27$ ;27$ ; 1487 24$: PUSHL (R3) ;STATUS ; 1578 BRB 26$ ;26$ ; 25$: PUSHL R1 ;R1 ; 1582 26$: CALLS #1, G^LIB$SIGNAL ;#1, LIB$SIGNAL ; 27$: BRW 1$ ;1$ ; 1456 ; Routine Size: 404 bytes, Routine Base: $CODE$ + 0051 ; 1587 %SBTTL 'Command execution -- COMND_HELP' ; 1588 ROUTINE COMND_HELP : NOVALUE = ; 1589 ; 1590 !++ ; 1591 ! FUNCTIONAL DESCRIPTION: ; 1592 ! ; 1593 ! This routine will do the HELP command processing for KERMIT. It ; 1594 ! will call the library routines. ; 1595 ! ; 1596 ! CALLING SEQUENCE: ; 1597 ! ; 1598 ! COMND_HELP(); ; 1599 ! ; 1600 ! INPUT PARAMETERS: ; 1601 ! ; 1602 ! None. ; 1603 ! ; 1604 ! IMPLICIT INPUTS: ; 1605 ! ; 1606 ! None. ; 1607 ! ; 1608 ! OUTPUT PARAMETERS: ; 1609 ! ; 1610 ! None. ; 1611 ! ; 1612 ! IMPLICIT OUTPUTS: ; 1613 ! ; 1614 ! None. ; 1615 ! ; 1616 ! COMPLETION CODES: ; 1617 ! ; 1618 ! None. ; 1619 ! ; 1620 ! SIDE EFFECTS: ; 1621 ! ; 1622 ! None. ; 1623 ! ; 1624 !-- ; 1625 ; 1626 BEGIN ; 1627 ; 1628 LOCAL ; 1629 STATUS : UNSIGNED LONG; ; 1630 ; 1631 EXTERNAL ROUTINE ; 1632 LBR$OUTPUT_HELP : ADDRESSING_MODE (GENERAL); ; 1633 ; 1634 ! ; 1635 ! Do the help processing. ; 1636 ! ; 1637 STATUS = LBR$OUTPUT_HELP (LIB$PUT_OUTPUT, 0, TEMP_DESC, %ASCID'KERMIT', ; 1638 UPLIT (HLP$M_PROMPT + HLP$M_PROCESS + HLP$M_GROUP + HLP$M_SYSTEM), LIB$GET_INPUT); ; 1639 ; 1640 IF NOT .STATUS THEN LIB$SIGNAL (.STATUS); ; 1641 ; 1642 END; .PSECT $PLIT$,NOWRT,NOEXE,2 P.AAJ: .ASCII \KERMIT\<0><0> ; ; P.AAI: .LONG 17694726 ; ; .ADDRESS P.AAJ ; ; P.AAK: .LONG 15 ; ; .EXTRN LBR$OUTPUT_HELP .PSECT $CODE$,NOWRT,2 ;COMND_HELP U.2: .WORD ^M<> ;Save nothing ; 1588 PUSHAB G^LIB$GET_INPUT ;LIB$GET_INPUT ; 1637 PUSHAB W^P.AAK ;P.AAK ; 1638 PUSHAB W^P.AAI ;P.AAI ; 1637 PUSHAB W^U.36 ;U.36 ; CLRL -(SP) ;-(SP) ; PUSHAB G^LIB$PUT_OUTPUT ;LIB$PUT_OUTPUT ; CALLS #6, G^LBR$OUTPUT_HELP ;#6, LBR$OUTPUT_HELP ; BLBS R0, 1$ ;STATUS, 1$ ; 1640 PUSHL R0 ;STATUS ; CALLS #1, G^LIB$SIGNAL ;#1, LIB$SIGNAL ; 1$: RET ; ; 1588 ; Routine Size: 48 bytes, Routine Base: $CODE$ + 01E5 ; 1643 %SBTTL 'Command execution -- Support routine -- INIT_DESC' ; 1644 ROUTINE INIT_DESC : NOVALUE = ; 1645 ; 1646 !++ ; 1647 ! FUNCTIONAL DESCRIPTION: ; 1648 ! ; 1649 ! This routine will initialize the output descriptor for the various ; 1650 ! commands that use $FAO to output text. ; 1651 ! ; 1652 ! CALLING SEQUENCE: ; 1653 ! ; 1654 ! INIT_DESC() ; 1655 ! ; 1656 ! INPUT PARAMETERS: ; 1657 ! ; 1658 ! None. ; 1659 ! ; 1660 ! IMPLICIT INPUTS: ; 1661 ! ; 1662 ! None. ; 1663 ! ; 1664 ! OUTPUT PARAMETERS: ; 1665 ! ; 1666 ! None. ; 1667 ! ; 1668 ! IMPLICIT OUTPUTS: ; 1669 ! ; 1670 ! None. ; 1671 ! ; 1672 ! COMPLETION CODES: ; 1673 ! ; 1674 ! None. ; 1675 ! ; 1676 ! SIDE EFFECTS: ; 1677 ! ; 1678 ! None. ; 1679 ! ; 1680 !-- ; 1681 ; 1682 BEGIN ; 1683 OUTPUT_DESC [DSC$B_CLASS] = DSC$K_CLASS_S; ; 1684 OUTPUT_DESC [DSC$B_DTYPE] = DSC$K_DTYPE_T; ; 1685 OUTPUT_DESC [DSC$W_LENGTH] = OUT_BFR_LENGTH; ; 1686 OUTPUT_DESC [DSC$A_POINTER] = OUTPUT_LINE; ; 1687 END; ! End of INIT_DESC () INIT_DESC: .WORD ^M<> ;Save nothing ; 1644 MOVL #17694800, W^U.32 ;#17694800, U.32 ; 1685 MOVAB W^U.31, W^U.32+4 ;U.31, U.32+4 ; 1686 RET ; ; 1644 ; Routine Size: 19 bytes, Routine Base: $CODE$ + 0215 ; 1688 %SBTTL 'Command execution -- Support routines -- OUTPUT_LONG_WORD' ; 1689 ROUTINE OUTPUT_LONG_WORD (MSG_ADDR, LONG_VALUE) : NOVALUE = ; 1690 ; 1691 !++ ; 1692 ! FUNCTIONAL DESCRIPTION: ; 1693 ! This routine is used to output the various long word parameters ; 1694 ! that are shown by the SHOW command. All text is defined in the level ; 1695 ! 0 of this program. ; 1696 ! ; 1697 ! CALLING SEQUENCE: ; 1698 ! ; 1699 ! OUTPUT_LONG_WORD( MSG_ASCID, LONG_WORD_VALUE_TO_OUTPUT); ; 1700 ! ; 1701 ! INPUT PARAMETERS: ; 1702 ! ; 1703 ! MSG_ASCID - %ASCID of the text to use for the $FAO call. ; 1704 ! ; 1705 ! LONG_WORD_VALUE_TO_OUTPUT - Value of the long word to pass to the $FAO. ; 1706 ! ; 1707 ! IMPLICIT INPUTS: ; 1708 ! ; 1709 ! None. ; 1710 ! ; 1711 ! OUTPUT PARAMETERS: ; 1712 ! ; 1713 ! None. ; 1714 ! ; 1715 ! IMPLICIT OUTPUTS: ; 1716 ! ; 1717 ! None. ; 1718 ! ; 1719 ! COMPLETION CODES: ; 1720 ! ; 1721 ! None. ; 1722 ! ; 1723 ! SIDE EFFECTS: ; 1724 ! ; 1725 ! None. ; 1726 ! ; 1727 !-- ; 1728 ; 1729 BEGIN ; 1730 ; 1731 MAP ; 1732 LONG_VALUE : LONG UNSIGNED, ; 1733 MSG_ADDR : LONG UNSIGNED; ; 1734 ; 1735 LOCAL ; 1736 STATUS : UNSIGNED; ! Status return by LIB$xxx ; 1737 ; 1738 INIT_DESC (); ; 1739 $FAO (.MSG_ADDR, OUTPUT_SIZE, OUTPUT_DESC, .LONG_VALUE); ; 1740 OUTPUT_DESC [DSC$W_LENGTH] = .OUTPUT_SIZE; ; 1741 STATUS = LIB$PUT_OUTPUT (OUTPUT_DESC); ; 1742 END; .EXTRN SYS$FAO OUTPUT_LONG_WORD: .WORD ^M ;Save R2 ; 1689 MOVAB W^U.32, R2 ;U.32, R2 ; CALLS #0, B^INIT_DESC ;#0, INIT_DESC ; 1738 PUSHL 8(AP) ;LONG_VALUE ; 1739 PUSHL R2 ;R2 ; PUSHAB 8(R2) ;OUTPUT_SIZE ; PUSHL 4(AP) ;MSG_ADDR ; CALLS #4, G^SYS$FAO ;#4, SYS$FAO ; MOVW 8(R2), (R2) ;OUTPUT_SIZE, OUTPUT_DESC ; 1740 PUSHL R2 ;R2 ; 1741 CALLS #1, G^LIB$PUT_OUTPUT ;#1, LIB$PUT_OUTPUT ; RET ; ; 1689 ; Routine Size: 43 bytes, Routine Base: $CODE$ + 0228 ; 1743 %SBTTL 'Command execution -- COMND_SHOW' ; 1744 ROUTINE COMND_SHOW : NOVALUE = ; 1745 ; 1746 !++ ; 1747 ! FUNCTIONAL DESCRIPTION: ; 1748 ! ; 1749 ! This routine will process the SHOW command. This routine ; 1750 ! expects that the command has already been processed and that ; 1751 ! the type of SHOW command is stored in SHOW_TYPE. ; 1752 ! ; 1753 ! CALLING SEQUENCE: ; 1754 ! ; 1755 ! COMND_SHOW(); ; 1756 ! ; 1757 ! INPUT PARAMETERS: ; 1758 ! ; 1759 ! None. ; 1760 ! ; 1761 ! IMPLICIT INPUTS: ; 1762 ! ; 1763 ! None. ; 1764 ! ; 1765 ! OUTPUT PARAMETERS: ; 1766 ! ; 1767 ! None. ; 1768 ! ; 1769 ! IMPLICIT OUTPUTS: ; 1770 ! ; 1771 ! None. ; 1772 ! ; 1773 ! COMPLETION CODES: ; 1774 ! ; 1775 ! None. ; 1776 ! ; 1777 ! SIDE EFFECTS: ; 1778 ! ; 1779 ! None. ; 1780 ! ; 1781 !-- ; 1782 ; 1783 BEGIN ; 1784 ; 1785 LOCAL ; 1786 STATUS : WORD; ! Status returned ; 1787 ; 1788 ! Bind some addresses to text ; 1789 ; 1790 BIND ; 1791 OFF_TEXT = %ASCID'OFF', ! Item is off ; 1792 ON_TEXT = %ASCID'ON', ! Item is on ; 1793 SHOW_ABT_MSG = %ASCID' Incomplete file disposition !AS', ; 1794 ABT_DISCARD = %ASCID'Discard', ; 1795 ABT_KEEP = %ASCID'Keep', ; 1796 SHOW_CHK_MSG = %ASCID' Block check type !AS', ; 1797 CHK_1CHAR_MSG = %ASCID'One character checksum', ; 1798 CHK_2CHAR_MSG = %ASCID'Two character checksum', ; 1799 CHK_CRC_MSG = %ASCID'Three character CRC-CCITT', ; 1800 SHOW_DEB_MSG = %ASCID' Debugging !AS', ; 1801 SHOW_DEL_MSG = %ASCID' Delay !ZL (sec)', ; 1802 SHOW_ESC_MSG = %ASCID' Escape character !3OL (octal)', ; 1803 SHOW_FTP_MSG = %ASCID' File type !AS', ; 1804 FTP_ASCII = %ASCID'ASCII', ; 1805 FTP_BINARY = %ASCID'BINARY', ; 1806 FTP_BLOCK = %ASCID'BLOCK', ; 1807 SHOW_IBM_MSG = %ASCID' IBM mode !AS', ; 1808 SHOW_LIN_MSG = %ASCID' Line used !AS', ; 1809 SHOW_ECH_MSG = %ASCID' Local echo !AS', ; 1810 SHOW_PAR_MSG = %ASCID' Parity type !AS', ; 1811 PAR_EVEN = %ASCID'Even', ; 1812 PAR_ODD = %ASCID'Odd', ; 1813 PAR_MARK = %ASCID'Mark', ; 1814 PAR_SPACE = %ASCID'Space', ; 1815 PAR_NONE = %ASCID'None', ; 1816 SHOW_RTY_HDR = %ASCID' Retry maximums', ; 1817 SHOW_RTY_INI_MSG = %ASCID' Initial connection !ZL (dec)', ; 1818 SHOW_RTY_PKT_MSG = %ASCID' Sending a packet !ZL (dec)', ; 1819 SHOW_REC_HDR = %ASCID' Receive parameters', ; 1820 SHOW_SND_HDR = %ASCID' Send parameters', ; 1821 SHOW_PKT_MSG = %ASCID' Packet length !ZL (dec)', ; 1822 SHOW_PAD_MSG = %ASCID' Padding length !ZL (dec)', ; 1823 SHOW_PDC_MSG = %ASCID' Padding character !3OL (octal)', ; 1824 SHOW_TIM_MSG = %ASCID' Time out !ZL (sec)', ; 1825 SHOW_EOL_MSG = %ASCID' End of line character !3OL (octal)', ; 1826 SHOW_QUO_MSG = %ASCID' Quoting character !3OL (octal)', ; 1827 SHOW_SOH_MSG = %ASCID' Start of packet !3OL (octal)', ; 1828 SHOW_8QU_MSG = %ASCID' 8-bit quoting character !3OL (octal)', ; 1829 SHOW_RPT_MSG = %ASCID' Repeat quoting character !3OL (octal)'; ; 1830 ; 1831 !++ ; 1832 ! FUNCTIONAL DESCRIPTION: ; 1833 ! ; 1834 ! This routine is used to output the keywords TRUE or FALSE. ; 1835 ! All text that this routine uses is defined in the level 0 BEGIN/END ; 1836 ! of the program. ; 1837 ! ; 1838 ! CALLING SEQUENCE: ; 1839 ! ; 1840 ! OUTPUT_TRUE_FALSE( MSG_ASCID, FLAG_WORD); ; 1841 ! ; 1842 ! INPUT PARAMETERS: ; 1843 ! ; 1844 ! MSG_ASCID - %ASCID of the text to use for the $FAO call. ; 1845 ! ; 1846 ! FLAG_WORD - Long word containing the value of either TRUE or FALSE. ; 1847 ! ; 1848 ! IMPLICIT INPUTS: ; 1849 ! ; 1850 ! None. ; 1851 ! ; 1852 ! OUTPUT PARAMETERS: ; 1853 ! ; 1854 ! None. ; 1855 ! ; 1856 ! IMPLICIT OUTPUTS: ; 1857 ! ; 1858 ! None. ; 1859 ! ; 1860 ! COMPLETION CODES: ; 1861 ! ; 1862 ! None. ; 1863 ! ; 1864 ! SIDE EFFECTS: ; 1865 ! ; 1866 ! None. ; 1867 ! ; 1868 !-- ; 1869 ; 1870 ROUTINE OUTPUT_TRUE_FALSE (MSG_ADDR, FLAG_ADDR) : NOVALUE = ; 1871 BEGIN ; 1872 ; 1873 MAP ; 1874 FLAG_ADDR : LONG UNSIGNED, ; 1875 MSG_ADDR : LONG UNSIGNED; ; 1876 ; 1877 LOCAL ; 1878 STATUS : UNSIGNED; ! Status return by LIB$xxx ; 1879 ; 1880 INIT_DESC (); ; P 1881 $FAO (.MSG_ADDR, OUTPUT_SIZE, OUTPUT_DESC, ; P 1882 (SELECTONE ..FLAG_ADDR OF ; P 1883 SET ; P 1884 [TRUE] : ON_TEXT; ; P 1885 [FALSE] : OFF_TEXT; ; 1886 TES)); ; 1887 OUTPUT_DESC [DSC$W_LENGTH] = .OUTPUT_SIZE; ; 1888 STATUS = LIB$PUT_OUTPUT (OUTPUT_DESC); ; 1889 END; .PSECT $PLIT$,NOWRT,NOEXE,2 P.AAM: .ASCII \OFF\<0> ; ; P.AAL: .LONG 17694723 ; ; .ADDRESS P.AAM ; ; P.AAO: .ASCII \ON\<0><0> ; ; P.AAN: .LONG 17694722 ; ; .ADDRESS P.AAO ; ; P.AAQ: .ASCII \ Incomplete file disposition\<9>\!AS\ ; ; P.AAP: .LONG 17694752 ; ; .ADDRESS P.AAQ ; ; P.AAS: .ASCII \Discard\<0> ; ; P.AAR: .LONG 17694727 ; ; .ADDRESS P.AAS ; ; P.AAU: .ASCII \Keep\ ; ; P.AAT: .LONG 17694724 ; ; .ADDRESS P.AAU ; ; P.AAW: .ASCII \ Block check type\<9><9>\!AS\<0><0> ; ; P.AAV: .LONG 17694742 ; ; .ADDRESS P.AAW ; ; P.AAY: .ASCII \One character checksum\<0><0> ; ; P.AAX: .LONG 17694742 ; ; .ADDRESS P.AAY ; ; P.ABA: .ASCII \Two character checksum\<0><0> ; ; P.AAZ: .LONG 17694742 ; ; .ADDRESS P.ABA ; ; P.ABC: .ASCII \Three character CRC-CCITT\<0><0><0> ; ; P.ABB: .LONG 17694745 ; ; .ADDRESS P.ABC ; ; P.ABE: .ASCII \ Debugging\<9><9><9>\!AS\ ; ; P.ABD: .LONG 17694736 ; ; .ADDRESS P.ABE ; ; P.ABG: .ASCII \ Delay\<9><9><9><9>\!ZL (sec)\<0> ; ; P.ABF: .LONG 17694739 ; ; .ADDRESS P.ABG ; ; P.ABI: .ASCII \ Escape character\<9><9>\!3OL (octal)\<0> ; ; P.ABH: .LONG 17694751 ; ; .ADDRESS P.ABI ; ; P.ABK: .ASCII \ File type\<9><9><9>\!AS\ ; ; P.ABJ: .LONG 17694736 ; ; .ADDRESS P.ABK ; ; P.ABM: .ASCII \ASCII\<0><0><0> ; ; P.ABL: .LONG 17694725 ; ; .ADDRESS P.ABM ; ; P.ABO: .ASCII \BINARY\<0><0> ; ; P.ABN: .LONG 17694726 ; ; .ADDRESS P.ABO ; ; P.ABQ: .ASCII \BLOCK\<0><0><0> ; ; P.ABP: .LONG 17694725 ; ; .ADDRESS P.ABQ ; ; P.ABS: .ASCII \ IBM mode\<9><9><9>\!AS\<0> ; ; P.ABR: .LONG 17694735 ; ; .ADDRESS P.ABS ; ; P.ABU: .ASCII \ Line used\<9><9><9>\!AS\ ; ; P.ABT: .LONG 17694736 ; ; .ADDRESS P.ABU ; ; P.ABW: .ASCII \ Local echo\<9><9><9>\!AS\<0><0><0> ; ; P.ABV: .LONG 17694737 ; ; .ADDRESS P.ABW ; ; P.ABY: .ASCII \ Parity type\<9><9><9>\!AS\<0><0> ; ; P.ABX: .LONG 17694738 ; ; .ADDRESS P.ABY ; ; P.ACA: .ASCII \Even\ ; ; P.ABZ: .LONG 17694724 ; ; .ADDRESS P.ACA ; ; P.ACC: .ASCII \Odd\<0> ; ; P.ACB: .LONG 17694723 ; ; .ADDRESS P.ACC ; ; P.ACE: .ASCII \Mark\ ; ; P.ACD: .LONG 17694724 ; ; .ADDRESS P.ACE ; ; P.ACG: .ASCII \Space\<0><0><0> ; ; P.ACF: .LONG 17694725 ; ; .ADDRESS P.ACG ; ; P.ACI: .ASCII \None\ ; ; P.ACH: .LONG 17694724 ; ; .ADDRESS P.ACI ; ; P.ACK: .ASCII \ Retry maximums\<0> ; ; P.ACJ: .LONG 17694735 ; ; .ADDRESS P.ACK ; ; P.ACM: .ASCII \ Initial connection\<9><9>\!ZL (dec)\<0> ; ; P.ACL: .LONG 17694751 ; ; .ADDRESS P.ACM ; ; P.ACO: .ASCII \ Sending a packet\<9><9>\!ZL (dec)\<0><0><0> ; ; P.ACN: .LONG 17694749 ; ; .ADDRESS P.ACO ; ; P.ACQ: .ASCII \ Receive parameters\<0> ; ; P.ACP: .LONG 17694739 ; ; .ADDRESS P.ACQ ; ; P.ACS: .ASCII \ Send parameters\ ; ; P.ACR: .LONG 17694736 ; ; .ADDRESS P.ACS ; ; P.ACU: .ASCII \ Packet length\<9><9><9>\!ZL (dec)\<0> ; ; P.ACT: .LONG 17694747 ; ; .ADDRESS P.ACU ; ; P.ACW: .ASCII \ Padding length\<9><9>\!ZL (dec)\<0> ; ; P.ACV: .LONG 17694747 ; ; .ADDRESS P.ACW ; ; P.ACY: .ASCII \ Padding character\<9><9>\!3OL (octal)\<0><0><0> ; ; P.ACX: .LONG 17694753 ; ; .ADDRESS P.ACY ; ; P.ADA: .ASCII \ Time out\<9><9><9>\!ZL (sec)\<0><0> ; ; P.ACZ: .LONG 17694742 ; ; .ADDRESS P.ADA ; ; P.ADC: .ASCII \ End of line character\<9><9>\!3OL (octal)\<0><0><0> ; ; P.ADB: .LONG 17694757 ; ; .ADDRESS P.ADC ; ; P.ADE: .ASCII \ Quoting character\<9><9>\!3OL (octal)\<0><0><0> ; ; P.ADD: .LONG 17694753 ; ; .ADDRESS P.ADE ; ; P.ADG: .ASCII \ Start of packet\<9><9>\!3OL (octal)\<0> ; ; P.ADF: .LONG 17694751 ; ; .ADDRESS P.ADG ; ; P.ADI: .ASCII \ 8-bit quoting character\<9>\!3OL (octal)\<0><0> ; ; P.ADH: .LONG 17694758 ; ; .ADDRESS P.ADI ; ; P.ADK: .ASCII \ Repeat quoting character\<9>\!3OL (octal)\<0><0> ; ; P.ADJ: .LONG 17694758 ; ; .ADDRESS P.ADK ; ; OFF_TEXT= P.AAL ON_TEXT= P.AAN SHOW_ABT_MSG= P.AAP ABT_DISCARD= P.AAR ABT_KEEP= P.AAT SHOW_CHK_MSG= P.AAV CHK_1CHAR_MSG= P.AAX CHK_2CHAR_MSG= P.AAZ CHK_CRC_MSG= P.ABB SHOW_DEB_MSG= P.ABD SHOW_DEL_MSG= P.ABF SHOW_ESC_MSG= P.ABH SHOW_FTP_MSG= P.ABJ FTP_ASCII= P.ABL FTP_BINARY= P.ABN FTP_BLOCK= P.ABP SHOW_IBM_MSG= P.ABR SHOW_LIN_MSG= P.ABT SHOW_ECH_MSG= P.ABV SHOW_PAR_MSG= P.ABX PAR_EVEN= P.ABZ PAR_ODD= P.ACB PAR_MARK= P.ACD PAR_SPACE= P.ACF PAR_NONE= P.ACH SHOW_RTY_HDR= P.ACJ SHOW_RTY_INI_MSG= P.ACL SHOW_RTY_PKT_MSG= P.ACN SHOW_REC_HDR= P.ACP SHOW_SND_HDR= P.ACR SHOW_PKT_MSG= P.ACT SHOW_PAD_MSG= P.ACV SHOW_PDC_MSG= P.ACX SHOW_TIM_MSG= P.ACZ SHOW_EOL_MSG= P.ADB SHOW_QUO_MSG= P.ADD SHOW_SOH_MSG= P.ADF SHOW_8QU_MSG= P.ADH SHOW_RPT_MSG= P.ADJ .PSECT $CODE$,NOWRT,2 OUTPUT_TRUE_FALSE: .WORD ^M ;Save R2 ; 1870 MOVAB W^U.32, R2 ;U.32, R2 ; CALLS #0, B^INIT_DESC ;#0, INIT_DESC ; 1880 MOVL @8(AP), R1 ;@FLAG_ADDR, R1 ; 1886 CMPL R1, #1 ;R1, #1 ; BNEQ 1$ ;1$ ; MOVAB W^ON_TEXT, R0 ;ON_TEXT, R0 ; BRB 3$ ;3$ ; 1$: TSTL R1 ;R1 ; BEQL 2$ ;2$ ; MNEGL #1, -(SP) ;#1, -(SP) ; BRB 4$ ;4$ ; 2$: MOVAB W^OFF_TEXT, R0 ;OFF_TEXT, R0 ; 3$: PUSHL R0 ;R0 ; 4$: PUSHL R2 ;R2 ; PUSHAB 8(R2) ;OUTPUT_SIZE ; PUSHL 4(AP) ;MSG_ADDR ; CALLS #4, G^SYS$FAO ;#4, SYS$FAO ; MOVW 8(R2), (R2) ;OUTPUT_SIZE, OUTPUT_DESC ; 1887 PUSHL R2 ;R2 ; 1888 CALLS #1, G^LIB$PUT_OUTPUT ;#1, LIB$PUT_OUTPUT ; RET ; ; 1870 ; Routine Size: 72 bytes, Routine Base: $CODE$ + 0253 ; 1890 ; 1891 SELECT .SHOW_TYPE OF ; 1892 SET ; 1893 ; 1894 ; 1895 [SHOW_ALL, SHOW_CHK, SHOW_PAC] : ; 1896 BEGIN ; 1897 INIT_DESC (); ; P 1898 $FAO (SHOW_CHK_MSG, OUTPUT_SIZE, OUTPUT_DESC, ; P 1899 (SELECTONE .CHKTYPE OF ; P 1900 SET ; P 1901 [CHK_1CHAR] : CHK_1CHAR_MSG; ; P 1902 [CHK_2CHAR] : CHK_2CHAR_MSG; ; P 1903 [CHK_CRC] : CHK_CRC_MSG; ; 1904 TES)); ; 1905 OUTPUT_DESC [DSC$W_LENGTH] = .OUTPUT_SIZE; ; 1906 STATUS = LIB$PUT_OUTPUT (OUTPUT_DESC); ; 1907 END; ; 1908 ; 1909 [SHOW_ALL, SHOW_DEB] : ; 1910 OUTPUT_TRUE_FALSE (SHOW_DEB_MSG, DEBUG_FLAG); ; 1911 ; 1912 [SHOW_ALL, SHOW_DEL, SHOW_COM] : ; 1913 OUTPUT_LONG_WORD (SHOW_DEL_MSG, .DELAY); ; 1914 ; 1915 [SHOW_ALL, SHOW_ESC, SHOW_COM] : ; 1916 OUTPUT_LONG_WORD (SHOW_ESC_MSG, .ESCAPE_CHR); ; 1917 ; 1918 [SHOW_ALL, SHOW_FTP, SHOW_FIL] : ; 1919 BEGIN ; 1920 INIT_DESC (); ; P 1921 $FAO (SHOW_FTP_MSG, OUTPUT_SIZE, OUTPUT_DESC, ; P 1922 (SELECTONE .FILE_TYPE OF ; P 1923 SET ; P 1924 [FILE_ASC] : FTP_ASCII; ; P 1925 [FILE_BIN] : FTP_BINARY; ; P 1926 [FILE_BLK] : FTP_BLOCK; ; 1927 TES)); ; 1928 OUTPUT_DESC [DSC$W_LENGTH] = .OUTPUT_SIZE; ; 1929 STATUS = LIB$PUT_OUTPUT (OUTPUT_DESC); ; 1930 END; ; 1931 ; 1932 [SHOW_ALL, SHOW_COM] : ; 1933 OUTPUT_TRUE_FALSE (SHOW_IBM_MSG, IBM_FLAG); ; 1934 ; 1935 [SHOW_ALL, SHOW_ABT, SHOW_FIL] : ; 1936 BEGIN ; 1937 INIT_DESC (); ; P 1938 $FAO (SHOW_ABT_MSG, OUTPUT_SIZE, OUTPUT_DESC, ; 1939 (IF .ABT_FLAG THEN ABT_DISCARD ELSE ABT_KEEP)); ; 1940 OUTPUT_DESC [DSC$W_LENGTH] = .OUTPUT_SIZE; ; 1941 STATUS = LIB$PUT_OUTPUT (OUTPUT_DESC); ; 1942 END; ; 1943 ; 1944 [SHOW_ALL, SHOW_LIN, SHOW_COM] : ; 1945 BEGIN ; 1946 INIT_DESC (); ; 1947 $FAO (SHOW_LIN_MSG, OUTPUT_SIZE, OUTPUT_DESC, TERM_DESC); ; 1948 OUTPUT_DESC [DSC$W_LENGTH] = .OUTPUT_SIZE; ; 1949 STATUS = LIB$PUT_OUTPUT (OUTPUT_DESC); ; 1950 END; ; 1951 ; 1952 [SHOW_ALL, SHOW_ECH, SHOW_COM] : ; 1953 OUTPUT_TRUE_FALSE (SHOW_ECH_MSG, ECHO_FLAG); ; 1954 ; 1955 [SHOW_ALL, SHOW_PAR, SHOW_COM] : ; 1956 BEGIN ; 1957 INIT_DESC (); ; P 1958 $FAO (SHOW_PAR_MSG, OUTPUT_SIZE, OUTPUT_DESC, ; P 1959 (SELECTONE .PARITY_TYPE OF ; P 1960 SET ; P 1961 [PR_EVEN] : PAR_EVEN; ; P 1962 [PR_ODD] : PAR_ODD; ; P 1963 [PR_NONE] : PAR_NONE; ; P 1964 [PR_MARK] : PAR_MARK; ; P 1965 [PR_SPACE] : PAR_SPACE; ; 1966 TES)); ; 1967 OUTPUT_DESC [DSC$W_LENGTH] = .OUTPUT_SIZE; ; 1968 STATUS = LIB$PUT_OUTPUT (OUTPUT_DESC); ; 1969 END; ; 1970 ; 1971 [SHOW_ALL, SHOW_RTY, SHOW_PAC] : ; 1972 BEGIN ; 1973 STATUS = LIB$PUT_OUTPUT (SHOW_RTY_HDR); ; 1974 OUTPUT_LONG_WORD (SHOW_RTY_INI_MSG, .SI_RETRIES); ; 1975 OUTPUT_LONG_WORD (SHOW_RTY_PKT_MSG, .PKT_RETRIES); ; 1976 END; ; 1977 ; 1978 [SHOW_ALL, SHOW_SEN, SHOW_PAC] : ; 1979 BEGIN ; 1980 STATUS = LIB$PUT_OUTPUT (SHOW_SND_HDR); ; 1981 OUTPUT_LONG_WORD (SHOW_PKT_MSG, ABS (.SND_PKT_SIZE)); ; 1982 OUTPUT_LONG_WORD (SHOW_PAD_MSG, ABS (.SND_NPAD)); ; 1983 OUTPUT_LONG_WORD (SHOW_PDC_MSG, ABS (.SND_PADCHAR)); ; 1984 OUTPUT_LONG_WORD (SHOW_TIM_MSG, ABS (.SND_TIMEOUT)); ; 1985 OUTPUT_LONG_WORD (SHOW_EOL_MSG, ABS (.SND_EOL)); ; 1986 OUTPUT_LONG_WORD (SHOW_QUO_MSG, ABS (.SND_QUOTE_CHR)); ; 1987 OUTPUT_LONG_WORD (SHOW_SOH_MSG, ABS (.SND_SOH)); ; 1988 END; ; 1989 ; 1990 [SHOW_ALL, SHOW_REC, SHOW_PAC] : ; 1991 BEGIN ; 1992 STATUS = LIB$PUT_OUTPUT (SHOW_REC_HDR); ; 1993 OUTPUT_LONG_WORD (SHOW_PKT_MSG, .RCV_PKT_SIZE); ; 1994 OUTPUT_LONG_WORD (SHOW_PAD_MSG, .RCV_NPAD); ; 1995 OUTPUT_LONG_WORD (SHOW_PDC_MSG, .RCV_PADCHAR); ; 1996 OUTPUT_LONG_WORD (SHOW_TIM_MSG, .RCV_TIMEOUT); ; 1997 OUTPUT_LONG_WORD (SHOW_EOL_MSG, .RCV_EOL); ; 1998 OUTPUT_LONG_WORD (SHOW_QUO_MSG, .RCV_QUOTE_CHR); ; 1999 OUTPUT_LONG_WORD (SHOW_8QU_MSG, .RCV_8QUOTE_CHR); ; 2000 OUTPUT_LONG_WORD (SHOW_SOH_MSG, .RCV_SOH); ; 2001 END; ; 2002 ; 2003 [SHOW_ALL, SHOW_PAC] : ; 2004 BEGIN ; 2005 OUTPUT_LONG_WORD (SHOW_RPT_MSG, .SET_REPT_CHR); ; 2006 END; ; 2007 TES; ; 2008 ; 2009 END; ! End of COMND_SHOW ;COMND_SHOW U.3: .WORD ^M ;Save R2,R3,R4,R5,R6,R7,R8 ; 1744 MOVAB G^SYS$FAO, R8 ;SYS$FAO, R8 ; MOVAB G^LIB$PUT_OUTPUT, R7 ;LIB$PUT_OUTPUT, R7 ; MOVAB W^U.32, R6 ;U.32, R6 ; MOVAB W^OUTPUT_LONG_WORD, R5 ;OUTPUT_LONG_WORD, R5 ; MOVAB W^SHOW_PKT_MSG, R4 ;SHOW_PKT_MSG, R4 ; MOVL -84(R6), R2 ;SHOW_TYPE, R2 ; 1891 CMPL R2, #1 ;R2, #1 ; BEQL 1$ ;1$ ; CMPL R2, #12 ;R2, #12 ; BEQL 1$ ;1$ ; CMPL R2, #15 ;R2, #15 ; BNEQ 7$ ;7$ ; 1$: CALLS #0, -19(R5) ;#0, INIT_DESC ; 1897 MOVL W^CHKTYPE, R0 ;CHKTYPE, R0 ; 1904 CMPL R0, #49 ;R0, #49 ; BNEQ 2$ ;2$ ; MOVAB -592(R4), R1 ;CHK_1CHAR_MSG, R1 ; BRB 3$ ;3$ ; 2$: CMPL R0, #50 ;R0, #50 ; BNEQ 4$ ;4$ ; MOVAB -560(R4), R1 ;CHK_2CHAR_MSG, R1 ; 3$: PUSHL R1 ;R1 ; BRB 6$ ;6$ ; 4$: CMPL R0, #51 ;R0, #51 ; BEQL 5$ ;5$ ; MNEGL #1, -(SP) ;#1, -(SP) ; BRB 6$ ;6$ ; 5$: MOVAB -524(R4), R0 ;CHK_CRC_MSG, R0 ; PUSHL R0 ;R0 ; 6$: PUSHL R6 ;R6 ; PUSHAB 8(R6) ;OUTPUT_SIZE ; PUSHAB -624(R4) ;SHOW_CHK_MSG ; CALLS #4, (R8) ;#4, SYS$FAO ; MOVW 8(R6), (R6) ;OUTPUT_SIZE, OUTPUT_DESC ; 1905 PUSHL R6 ;R6 ; 1906 CALLS #1, (R7) ;#1, LIB$PUT_OUTPUT ; MOVW R0, R3 ;R0, STATUS ; 7$: TSTL R2 ;R2 ; 1891 BLEQ 8$ ;8$ ; CMPL R2, #2 ;R2, #2 ; BGTR 8$ ;8$ ; PUSHAB W^DEBUG_FLAG ;DEBUG_FLAG ; 1910 PUSHAB -500(R4) ;SHOW_DEB_MSG ; CALLS #2, 43(R5) ;#2, OUTPUT_TRUE_FALSE ; 8$: CMPL R2, #1 ;R2, #1 ; 1891 BEQL 9$ ;9$ ; CMPL R2, #3 ;R2, #3 ; BEQL 9$ ;9$ ; CMPL R2, #16 ;R2, #16 ; BNEQ 10$ ;10$ ; 9$: PUSHL W^DELAY ;DELAY ; 1913 PUSHAB -472(R4) ;SHOW_DEL_MSG ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; 10$: CMPL R2, #1 ;R2, #1 ; 1891 BEQL 11$ ;11$ ; CMPL R2, #4 ;R2, #4 ; BEQL 11$ ;11$ ; CMPL R2, #16 ;R2, #16 ; BNEQ 12$ ;12$ ; 11$: PUSHL W^ESCAPE_CHR ;ESCAPE_CHR ; 1916 PUSHAB -432(R4) ;SHOW_ESC_MSG ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; 12$: CMPL R2, #1 ;R2, #1 ; 1891 BEQL 13$ ;13$ ; CMPL R2, #5 ;R2, #5 ; BEQL 13$ ;13$ ; CMPL R2, #14 ;R2, #14 ; BNEQ 19$ ;19$ ; 13$: CALLS #0, -19(R5) ;#0, INIT_DESC ; 1920 MOVL W^FILE_TYPE, R0 ;FILE_TYPE, R0 ; 1927 CMPL R0, #1 ;R0, #1 ; BNEQ 14$ ;14$ ; MOVAB -392(R4), R1 ;FTP_ASCII, R1 ; BRB 15$ ;15$ ; 14$: CMPL R0, #2 ;R0, #2 ; BNEQ 16$ ;16$ ; MOVAB -376(R4), R1 ;FTP_BINARY, R1 ; 15$: PUSHL R1 ;R1 ; BRB 18$ ;18$ ; 16$: CMPL R0, #3 ;R0, #3 ; BEQL 17$ ;17$ ; MNEGL #1, -(SP) ;#1, -(SP) ; BRB 18$ ;18$ ; 17$: MOVAB -360(R4), R0 ;FTP_BLOCK, R0 ; PUSHL R0 ;R0 ; 18$: PUSHL R6 ;R6 ; PUSHAB 8(R6) ;OUTPUT_SIZE ; PUSHAB -408(R4) ;SHOW_FTP_MSG ; CALLS #4, (R8) ;#4, SYS$FAO ; MOVW 8(R6), (R6) ;OUTPUT_SIZE, OUTPUT_DESC ; 1928 PUSHL R6 ;R6 ; 1929 CALLS #1, (R7) ;#1, LIB$PUT_OUTPUT ; MOVW R0, R3 ;R0, STATUS ; 19$: CMPL R2, #1 ;R2, #1 ; 1891 BEQL 20$ ;20$ ; CMPL R2, #16 ;R2, #16 ; BNEQ 21$ ;21$ ; 20$: PUSHAB W^IBM_FLAG ;IBM_FLAG ; 1933 PUSHAB -336(R4) ;SHOW_IBM_MSG ; CALLS #2, 43(R5) ;#2, OUTPUT_TRUE_FALSE ; 21$: CMPL R2, #1 ;R2, #1 ; 1891 BEQL 22$ ;22$ ; CMPL R2, #13 ;R2, #13 ; BLSS 25$ ;25$ ; CMPL R2, #14 ;R2, #14 ; BGTR 25$ ;25$ ; 22$: CALLS #0, -19(R5) ;#0, INIT_DESC ; 1937 BLBC W^ABT_FLAG, 23$ ;ABT_FLAG, 23$ ; 1939 MOVAB -668(R4), R0 ;ABT_DISCARD, R0 ; BRB 24$ ;24$ ; 23$: MOVAB -656(R4), R0 ;ABT_KEEP, R0 ; 24$: PUSHL R0 ;R0 ; PUSHL R6 ;R6 ; PUSHAB 8(R6) ;OUTPUT_SIZE ; PUSHAB -684(R4) ;SHOW_ABT_MSG ; CALLS #4, (R8) ;#4, SYS$FAO ; MOVW 8(R6), (R6) ;OUTPUT_SIZE, OUTPUT_DESC ; 1940 PUSHL R6 ;R6 ; 1941 CALLS #1, (R7) ;#1, LIB$PUT_OUTPUT ; MOVW R0, R3 ;R0, STATUS ; 25$: CMPL R2, #1 ;R2, #1 ; 1891 BEQL 26$ ;26$ ; CMPL R2, #6 ;R2, #6 ; BEQL 26$ ;26$ ; CMPL R2, #16 ;R2, #16 ; BNEQ 27$ ;27$ ; 26$: CALLS #0, -19(R5) ;#0, INIT_DESC ; 1946 PUSHAB W^TERM_DESC ;TERM_DESC ; 1947 PUSHL R6 ;R6 ; PUSHAB 8(R6) ;OUTPUT_SIZE ; PUSHAB -312(R4) ;SHOW_LIN_MSG ; CALLS #4, (R8) ;#4, SYS$FAO ; MOVW 8(R6), (R6) ;OUTPUT_SIZE, OUTPUT_DESC ; 1948 PUSHL R6 ;R6 ; 1949 CALLS #1, (R7) ;#1, LIB$PUT_OUTPUT ; MOVW R0, R3 ;R0, STATUS ; 27$: CMPL R2, #1 ;R2, #1 ; 1891 BEQL 28$ ;28$ ; CMPL R2, #7 ;R2, #7 ; BEQL 28$ ;28$ ; CMPL R2, #16 ;R2, #16 ; BNEQ 29$ ;29$ ; 28$: PUSHAB W^ECHO_FLAG ;ECHO_FLAG ; 1953 PUSHAB -284(R4) ;SHOW_ECH_MSG ; CALLS #2, 43(R5) ;#2, OUTPUT_TRUE_FALSE ; 29$: CMPL R2, #1 ;R2, #1 ; 1891 BEQL 30$ ;30$ ; CMPL R2, #10 ;R2, #10 ; BEQL 30$ ;30$ ; CMPL R2, #16 ;R2, #16 ; BNEQ 38$ ;38$ ; 30$: CALLS #0, -19(R5) ;#0, INIT_DESC ; 1957 MOVL W^PARITY_TYPE, R0 ;PARITY_TYPE, R0 ; 1966 CMPL R0, #2 ;R0, #2 ; BNEQ 31$ ;31$ ; MOVAB -244(R4), R1 ;PAR_EVEN, R1 ; BRB 34$ ;34$ ; 31$: CMPL R0, #3 ;R0, #3 ; BNEQ 32$ ;32$ ; MOVAB -232(R4), R1 ;PAR_ODD, R1 ; BRB 34$ ;34$ ; 32$: TSTL R0 ;R0 ; BNEQ 33$ ;33$ ; MOVAB -192(R4), R1 ;PAR_NONE, R1 ; BRB 34$ ;34$ ; 33$: CMPL R0, #1 ;R0, #1 ; BNEQ 35$ ;35$ ; MOVAB -220(R4), R1 ;PAR_MARK, R1 ; 34$: PUSHL R1 ;R1 ; BRB 37$ ;37$ ; 35$: CMPL R0, #4 ;R0, #4 ; BEQL 36$ ;36$ ; MNEGL #1, -(SP) ;#1, -(SP) ; BRB 37$ ;37$ ; 36$: MOVAB -204(R4), R0 ;PAR_SPACE, R0 ; PUSHL R0 ;R0 ; 37$: PUSHL R6 ;R6 ; PUSHAB 8(R6) ;OUTPUT_SIZE ; PUSHAB -256(R4) ;SHOW_PAR_MSG ; CALLS #4, (R8) ;#4, SYS$FAO ; MOVW 8(R6), (R6) ;OUTPUT_SIZE, OUTPUT_DESC ; 1967 PUSHL R6 ;R6 ; 1968 CALLS #1, (R7) ;#1, LIB$PUT_OUTPUT ; MOVW R0, R3 ;R0, STATUS ; 38$: CMPL R2, #1 ;R2, #1 ; 1891 BEQL 39$ ;39$ ; CMPL R2, #11 ;R2, #11 ; BEQL 39$ ;39$ ; CMPL R2, #15 ;R2, #15 ; BNEQ 40$ ;40$ ; 39$: PUSHAB -168(R4) ;SHOW_RTY_HDR ; 1973 CALLS #1, (R7) ;#1, LIB$PUT_OUTPUT ; MOVW R0, R3 ;R0, STATUS ; PUSHL W^SI_RETRIES ;SI_RETRIES ; 1974 PUSHAB -128(R4) ;SHOW_RTY_INI_MSG ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHL W^PKT_RETRIES ;PKT_RETRIES ; 1975 PUSHAB -88(R4) ;SHOW_RTY_PKT_MSG ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; 40$: CMPL R2, #1 ;R2, #1 ; 1891 BEQL 41$ ;41$ ; CMPL R2, #8 ;R2, #8 ; BEQL 41$ ;41$ ; CMPL R2, #15 ;R2, #15 ; BNEQ 49$ ;49$ ; 41$: PUSHAB -36(R4) ;SHOW_SND_HDR ; 1980 CALLS #1, (R7) ;#1, LIB$PUT_OUTPUT ; MOVW R0, R3 ;R0, STATUS ; PUSHL W^SND_PKT_SIZE ;SND_PKT_SIZE ; 1981 BGEQ 42$ ;42$ ; MNEGL (SP), (SP) ;(SP), (SP) ; 42$: PUSHL R4 ;R4 ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHL W^SND_NPAD ;SND_NPAD ; 1982 BGEQ 43$ ;43$ ; MNEGL (SP), (SP) ;(SP), (SP) ; 43$: PUSHAB 36(R4) ;SHOW_PAD_MSG ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHL W^SND_PADCHAR ;SND_PADCHAR ; 1983 BGEQ 44$ ;44$ ; MNEGL (SP), (SP) ;(SP), (SP) ; 44$: PUSHAB 80(R4) ;SHOW_PDC_MSG ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHL W^SND_TIMEOUT ;SND_TIMEOUT ; 1984 BGEQ 45$ ;45$ ; MNEGL (SP), (SP) ;(SP), (SP) ; 45$: PUSHAB 112(R4) ;SHOW_TIM_MSG ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHL W^SND_EOL ;SND_EOL ; 1985 BGEQ 46$ ;46$ ; MNEGL (SP), (SP) ;(SP), (SP) ; 46$: PUSHAB 160(R4) ;SHOW_EOL_MSG ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHL W^SND_QUOTE_CHR ;SND_QUOTE_CHR ; 1986 BGEQ 47$ ;47$ ; MNEGL (SP), (SP) ;(SP), (SP) ; 47$: PUSHAB 204(R4) ;SHOW_QUO_MSG ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHL W^SND_SOH ;SND_SOH ; 1987 BGEQ 48$ ;48$ ; MNEGL (SP), (SP) ;(SP), (SP) ; 48$: PUSHAB 244(R4) ;SHOW_SOH_MSG ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; 49$: CMPL R2, #1 ;R2, #1 ; 1891 BEQL 50$ ;50$ ; CMPL R2, #9 ;R2, #9 ; BEQL 50$ ;50$ ; CMPL R2, #15 ;R2, #15 ; BNEQ 51$ ;51$ ; 50$: PUSHAB -60(R4) ;SHOW_REC_HDR ; 1992 CALLS #1, (R7) ;#1, LIB$PUT_OUTPUT ; MOVW R0, R3 ;R0, STATUS ; PUSHL W^RCV_PKT_SIZE ;RCV_PKT_SIZE ; 1993 PUSHL R4 ;R4 ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHL W^RCV_NPAD ;RCV_NPAD ; 1994 PUSHAB 36(R4) ;SHOW_PAD_MSG ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHL W^RCV_PADCHAR ;RCV_PADCHAR ; 1995 PUSHAB 80(R4) ;SHOW_PDC_MSG ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHL W^RCV_TIMEOUT ;RCV_TIMEOUT ; 1996 PUSHAB 112(R4) ;SHOW_TIM_MSG ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHL W^RCV_EOL ;RCV_EOL ; 1997 PUSHAB 160(R4) ;SHOW_EOL_MSG ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHL W^RCV_QUOTE_CHR ;RCV_QUOTE_CHR ; 1998 PUSHAB 204(R4) ;SHOW_QUO_MSG ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHL W^RCV_8QUOTE_CHR ;RCV_8QUOTE_CHR ; 1999 PUSHAB 292(R4) ;SHOW_8QU_MSG ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHL W^RCV_SOH ;RCV_SOH ; 2000 PUSHAB 244(R4) ;SHOW_SOH_MSG ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; 51$: CMPL R2, #1 ;R2, #1 ; 1891 BEQL 52$ ;52$ ; CMPL R2, #15 ;R2, #15 ; BNEQ 53$ ;53$ ; 52$: PUSHL W^SET_REPT_CHR ;SET_REPT_CHR ; 2005 PUSHAB 340(R4) ;SHOW_RPT_MSG ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; 53$: RET ; ; 1744 ; Routine Size: 867 bytes, Routine Base: $CODE$ + 029B ; 2010 %SBTTL 'Command execution -- COMND_STATUS' ; 2011 ROUTINE COMND_STATUS : NOVALUE = ; 2012 ; 2013 !++ ; 2014 ! FUNCTIONAL DESCRIPTION: ; 2015 ! ; 2016 ! This routine will display the status of Kermit-32. ; 2017 ! ; 2018 ! CALLING SEQUENCE: ; 2019 ! ; 2020 ! COMND_STATUS (); ; 2021 ! ; 2022 ! INPUT PARAMETERS: ; 2023 ! ; 2024 ! None. ; 2025 ! ; 2026 ! IMPLICIT INPUTS: ; 2027 ! ; 2028 ! None. ; 2029 ! ; 2030 ! OUTPUT PARAMETERS: ; 2031 ! ; 2032 ! None. ; 2033 ! ; 2034 ! IMPLICIT OUTPUTS: ; 2035 ! ; 2036 ! None. ; 2037 ! ; 2038 ! COMPLETION CODES: ; 2039 ! ; 2040 ! None. ; 2041 ! ; 2042 ! SIDE EFFECTS: ; 2043 ! ; 2044 ! None. ; 2045 ! ; 2046 !-- ; 2047 ; 2048 BEGIN ; 2049 ; 2050 LOCAL ; 2051 STATUS, ! Status returned by system call ; 2052 POINTER, ! Pointer to the LAST_ERROR text ; 2053 CHAR_COUNT; ! Character count ; 2054 ; 2055 BIND ; 2056 TEXT_CR = %ASCID'', ; 2057 TEXT_BAUD = %ASCID' Effective data rate !ZL baud', ; 2058 TEXT_NAKS_SENT = %ASCID' NAKs received !ZL', ; 2059 TEXT_NAKS_RCV = %ASCID' NAKs sent !ZL', ; 2060 TEXT_PKTS_SENT = %ASCID' Packets sent !ZL', ; 2061 TEXT_PKTS_RCV = %ASCID' Packets received !ZL', ; 2062 TEXT_CHR_SENT = %ASCID' Characters sent !ZL', ; 2063 TEXT_DATA_CHAR_SENT = %ASCID' Data characters sent !ZL', ; 2064 TEXT_DATA_CHAR_RCV = %ASCID' Data characters received !ZL', ; 2065 TEXT_CHR_RCV = %ASCID' Characters received !ZL', ; 2066 TEXT_TOTAL_HDR = %ASCID'Totals since Kermit was started', ; 2067 TEXT_XFR_HDR = %ASCID'Totals for the last transfer'; ; 2068 ; 2069 STATUS = LIB$PUT_OUTPUT (TEXT_CR); ; 2070 STATUS = LIB$PUT_OUTPUT (TEXT_TOTAL_HDR); ; 2071 OUTPUT_LONG_WORD (TEXT_CHR_SENT, .SMSG_TOTAL_CHARS); ; 2072 OUTPUT_LONG_WORD (TEXT_DATA_CHAR_SENT, .SMSG_DATA_CHARS); ; 2073 OUTPUT_LONG_WORD (TEXT_NAKS_SENT, .SMSG_NAKS); ; 2074 OUTPUT_LONG_WORD (TEXT_CHR_RCV, .RMSG_TOTAL_CHARS); ; 2075 OUTPUT_LONG_WORD (TEXT_DATA_CHAR_RCV, .RMSG_DATA_CHARS); ; 2076 OUTPUT_LONG_WORD (TEXT_NAKS_RCV, .RMSG_NAKS); ; 2077 ; 2078 IF .XFR_TIME NEQ 0 ; 2079 THEN ; 2080 OUTPUT_LONG_WORD (TEXT_BAUD, ; 2081 (((IF .RMSG_DATA_CHARS LEQ .SMSG_DATA_CHARS THEN .SMSG_DATA_CHARS ELSE .RMSG_DATA_CHARS)*10)/(( ; 2082 .XFR_TIME + 500)/1000))); ; 2083 ; 2084 STATUS = LIB$PUT_OUTPUT (TEXT_CR); ; 2085 STATUS = LIB$PUT_OUTPUT (TEXT_XFR_HDR); ; 2086 OUTPUT_LONG_WORD (TEXT_CHR_SENT, .SND_TOTAL_CHARS); ; 2087 OUTPUT_LONG_WORD (TEXT_DATA_CHAR_SENT, .SND_DATA_CHARS); ; 2088 OUTPUT_LONG_WORD (TEXT_NAKS_SENT, .SND_NAKS); ; 2089 OUTPUT_LONG_WORD (TEXT_PKTS_SENT, .SND_COUNT); ; 2090 OUTPUT_LONG_WORD (TEXT_CHR_RCV, .RCV_TOTAL_CHARS); ; 2091 OUTPUT_LONG_WORD (TEXT_DATA_CHAR_RCV, .RCV_DATA_CHARS); ; 2092 OUTPUT_LONG_WORD (TEXT_NAKS_RCV, .RCV_NAKS); ; 2093 OUTPUT_LONG_WORD (TEXT_PKTS_RCV, .RCV_COUNT); ; 2094 ; 2095 IF .TOTAL_TIME NEQ 0 ; 2096 THEN ; 2097 OUTPUT_LONG_WORD (TEXT_BAUD, ; 2098 (((.RCV_DATA_CHARS + .SND_DATA_CHARS)*10)/((.TOTAL_TIME + 500)/1000))); ; 2099 ; 2100 ! ; 2101 ! Output the error text if there is any ; 2102 ! ; 2103 POINTER = CH$PTR (LAST_ERROR); ; 2104 CHAR_COUNT = 0; ; 2105 ; 2106 WHILE CH$RCHAR_A (POINTER) NEQ CHR_NUL DO ; 2107 CHAR_COUNT = .CHAR_COUNT + 1; ; 2108 ; 2109 IF .CHAR_COUNT NEQ 0 ; 2110 THEN ; 2111 BEGIN ; 2112 INIT_DESC (); ; 2113 STATUS = $FAO (%ASCID'Last error: !AD', OUTPUT_SIZE, OUTPUT_DESC, .CHAR_COUNT, LAST_ERROR); ; 2114 ; 2115 IF NOT .STATUS ; 2116 THEN ; 2117 LIB$SIGNAL (.STATUS) ; 2118 ELSE ; 2119 BEGIN ; 2120 OUTPUT_DESC [DSC$W_LENGTH] = .OUTPUT_SIZE; ; 2121 STATUS = LIB$PUT_OUTPUT (OUTPUT_DESC); ; 2122 ; 2123 IF NOT .STATUS THEN LIB$SIGNAL (.STATUS); ; 2124 ; 2125 END; ; 2126 ; 2127 END; ; 2128 ; 2129 END; ! End of SHOW_STATUS .PSECT $PLIT$,NOWRT,NOEXE,2 P.ADM: .BLKB 0 ; ; P.ADL: .LONG 17694720 ; ; .ADDRESS P.ADM ; ; P.ADO: .ASCII \ Effective data rate\<9>\!ZL baud\<0><0><0> ; ; P.ADN: .LONG 17694749 ; ; .ADDRESS P.ADO ; ; P.ADQ: .ASCII \ NAKs received\<9><9>\!ZL\<0> ; ; P.ADP: .LONG 17694739 ; ; .ADDRESS P.ADQ ; ; P.ADS: .ASCII \ NAKs sent\<9><9>\!ZL\<0> ; ; P.ADR: .LONG 17694735 ; ; .ADDRESS P.ADS ; ; P.ADU: .ASCII \ Packets sent\<9><9>\!ZL\<0><0> ; ; P.ADT: .LONG 17694738 ; ; .ADDRESS P.ADU ; ; P.ADW: .ASCII \ Packets received\<9>\!ZL\<0><0><0> ; ; P.ADV: .LONG 17694741 ; ; .ADDRESS P.ADW ; ; P.ADY: .ASCII \ Characters sent\<9>\!ZL\ ; ; P.ADX: .LONG 17694740 ; ; .ADDRESS P.ADY ; ; P.AEA: .ASCII \ Data characters sent\<9>\!ZL\<0><0><0> ; ; P.ADZ: .LONG 17694745 ; ; .ADDRESS P.AEA ; ; P.AEC: .ASCII \ Data characters received !ZL\<0><0><0> ; ; P.AEB: .LONG 17694749 ; ; .ADDRESS P.AEC ; ; P.AEE: .ASCII \ Characters received\<9>\!ZL\ ; ; P.AED: .LONG 17694744 ; ; .ADDRESS P.AEE ; ; P.AEG: .ASCII \Totals since Kermit was started\<0> ; ; P.AEF: .LONG 17694751 ; ; .ADDRESS P.AEG ; ; P.AEI: .ASCII \Totals for the last transfer\ ; ; P.AEH: .LONG 17694748 ; ; .ADDRESS P.AEI ; ; P.AEK: .ASCII \Last error: !AD\<0> ; ; P.AEJ: .LONG 17694735 ; ; .ADDRESS P.AEK ; ; TEXT_CR= P.ADL TEXT_BAUD= P.ADN TEXT_NAKS_SENT= P.ADP TEXT_NAKS_RCV= P.ADR TEXT_PKTS_SENT= P.ADT TEXT_PKTS_RCV= P.ADV TEXT_CHR_SENT= P.ADX TEXT_DATA_CHAR_SENT=P.ADZ TEXT_DATA_CHAR_RCV= P.AEB TEXT_CHR_RCV= P.AED TEXT_TOTAL_HDR= P.AEF TEXT_XFR_HDR= P.AEH .PSECT $CODE$,NOWRT,2 ;COMND_STATUS U.4: .WORD ^M ;Save R2,R3,R4,R5,R6,R7,R8,R9 ; 2011 MOVAB W^RMSG_DATA_CHARS, R9 ;RMSG_DATA_CHARS, R9 ; MOVAB W^SMSG_DATA_CHARS, R8 ;SMSG_DATA_CHARS, R8 ; MOVAB W^U.32, R7 ;U.32, R7 ; MOVAB G^LIB$PUT_OUTPUT, R6 ;LIB$PUT_OUTPUT, R6 ; MOVAB W^OUTPUT_LONG_WORD, R5 ;OUTPUT_LONG_WORD, R5 ; MOVAB W^TEXT_CR, R4 ;TEXT_CR, R4 ; PUSHL R4 ;R4 ; 2069 CALLS #1, (R6) ;#1, LIB$PUT_OUTPUT ; MOVL R0, R3 ;R0, STATUS ; PUSHAB 328(R4) ;TEXT_TOTAL_HDR ; 2070 CALLS #1, (R6) ;#1, LIB$PUT_OUTPUT ; MOVL R0, R3 ;R0, STATUS ; PUSHL W^SMSG_TOTAL_CHARS ;SMSG_TOTAL_CHARS ; 2071 PUSHAB 180(R4) ;TEXT_CHR_SENT ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHL (R8) ;SMSG_DATA_CHARS ; 2072 PUSHAB 216(R4) ;TEXT_DATA_CHAR_SENT ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHL W^SMSG_NAKS ;SMSG_NAKS ; 2073 PUSHAB 68(R4) ;TEXT_NAKS_SENT ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHL W^RMSG_TOTAL_CHARS ;RMSG_TOTAL_CHARS ; 2074 PUSHAB 288(R4) ;TEXT_CHR_RCV ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHL (R9) ;RMSG_DATA_CHARS ; 2075 PUSHAB 256(R4) ;TEXT_DATA_CHAR_RCV ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHL W^RMSG_NAKS ;RMSG_NAKS ; 2076 PUSHAB 92(R4) ;TEXT_NAKS_RCV ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; MOVL W^XFR_TIME, R0 ;XFR_TIME, R0 ; 2078 BEQL 3$ ;3$ ; CMPL (R9), (R8) ;RMSG_DATA_CHARS, SMSG_DATA_CHARS ; 2081 BGTR 1$ ;1$ ; MOVL (R8), R1 ;SMSG_DATA_CHARS, R1 ; BRB 2$ ;2$ ; 1$: MOVL (R9), R1 ;RMSG_DATA_CHARS, R1 ; 2$: MULL2 #10, R1 ;#10, R1 ; MOVAB 500(R0), R0 ;500(R0), R0 ; DIVL2 #1000, R0 ;#1000, R0 ; DIVL3 R0, R1, -(SP) ;R0, R1, -(SP) ; PUSHAB 40(R4) ;TEXT_BAUD ; 2080 CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; 3$: PUSHL R4 ;R4 ; 2084 CALLS #1, (R6) ;#1, LIB$PUT_OUTPUT ; MOVL R0, R3 ;R0, STATUS ; PUSHAB 364(R4) ;TEXT_XFR_HDR ; 2085 CALLS #1, (R6) ;#1, LIB$PUT_OUTPUT ; MOVL R0, R3 ;R0, STATUS ; PUSHL W^SND_TOTAL_CHARS ;SND_TOTAL_CHARS ; 2086 PUSHAB 180(R4) ;TEXT_CHR_SENT ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHL W^SND_DATA_CHARS ;SND_DATA_CHARS ; 2087 PUSHAB 216(R4) ;TEXT_DATA_CHAR_SENT ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHL W^SND_NAKS ;SND_NAKS ; 2088 PUSHAB 68(R4) ;TEXT_NAKS_SENT ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHL W^SND_COUNT ;SND_COUNT ; 2089 PUSHAB 120(R4) ;TEXT_PKTS_SENT ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHL W^RCV_TOTAL_CHARS ;RCV_TOTAL_CHARS ; 2090 PUSHAB 288(R4) ;TEXT_CHR_RCV ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHL W^RCV_DATA_CHARS ;RCV_DATA_CHARS ; 2091 PUSHAB 256(R4) ;TEXT_DATA_CHAR_RCV ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHL W^RCV_NAKS ;RCV_NAKS ; 2092 PUSHAB 92(R4) ;TEXT_NAKS_RCV ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHL W^RCV_COUNT ;RCV_COUNT ; 2093 PUSHAB 152(R4) ;TEXT_PKTS_RCV ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; MOVL W^TOTAL_TIME, R0 ;TOTAL_TIME, R0 ; 2095 BEQL 4$ ;4$ ; ADDL3 W^SND_DATA_CHARS, W^RCV_DATA_CHARS, -;SND_DATA_CHARS, RCV_DATA_CHARS, R1 ; 2098 R1 ; ; MULL2 #10, R1 ;#10, R1 ; MOVAB 500(R0), R0 ;500(R0), R0 ; DIVL2 #1000, R0 ;#1000, R0 ; DIVL3 R0, R1, -(SP) ;R0, R1, -(SP) ; PUSHAB 40(R4) ;TEXT_BAUD ; 2097 CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; 4$: MOVAB W^LAST_ERROR, R0 ;LAST_ERROR, POINTER ; 2103 CLRL R2 ;CHAR_COUNT ; 2104 5$: MOVZBL (R0)+, R1 ;(POINTER)+, R1 ; 2106 BEQL 6$ ;6$ ; INCL R2 ;CHAR_COUNT ; 2107 BRB 5$ ;5$ ; 2106 6$: TSTL R2 ;CHAR_COUNT ; 2109 BEQL 8$ ;8$ ; CALLS #0, -19(R5) ;#0, INIT_DESC ; 2112 PUSHAB W^LAST_ERROR ;LAST_ERROR ; 2113 PUSHL R2 ;CHAR_COUNT ; PUSHL R7 ;R7 ; PUSHAB 8(R7) ;OUTPUT_SIZE ; PUSHAB 388(R4) ;P.AEJ ; CALLS #5, G^SYS$FAO ;#5, SYS$FAO ; MOVL R0, R3 ;R0, STATUS ; BLBC R3, 7$ ;STATUS, 7$ ; 2115 MOVW 8(R7), (R7) ;OUTPUT_SIZE, OUTPUT_DESC ; 2120 PUSHL R7 ;R7 ; 2121 CALLS #1, (R6) ;#1, LIB$PUT_OUTPUT ; MOVL R0, R3 ;R0, STATUS ; BLBS R3, 8$ ;STATUS, 8$ ; 2123 7$: PUSHL R3 ;STATUS ; CALLS #1, G^LIB$SIGNAL ;#1, LIB$SIGNAL ; 8$: RET ; ; 2011 ; Routine Size: 377 bytes, Routine Base: $CODE$ + 05FE ; 2130 %SBTTL 'TPARSE support -- STORE_DEBUG' ; 2131 ROUTINE STORE_DEBUG = ; 2132 ; 2133 !++ ; 2134 ! FUNCTIONAL DESCRIPTION: ; 2135 ! ; 2136 ! This routine will store the debug flag into the DEBUG_FLAG ; 2137 ! location. ; 2138 ! ; 2139 ! CALLING SEQUENCE: ; 2140 ! ; 2141 ! Standard LIB$TPARSE routine call. ; 2142 ! ; 2143 ! INPUT PARAMETERS: ; 2144 ! ; 2145 ! None. ; 2146 ! ; 2147 ! IMPLICIT INPUTS: ; 2148 ! ; 2149 ! None. ; 2150 ! ; 2151 ! OUTPUT PARAMETERS: ; 2152 ! ; 2153 ! None. ; 2154 ! ; 2155 ! IMPLICIT OUTPUTS: ; 2156 ! ; 2157 ! None. ; 2158 ! ; 2159 ! COMPLETION CODES: ; 2160 ! ; 2161 ! None. ; 2162 ! ; 2163 ! SIDE EFFECTS: ; 2164 ! ; 2165 ! None. ; 2166 ! ; 2167 !-- ; 2168 ; 2169 BEGIN ; 2170 TPARSE_ARGS; ; 2171 DEBUG_FLAG = .AP [TPA$L_PARAM]; ; 2172 RETURN SS$_NORMAL; ; 2173 END; ! End of STORE_DEBUG ;STORE_DEBUG U.8: .WORD ^M<> ;Save nothing ; 2131 MOVL 32(AP), W^DEBUG_FLAG ;32(AP), DEBUG_FLAG ; 2171 MOVL #1, R0 ;#1, R0 ; 2169 RET ; ; 2131 ; Routine Size: 12 bytes, Routine Base: $CODE$ + 0777 ; 2174 %SBTTL 'TPARSE support -- STORE_IBM' ; 2175 ROUTINE STORE_IBM = ; 2176 ; 2177 !++ ; 2178 ! FUNCTIONAL DESCRIPTION: ; 2179 ! ; 2180 ! This routine will store the IBM flag into the IBM_FLAG ; 2181 ! location. ; 2182 ! ; 2183 ! CALLING SEQUENCE: ; 2184 ! ; 2185 ! Standard LIB$TPARSE routine call. ; 2186 ! ; 2187 ! INPUT PARAMETERS: ; 2188 ! ; 2189 ! None. ; 2190 ! ; 2191 ! IMPLICIT INPUTS: ; 2192 ! ; 2193 ! None. ; 2194 ! ; 2195 ! OUTPUT PARAMETERS: ; 2196 ! ; 2197 ! None. ; 2198 ! ; 2199 ! IMPLICIT OUTPUTS: ; 2200 ! ; 2201 ! None. ; 2202 ! ; 2203 ! COMPLETION CODES: ; 2204 ! ; 2205 ! None. ; 2206 ! ; 2207 ! SIDE EFFECTS: ; 2208 ! ; 2209 ! None. ; 2210 ! ; 2211 !-- ; 2212 ; 2213 BEGIN ; 2214 TPARSE_ARGS; ; 2215 IBM_FLAG = .AP [TPA$L_PARAM]; ; 2216 RETURN SS$_NORMAL; ; 2217 END; ! End of STORE_IBM ;STORE_IBM U.14: .WORD ^M<> ;Save nothing ; 2175 MOVL 32(AP), W^IBM_FLAG ;32(AP), IBM_FLAG ; 2215 MOVL #1, R0 ;#1, R0 ; 2213 RET ; ; 2175 ; Routine Size: 12 bytes, Routine Base: $CODE$ + 0783 ; 2218 %SBTTL 'TPARSE support -- STORE_ABT' ; 2219 ROUTINE STORE_ABT = ; 2220 ; 2221 !++ ; 2222 ! FUNCTIONAL DESCRIPTION: ; 2223 ! ; 2224 ! This routine will store the aborted file disposition into ABT_FLAG ; 2225 ! ; 2226 ! CALLING SEQUENCE: ; 2227 ! ; 2228 ! Standard LIB$TPARSE routine call. ; 2229 ! ; 2230 ! INPUT PARAMETERS: ; 2231 ! ; 2232 ! None. ; 2233 ! ; 2234 ! IMPLICIT INPUTS: ; 2235 ! ; 2236 ! None. ; 2237 ! ; 2238 ! OUTPUT PARAMETERS: ; 2239 ! ; 2240 ! None. ; 2241 ! ; 2242 ! IMPLICIT OUTPUTS: ; 2243 ! ; 2244 ! None. ; 2245 ! ; 2246 ! COMPLETION CODES: ; 2247 ! ; 2248 ! None. ; 2249 ! ; 2250 ! SIDE EFFECTS: ; 2251 ! ; 2252 ! None. ; 2253 ! ; 2254 !-- ; 2255 ; 2256 BEGIN ; 2257 TPARSE_ARGS; ; 2258 ABT_FLAG = .AP [TPA$L_PARAM]; ; 2259 RETURN SS$_NORMAL; ; 2260 END; ! End of STORE_ABT ;STORE_ABT U.13: .WORD ^M<> ;Save nothing ; 2219 MOVL 32(AP), W^ABT_FLAG ;32(AP), ABT_FLAG ; 2258 MOVL #1, R0 ;#1, R0 ; 2256 RET ; ; 2219 ; Routine Size: 12 bytes, Routine Base: $CODE$ + 078F ; 2261 %SBTTL 'TPARSE support -- STORE_CHK' ; 2262 ROUTINE STORE_CHK = ; 2263 ; 2264 !++ ; 2265 ! FUNCTIONAL DESCRIPTION: ; 2266 ! ; 2267 ! This routine will store the block check type into XXXX ; 2268 ! location. ; 2269 ! ; 2270 ! CALLING SEQUENCE: ; 2271 ! ; 2272 ! Standard LIB$TPARSE routine call. ; 2273 ! ; 2274 ! INPUT PARAMETERS: ; 2275 ! ; 2276 ! None. ; 2277 ! ; 2278 ! IMPLICIT INPUTS: ; 2279 ! ; 2280 ! None. ; 2281 ! ; 2282 ! OUTPUT PARAMETERS: ; 2283 ! ; 2284 ! None. ; 2285 ! ; 2286 ! IMPLICIT OUTPUTS: ; 2287 ! ; 2288 ! None. ; 2289 ! ; 2290 ! COMPLETION CODES: ; 2291 ! ; 2292 ! None. ; 2293 ! ; 2294 ! SIDE EFFECTS: ; 2295 ! ; 2296 ! None. ; 2297 ! ; 2298 !-- ; 2299 ; 2300 BEGIN ; 2301 TPARSE_ARGS; ; 2302 CHKTYPE = .AP [TPA$L_PARAM]; ; 2303 RETURN SS$_NORMAL; ; 2304 END; ! End of STORE_CHK ;STORE_CHK U.12: .WORD ^M<> ;Save nothing ; 2262 MOVL 32(AP), W^CHKTYPE ;32(AP), CHKTYPE ; 2302 MOVL #1, R0 ;#1, R0 ; 2300 RET ; ; 2262 ; Routine Size: 12 bytes, Routine Base: $CODE$ + 079B ; 2305 %SBTTL 'TPARSE support -- STORE_FTP - Store file type' ; 2306 ROUTINE STORE_FTP = ; 2307 ; 2308 !++ ; 2309 ! FUNCTIONAL DESCRIPTION: ; 2310 ! ; 2311 ! This routine will store the file type that was specified by the ; 2312 ! user for the KERFIL processing. ; 2313 ! ; 2314 ! CALLING SEQUENCE: ; 2315 ! ; 2316 ! Standard call from LIB$TPARSE. ; 2317 ! ; 2318 ! INPUT PARAMETERS: ; 2319 ! ; 2320 ! None. ; 2321 ! ; 2322 ! IMPLICIT INPUTS: ; 2323 ! ; 2324 ! None. ; 2325 ! ; 2326 ! OUTPUT PARAMETERS: ; 2327 ! ; 2328 ! None. ; 2329 ! ; 2330 ! IMPLICIT OUTPUTS: ; 2331 ! ; 2332 ! None. ; 2333 ! ; 2334 ! COMPLETION CODES: ; 2335 ! ; 2336 ! None. ; 2337 ! ; 2338 ! SIDE EFFECTS: ; 2339 ! ; 2340 ! None. ; 2341 ! ; 2342 !-- ; 2343 ; 2344 BEGIN ; 2345 TPARSE_ARGS; ; 2346 FILE_TYPE = .AP [TPA$L_PARAM]; ; 2347 RETURN SS$_NORMAL; ; 2348 END; ! End of STORE_FTP ;STORE_FTP U.9: .WORD ^M<> ;Save nothing ; 2306 MOVL 32(AP), W^FILE_TYPE ;32(AP), FILE_TYPE ; 2346 MOVL #1, R0 ;#1, R0 ; 2344 RET ; ; 2306 ; Routine Size: 12 bytes, Routine Base: $CODE$ + 07A7 ; 2349 %SBTTL 'TPARSE support -- STORE_PARITY - Store file type' ; 2350 ROUTINE STORE_PARITY = ; 2351 ; 2352 !++ ; 2353 ! FUNCTIONAL DESCRIPTION: ; 2354 ! ; 2355 ! This routine will store the type of parity to use for the transfer. ; 2356 ! If a parity type of other than NONE is specified then we will use ; 2357 ! eight-bit quoting to support the transfer. ; 2358 ! ; 2359 ! CALLING SEQUENCE: ; 2360 ! ; 2361 ! Standard call from LIB$TPARSE. ; 2362 ! ; 2363 ! INPUT PARAMETERS: ; 2364 ! ; 2365 ! None. ; 2366 ! ; 2367 ! IMPLICIT INPUTS: ; 2368 ! ; 2369 ! None. ; 2370 ! ; 2371 ! OUTPUT PARAMETERS: ; 2372 ! ; 2373 ! None. ; 2374 ! ; 2375 ! IMPLICIT OUTPUTS: ; 2376 ! ; 2377 ! None. ; 2378 ! ; 2379 ! COMPLETION CODES: ; 2380 ! ; 2381 ! None. ; 2382 ! ; 2383 ! SIDE EFFECTS: ; 2384 ! ; 2385 ! None. ; 2386 ! ; 2387 !-- ; 2388 ; 2389 BEGIN ; 2390 TPARSE_ARGS; ; 2391 PARITY_TYPE = .AP [TPA$L_PARAM]; ; 2392 RETURN SS$_NORMAL; ; 2393 END; ! End of STORE_PARITY ;STORE_PARITY U.11: .WORD ^M<> ;Save nothing ; 2350 MOVL 32(AP), W^PARITY_TYPE ;32(AP), PARITY_TYPE ; 2391 MOVL #1, R0 ;#1, R0 ; 2389 RET ; ; 2350 ; Routine Size: 12 bytes, Routine Base: $CODE$ + 07B3 ; 2394 %SBTTL 'TPARSE support -- STORE_ECHO - Store local echo flag' ; 2395 ROUTINE STORE_ECHO = ; 2396 ; 2397 !++ ; 2398 ! FUNCTIONAL DESCRIPTION: ; 2399 ! ; 2400 ! This routine will store the state of the local echo flag as the ; 2401 ! user set it. ; 2402 ! ; 2403 ! CALLING SEQUENCE: ; 2404 ! ; 2405 ! Standard TPARSE argument call. ; 2406 ! ; 2407 ! INPUT PARAMETERS: ; 2408 ! ; 2409 ! None. ; 2410 ! ; 2411 ! IMPLICIT INPUTS: ; 2412 ! ; 2413 ! None. ; 2414 ! ; 2415 ! OUTPUT PARAMETERS: ; 2416 ! ; 2417 ! None. ; 2418 ! ; 2419 ! IMPLICIT OUTPUTS: ; 2420 ! ; 2421 ! None. ; 2422 ! ; 2423 ! COMPLETION CODES: ; 2424 ! ; 2425 ! None. ; 2426 ! ; 2427 ! SIDE EFFECTS: ; 2428 ! ; 2429 ! None. ; 2430 ! ; 2431 !-- ; 2432 ; 2433 BEGIN ; 2434 TPARSE_ARGS; ; 2435 ECHO_FLAG = .AP [TPA$L_PARAM]; ; 2436 RETURN SS$_NORMAL; ; 2437 END; ! End of STORE_ECHO ;STORE_ECHO U.10: .WORD ^M<> ;Save nothing ; 2395 MOVL 32(AP), W^ECHO_FLAG ;32(AP), ECHO_FLAG ; 2435 MOVL #1, R0 ;#1, R0 ; 2433 RET ; ; 2395 ; Routine Size: 12 bytes, Routine Base: $CODE$ + 07BF ; 2438 %SBTTL 'TPARSE support -- STORE_MSG_FIL - Store file name typeout flag' ; 2439 ROUTINE STORE_MSG_FIL = ; 2440 ; 2441 !++ ; 2442 ! FUNCTIONAL DESCRIPTION: ; 2443 ! ; 2444 ! This routine will store the state of the file name typeout flag as the ; 2445 ! user set it. ; 2446 ! ; 2447 ! CALLING SEQUENCE: ; 2448 ! ; 2449 ! Standard TPARSE argument call. ; 2450 ! ; 2451 ! INPUT PARAMETERS: ; 2452 ! ; 2453 ! None. ; 2454 ! ; 2455 ! IMPLICIT INPUTS: ; 2456 ! ; 2457 ! None. ; 2458 ! ; 2459 ! OUTPUT PARAMETERS: ; 2460 ! ; 2461 ! None. ; 2462 ! ; 2463 ! IMPLICIT OUTPUTS: ; 2464 ! ; 2465 ! None. ; 2466 ! ; 2467 ! COMPLETION CODES: ; 2468 ! ; 2469 ! None. ; 2470 ! ; 2471 ! SIDE EFFECTS: ; 2472 ! ; 2473 ! None. ; 2474 ! ; 2475 !-- ; 2476 ; 2477 BEGIN ; 2478 TPARSE_ARGS; ; 2479 TY_FIL = .AP [TPA$L_PARAM]; ; 2480 RETURN SS$_NORMAL; ; 2481 END; ! End of STORE_MSG_FIL ;STORE_MSG_FIL U.15: .WORD ^M<> ;Save nothing ; 2439 MOVL 32(AP), W^TY_FIL ;32(AP), TY_FIL ; 2479 MOVL #1, R0 ;#1, R0 ; 2477 RET ; ; 2439 ; Routine Size: 12 bytes, Routine Base: $CODE$ + 07CB ; 2482 %SBTTL 'TPARSE support -- STORE_MSG_PKT - Store packet number typeout flag' ; 2483 ROUTINE STORE_MSG_PKT = ; 2484 ; 2485 !++ ; 2486 ! FUNCTIONAL DESCRIPTION: ; 2487 ! ; 2488 ! This routine will store the state of the packet number flag as the ; 2489 ! user set it. ; 2490 ! ; 2491 ! CALLING SEQUENCE: ; 2492 ! ; 2493 ! Standard TPARSE argument call. ; 2494 ! ; 2495 ! INPUT PARAMETERS: ; 2496 ! ; 2497 ! None. ; 2498 ! ; 2499 ! IMPLICIT INPUTS: ; 2500 ! ; 2501 ! None. ; 2502 ! ; 2503 ! OUTPUT PARAMETERS: ; 2504 ! ; 2505 ! None. ; 2506 ! ; 2507 ! IMPLICIT OUTPUTS: ; 2508 ! ; 2509 ! None. ; 2510 ! ; 2511 ! COMPLETION CODES: ; 2512 ! ; 2513 ! None. ; 2514 ! ; 2515 ! SIDE EFFECTS: ; 2516 ! ; 2517 ! None. ; 2518 ! ; 2519 !-- ; 2520 ; 2521 BEGIN ; 2522 TPARSE_ARGS; ; 2523 TY_PKT = .AP [TPA$L_PARAM]; ; 2524 RETURN SS$_NORMAL; ; 2525 END; ! End of STORE_MSG_PKT ;STORE_MSG_PKT U.16: .WORD ^M<> ;Save nothing ; 2483 MOVL 32(AP), W^TY_PKT ;32(AP), TY_PKT ; 2523 MOVL #1, R0 ;#1, R0 ; 2521 RET ; ; 2483 ; Routine Size: 12 bytes, Routine Base: $CODE$ + 07D7 ; 2526 %SBTTL 'TPARSE support -- CHECK_EOL' ; 2527 ROUTINE CHECK_EOL = ; 2528 ; 2529 !++ ; 2530 ! FUNCTIONAL DESCRIPTION: ; 2531 ! ; 2532 ! This routine will valid the SEND and RECEIVE eol character that ; 2533 ! is being set by the user. ; 2534 ! ; 2535 ! CALLING SEQUENCE: ; 2536 ! ; 2537 ! Standard TPARSE routine calling sequence. ; 2538 ! ; 2539 ! INPUT PARAMETERS: ; 2540 ! ; 2541 ! None. ; 2542 ! ; 2543 ! IMPLICIT INPUTS: ; 2544 ! ; 2545 ! None. ; 2546 ! ; 2547 ! OUTPUT PARAMETERS: ; 2548 ! ; 2549 ! None. ; 2550 ! ; 2551 ! IMPLICIT OUTPUTS: ; 2552 ! ; 2553 ! None. ; 2554 ! ; 2555 ! COMPLETION CODES: ; 2556 ! ; 2557 ! None. ; 2558 ! ; 2559 ! SIDE EFFECTS: ; 2560 ! ; 2561 ! None. ; 2562 ! ; 2563 !-- ; 2564 ; 2565 BEGIN ; 2566 TPARSE_ARGS; ; 2567 ; 2568 IF (.AP [TPA$L_NUMBER] LSS %C' ') AND (.AP [TPA$L_NUMBER] GTR 0) ; 2569 THEN ; 2570 RETURN SS$_NORMAL ; 2571 ELSE ; 2572 RETURN KER_ILLEOL; ; 2573 ; 2574 END; ! End of CHECK_EOL ;CHECK_EOL U.20: .WORD ^M<> ;Save nothing ; 2527 CMPL 28(AP), #32 ;28(AP), #32 ; 2568 BGEQ 1$ ;1$ ; TSTL 28(AP) ;28(AP) ; BLEQ 1$ ;1$ ; MOVL #1, R0 ;#1, R0 ; 2565 RET ; ; 1$: MOVL #134316066, R0 ;#134316066, R0 ; RET ; ; 2527 ; Routine Size: 25 bytes, Routine Base: $CODE$ + 07E3 ; 2575 %SBTTL 'TPARSE support -- CHECK_SOH' ; 2576 ROUTINE CHECK_SOH = ; 2577 ; 2578 !++ ; 2579 ! FUNCTIONAL DESCRIPTION: ; 2580 ! ; 2581 ! This routine will valid the SEND and RECEIVE START_OF_PACKET ; 2582 ! character that is being set by the user. ; 2583 ! ; 2584 ! CALLING SEQUENCE: ; 2585 ! ; 2586 ! Standard TPARSE routine calling sequence. ; 2587 ! ; 2588 ! INPUT PARAMETERS: ; 2589 ! ; 2590 ! None. ; 2591 ! ; 2592 ! IMPLICIT INPUTS: ; 2593 ! ; 2594 ! None. ; 2595 ! ; 2596 ! OUTPUT PARAMETERS: ; 2597 ! ; 2598 ! None. ; 2599 ! ; 2600 ! IMPLICIT OUTPUTS: ; 2601 ! ; 2602 ! None. ; 2603 ! ; 2604 ! COMPLETION CODES: ; 2605 ! ; 2606 ! None. ; 2607 ! ; 2608 ! SIDE EFFECTS: ; 2609 ! ; 2610 ! None. ; 2611 ! ; 2612 !-- ; 2613 ; 2614 BEGIN ; 2615 TPARSE_ARGS; ; 2616 ; 2617 IF (.AP [TPA$L_NUMBER] LSS %C' ') AND (.AP [TPA$L_NUMBER] GTR 0) ; 2618 THEN ; 2619 RETURN SS$_NORMAL ; 2620 ELSE ; 2621 RETURN KER_ILLSOH; ; 2622 ; 2623 END; ! End of CHECK_SOH ;CHECK_SOH U.21: .WORD ^M<> ;Save nothing ; 2576 CMPL 28(AP), #32 ;28(AP), #32 ; 2617 BGEQ 1$ ;1$ ; TSTL 28(AP) ;28(AP) ; BLEQ 1$ ;1$ ; MOVL #1, R0 ;#1, R0 ; 2614 RET ; ; 1$: MOVL #134316106, R0 ;#134316106, R0 ; RET ; ; 2576 ; Routine Size: 25 bytes, Routine Base: $CODE$ + 07FC ; 2624 ; 2625 %SBTTL 'TPARSE support -- CHECK_PAD_CHAR' ; 2626 ROUTINE CHECK_PAD_CHAR = ; 2627 ; 2628 !++ ; 2629 ! FUNCTIONAL DESCRIPTION: ; 2630 ! ; 2631 ! This routine will valid the SEND and RECEIVE eol character that ; 2632 ! is being set by the user. ; 2633 ! ; 2634 ! CALLING SEQUENCE: ; 2635 ! ; 2636 ! Standard TPARSE routine calling sequence. ; 2637 ! ; 2638 ! INPUT PARAMETERS: ; 2639 ! ; 2640 ! None. ; 2641 ! ; 2642 ! IMPLICIT INPUTS: ; 2643 ! ; 2644 ! None. ; 2645 ! ; 2646 ! OUTPUT PARAMETERS: ; 2647 ! ; 2648 ! None. ; 2649 ! ; 2650 ! IMPLICIT OUTPUTS: ; 2651 ! ; 2652 ! None. ; 2653 ! ; 2654 ! COMPLETION CODES: ; 2655 ! ; 2656 ! None. ; 2657 ! ; 2658 ! SIDE EFFECTS: ; 2659 ! ; 2660 ! None. ; 2661 ! ; 2662 !-- ; 2663 ; 2664 BEGIN ; 2665 TPARSE_ARGS; ; 2666 ; 2667 IF .AP [TPA$L_NUMBER] LSS %C' ' OR .AP [TPA$L_NUMBER] EQL CHR_DEL ; 2668 THEN ; 2669 RETURN SS$_NORMAL ; 2670 ELSE ; 2671 RETURN KER_ILLPADCHR; ; 2672 ; 2673 END; ! End of CHECK_PAD_CHAR ;CHECK_PAD_CHAR U.19: .WORD ^M<> ;Save nothing ; 2626 CMPL 28(AP), #32 ;28(AP), #32 ; 2667 BLSS 1$ ;1$ ; CMPL 28(AP), #127 ;28(AP), #127 ; BNEQ 2$ ;2$ ; 1$: MOVL #1, R0 ;#1, R0 ; 2664 RET ; ; 2$: MOVL #134316082, R0 ;#134316082, R0 ; RET ; ; 2626 ; Routine Size: 30 bytes, Routine Base: $CODE$ + 0815 ; 2674 %SBTTL 'TPARSE support -- CHECK_NPAD' ; 2675 ROUTINE CHECK_NPAD = ; 2676 ; 2677 !++ ; 2678 ! FUNCTIONAL DESCRIPTION: ; 2679 ! ; 2680 ! This routine will determine if the packet length specified by the ; 2681 ! user is valid. ; 2682 ! ; 2683 ! CALLING SEQUENCE: ; 2684 ! ; 2685 ! Standard TPARSE calling sequence. ; 2686 ! ; 2687 ! INPUT PARAMETERS: ; 2688 ! ; 2689 ! None. ; 2690 ! ; 2691 ! IMPLICIT INPUTS: ; 2692 ! ; 2693 ! None. ; 2694 ! ; 2695 ! OUTPUT PARAMETERS: ; 2696 ! ; 2697 ! None. ; 2698 ! ; 2699 ! IMPLICIT OUTPUTS: ; 2700 ! ; 2701 ! None. ; 2702 ! ; 2703 ! COMPLETION CODES: ; 2704 ! ; 2705 ! None. ; 2706 ! ; 2707 ! SIDE EFFECTS: ; 2708 ! ; 2709 ! None. ; 2710 ! ; 2711 !-- ; 2712 ; 2713 BEGIN ; 2714 TPARSE_ARGS; ; 2715 ; 2716 IF .AP [TPA$L_NUMBER] LEQ 0 THEN RETURN KER_ILLNPAD ELSE RETURN SS$_NORMAL; ; 2717 ; 2718 END; ! End of CHECK_NPAD ;CHECK_NPAD U.18: .WORD ^M<> ;Save nothing ; 2675 TSTL 28(AP) ;28(AP) ; 2716 BGTR 1$ ;1$ ; MOVL #134316090, R0 ;#134316090, R0 ; 2713 RET ; ; 1$: MOVL #1, R0 ;#1, R0 ; RET ; ; 2675 ; Routine Size: 19 bytes, Routine Base: $CODE$ + 0833 ; 2719 %SBTTL 'TPARSE support -- CHECK_PACKET_LEN' ; 2720 ROUTINE CHECK_PACKET_LEN = ; 2721 ; 2722 !++ ; 2723 ! FUNCTIONAL DESCRIPTION: ; 2724 ! ; 2725 ! This routine will determine if the packet length specified by the ; 2726 ! user is valid. ; 2727 ! ; 2728 ! CALLING SEQUENCE: ; 2729 ! ; 2730 ! Standard TPARSE calling sequence. ; 2731 ! ; 2732 ! INPUT PARAMETERS: ; 2733 ! ; 2734 ! None. ; 2735 ! ; 2736 ! IMPLICIT INPUTS: ; 2737 ! ; 2738 ! None. ; 2739 ! ; 2740 ! OUTPUT PARAMETERS: ; 2741 ! ; 2742 ! None. ; 2743 ! ; 2744 ! IMPLICIT OUTPUTS: ; 2745 ! ; 2746 ! None. ; 2747 ! ; 2748 ! COMPLETION CODES: ; 2749 ! ; 2750 ! None. ; 2751 ! ; 2752 ! SIDE EFFECTS: ; 2753 ! ; 2754 ! None. ; 2755 ! ; 2756 !-- ; 2757 ; 2758 BEGIN ; 2759 TPARSE_ARGS; ; 2760 ; 2761 IF .AP [TPA$L_NUMBER] LSS 10 OR .AP [TPA$L_NUMBER] GTR MAX_MSG ; 2762 THEN ; 2763 RETURN KER_ILLPKTLEN ; 2764 ELSE ; 2765 RETURN SS$_NORMAL; ; 2766 ; 2767 END; ! End of CHECK_PACKET_LEN ;CHECK_PACKET_LEN U.17: .WORD ^M<> ;Save nothing ; 2720 CMPL 28(AP), #10 ;28(AP), #10 ; 2761 BLSS 1$ ;1$ ; CMPL 28(AP), #96 ;28(AP), #96 ; BLEQ 2$ ;2$ ; 1$: MOVL #134316074, R0 ;#134316074, R0 ; 2758 RET ; ; 2$: MOVL #1, R0 ;#1, R0 ; RET ; ; 2720 ; Routine Size: 30 bytes, Routine Base: $CODE$ + 0846 ; 2768 %SBTTL 'STORE_TEXT' ; 2769 ROUTINE STORE_TEXT = ; 2770 ; 2771 !++ ; 2772 ! FUNCTIONAL DESCRIPTION: ; 2773 ! ; 2774 ! This routine will store a single character of the file specification ; 2775 ! that the user gives to the SEND and RECEIVE commands. ; 2776 ! ; 2777 ! FORMAL PARAMETERS: ; 2778 ! ; 2779 ! Character that was parsed. ; 2780 ! ; 2781 ! IMPLICIT INPUTS: ; 2782 ! ; 2783 ! None. ; 2784 ! ; 2785 ! IMPLICIT OUTPUTS: ; 2786 ! ; 2787 ! Character stored into the file specification vector. ; 2788 ! ; 2789 ! ROUTINE VALUE and ; 2790 ! COMPLETION CODES: ; 2791 ! ; 2792 ! None. ; 2793 ! ; 2794 ! SIDE EFFECTS: ; 2795 ! ; 2796 ! None. ; 2797 ! ; 2798 !-- ; 2799 ; 2800 BEGIN ; 2801 TPARSE_ARGS; ; 2802 ; 2803 IF (TEMP_DESC [DSC$W_LENGTH] = .TEMP_DESC [DSC$W_LENGTH] + 1) LEQ TEMP_LENGTH ; 2804 THEN ; 2805 BEGIN ; 2806 CH$WCHAR (.AP [TPA$B_CHAR], CH$PTR (TEMP_NAME, .TEMP_DESC [DSC$W_LENGTH] - 1)); ; 2807 RETURN SS$_NORMAL; ; 2808 END ; 2809 ELSE ; 2810 RETURN KER_LINTOOLNG; ; 2811 ; 2812 END; ! End of STORE_TEXT ;STORE_TEXT U.5: .WORD ^M ;Save R2 ; 2769 MOVAB W^U.36, R2 ;U.36, R2 ; MOVZWL (R2), R0 ;TEMP_DESC, R0 ; 2803 INCL R0 ;R0 ; MOVW R0, (R2) ;R0, TEMP_DESC ; CMPL R0, #132 ;R0, #132 ; BGTR 1$ ;1$ ; MOVZWL (R2), R0 ;TEMP_DESC, R0 ; 2806 MOVB 24(AP), 7(R2)[R0] ;24(AP), TEMP_NAME-1[R0] ; MOVL #1, R0 ;#1, R0 ; 2800 RET ; ; 1$: MOVL #134316098, R0 ;#134316098, R0 ; RET ; ; 2769 ; Routine Size: 45 bytes, Routine Base: $CODE$ + 0864 ; 2813 %SBTTL 'TPARSE support -- COPY_FILE - Copy file specification' ; 2814 ROUTINE COPY_FILE = ; 2815 ; 2816 !++ ; 2817 ! FUNCTIONAL DESCRIPTION: ; 2818 ! ; 2819 ! This routine will copy the file name from the temporary ; 2820 ! descriptor to the descriptor that is used for the file name. ; 2821 ! (FILE_NAME and FILE_DESC). ; 2822 ! ; 2823 ! CALLING SEQUENCE: ; 2824 ! ; 2825 ! COPY_FILE(); ; 2826 ! ; 2827 ! INPUT PARAMETERS: ; 2828 ! ; 2829 ! None. ; 2830 ! ; 2831 ! IMPLICIT INPUTS: ; 2832 ! ; 2833 ! TEMP_DESC and TEMP_NAME set up with the device name and length ; 2834 ! in the descriptor. ; 2835 ! ; 2836 ! OUTPUT PARAMETERS: ; 2837 ! ; 2838 ! None. ; 2839 ! ; 2840 ! IMPLICIT OUTPUTS: ; 2841 ! ; 2842 ! FILE_NAME and FILE_DESC set up with what was in TEMP_NAME and ; 2843 ! TEMP_DESC. ; 2844 ! ; 2845 ! COMPLETION CODES: ; 2846 ! ; 2847 ! 0 - Failure. ; 2848 ! 1 - Success. ; 2849 ! ; 2850 ! SIDE EFFECTS: ; 2851 ! ; 2852 ! None. ; 2853 ! ; 2854 !-- ; 2855 ; 2856 BEGIN ; 2857 FILE_DESC [DSC$W_LENGTH] = .TEMP_DESC [DSC$W_LENGTH]; ; 2858 FILE_SIZE = .FILE_DESC [DSC$W_LENGTH]; ; 2859 CH$COPY (.TEMP_DESC [DSC$W_LENGTH], CH$PTR (TEMP_NAME), 0, .TEMP_DESC [DSC$W_LENGTH] + 1, ; 2860 CH$PTR (FILE_NAME)); ; 2861 RETURN SS$_NORMAL; ; 2862 END; ! End of COPY_FILE ;COPY_FILE U.7: .WORD ^M ;Save R2,R3,R4,R5 ; 2814 MOVZWL W^U.36, R1 ;U.36, R1 ; 2857 MOVW R1, W^FILE_DESC ;R1, FILE_DESC ; MOVZWL W^FILE_DESC, W^FILE_SIZE ;FILE_DESC, FILE_SIZE ; 2858 MOVAB 1(R1), R0 ;1(R1), R0 ; 2859 MOVC5 R1, W^U.37, #0, R0, W^FILE_NAME ;R1, U.37, #0, R0, FILE_NAME ; MOVL #1, R0 ;#1, R0 ; 2856 RET ; ; 2814 ; Routine Size: 37 bytes, Routine Base: $CODE$ + 0891 ; 2863 %SBTTL 'COPY_TERM_NAME' ; 2864 ROUTINE COPY_TERM_NAME = ; 2865 ; 2866 !++ ; 2867 ! FUNCTIONAL DESCRIPTION: ; 2868 ! ; 2869 ! This routine will copy the device name from the temporary ; 2870 ! descriptor to the descriptor that is used for the terminal name. ; 2871 ! (TERM_NAME and TERM_DESC). ; 2872 ! It will then check to see if TERM_DESC is a terminal. ; 2873 ! If it is not a terminal, it will return KER_LINTERM. ; 2874 ! ; 2875 ! CALLING SEQUENCE: ; 2876 ! ; 2877 ! COPY_TERM_NAME(); ; 2878 ! ; 2879 ! INPUT PARAMETERS: ; 2880 ! ; 2881 ! None. ; 2882 ! ; 2883 ! IMPLICIT INPUTS: ; 2884 ! ; 2885 ! TEMP_DESC and TEMP_NAME set up with the device name and length ; 2886 ! in the descriptor. ; 2887 ! ; 2888 ! OUTPUT PARAMETERS: ; 2889 ! ; 2890 ! None. ; 2891 ! ; 2892 ! IMPLICIT OUTPUTS: ; 2893 ! ; 2894 ! TERM_NAME and TERM_DESC set up with what was in TEMP_NAME and ; 2895 ! TEMP_DESC. ; 2896 ! ; 2897 ! COMPLETION CODES: ; 2898 ! ; 2899 ! 0 - Failure. ; 2900 ! 1 - Success. ; 2901 ! ; 2902 ! SIDE EFFECTS: ; 2903 ! ; 2904 ! None. ; 2905 ! ; 2906 !-- ; 2907 ; 2908 BEGIN ; 2909 ; 2910 LOCAL ; 2911 STATUS, ; 2912 ! ; 2913 ! The following variables are used to test if device is a terminal. ; 2914 ! ; 2915 TERM_ITM : DVI_ITEM_LIST [0] FIELD (DVI_FIELDS), ; 2916 TERM_CLASS, ; 2917 TERM_STATUS; ; 2918 ; 2919 ! ; 2920 ! Initialize the GETDVI call for the terminal name given ; 2921 ! ; 2922 TERM_ITM [0, DVI_ITEM_CODE] = DVI$_DEVCLASS; ; 2923 TERM_ITM [0, DVI_BFR_LENGTH] = 4; ; 2924 TERM_ITM [0, DVI_BFR_ADDRESS] = TERM_CLASS; ; 2925 TERM_ITM [0, DVI_RTN_LENGTH] = 0; ; 2926 ! ; 2927 ! Get the device information ; 2928 ! ; 2929 TERM_STATUS = $GETDVI (EFN = 2, DEVNAM = TEMP_DESC, ITMLST = TERM_ITM); ; 2930 ; 2931 IF NOT .TERM_STATUS ; 2932 THEN ; 2933 BEGIN ; 2934 LIB$SIGNAL (.TERM_STATUS); ; 2935 RETURN .TERM_STATUS; ; 2936 END; ; 2937 ; 2938 STATUS = $WAITFR (EFN = 2); ; 2939 ; 2940 IF NOT .STATUS ; 2941 THEN ; 2942 BEGIN ; 2943 LIB$SIGNAL (.STATUS); ; 2944 RETURN .STATUS; ; 2945 END; ; 2946 ; 2947 ! ; 2948 ! Make sure that .TERM_CLASS is a terminal ; 2949 ! ; 2950 ; 2951 IF .TERM_CLASS EQL DC$_TERM ; 2952 THEN ; 2953 BEGIN ; 2954 TERM_DESC [DSC$W_LENGTH] = .TEMP_DESC [DSC$W_LENGTH]; ; 2955 CH$COPY (.TEMP_DESC [DSC$W_LENGTH], CH$PTR (TEMP_NAME), 0, .TEMP_DESC [DSC$W_LENGTH], ; 2956 CH$PTR (TERM_NAME)); ; 2957 RETURN SS$_NORMAL; ; 2958 END ; 2959 ELSE ; 2960 RETURN KER_LINTERM; ; 2961 ; 2962 END; ! End of COPY_TERM_NAME .EXTRN SYS$GETDVI, SYS$WAITFR ;COPY_TERM_NAME U.6: .WORD ^M ;Save R2,R3,R4,R5 ; 2864 SUBL2 #16, SP ;#16, SP ; MOVL #262148, 4(SP) ;#262148, TERM_ITM ; 2923 MOVAB (SP), 8(SP) ;TERM_CLASS, TERM_ITM+4 ; 2924 CLRL 12(SP) ;TERM_ITM+8 ; 2925 CLRQ -(SP) ;-(SP) ; 2929 CLRQ -(SP) ;-(SP) ; PUSHAB 20(SP) ;TERM_ITM ; PUSHAB W^U.36 ;U.36 ; MOVQ #2, -(SP) ;#2, -(SP) ; CALLS #8, G^SYS$GETDVI ;#8, SYS$GETDVI ; MOVL R0, R2 ;R0, TERM_STATUS ; BLBC R2, 1$ ;TERM_STATUS, 1$ ; 2931 PUSHL #2 ;#2 ; 2938 CALLS #1, G^SYS$WAITFR ;#1, SYS$WAITFR ; MOVL R0, R2 ;R0, STATUS ; BLBS R2, 2$ ;STATUS, 2$ ; 2940 1$: PUSHL R2 ;STATUS ; 2943 CALLS #1, G^LIB$SIGNAL ;#1, LIB$SIGNAL ; MOVL R2, R0 ;STATUS, R0 ; 2942 RET ; ; 2$: CMPL (SP), #66 ;TERM_CLASS, #66 ; 2951 BNEQ 3$ ;3$ ; MOVZWL W^U.36, R0 ;U.36, R0 ; 2954 MOVW R0, W^TERM_DESC ;R0, TERM_DESC ; MOVC3 R0, W^U.37, W^TERM_NAME ;R0, U.37, TERM_NAME ; 2955 MOVL #1, R0 ;#1, R0 ; 2908 RET ; ; 3$: MOVL #134316226, R0 ;#134316226, R0 ; RET ; ; 2864 ; Routine Size: 114 bytes, Routine Base: $CODE$ + 08B6 ; 2963 %SBTTL 'HELP_START' ; 2964 ROUTINE HELP_START = ; 2965 ; 2966 !++ ; 2967 ! FUNCTIONAL DESCRIPTION: ; 2968 ! ; 2969 ! This routine is called after the HELP verb has been parsed off ; 2970 ! of the command. This routine will then turn the TPA$V_BLANK bit ; 2971 ! on in the TPARSE_BLOCK. This will allow us to scan multi-words in ; 2972 ! the "HELP xyz" command. ; 2973 ! ; 2974 ! CALLING SEQUENCE: ; 2975 ! ; 2976 ! HELP_START(); ; 2977 ! ; 2978 ! INPUT PARAMETERS: ; 2979 ! ; 2980 ! None. ; 2981 ! ; 2982 ! IMPLICIT INPUTS: ; 2983 ! ; 2984 ! None. ; 2985 ! ; 2986 ! OUTPUT PARAMETERS: ; 2987 ! ; 2988 ! None. ; 2989 ! ; 2990 ! IMPLICIT OUPTUTS: ; 2991 ! ; 2992 ! None. ; 2993 ! ; 2994 ! COMPLETION CODES: ; 2995 ! ; 2996 ! 0 - Failure ; 2997 ! 1 - Success ; 2998 ! ; 2999 ! SIDE EFFECTS: ; 3000 ! ; 3001 ! None. ; 3002 ! ; 3003 !-- ; 3004 ; 3005 BEGIN ; 3006 TPARSE_BLOCK [TPA$V_BLANKS] = 1; ; 3007 RETURN SS$_NORMAL; ; 3008 END; ! End of HELP_START ;HELP_START U.22: .WORD ^M<> ;Save nothing ; 2964 BISB2 #1, W^U.28+4 ;#1, U.28+4 ; 3006 MOVL #1, R0 ;#1, R0 ; 3005 RET ; ; 2964 ; Routine Size: 11 bytes, Routine Base: $CODE$ + 0928 ; 3009 %SBTTL 'HELP_DONE' ; 3010 ROUTINE HELP_DONE = ; 3011 ; 3012 !++ ; 3013 ! FUNCTIONAL DESCRIPTION: ; 3014 ! ; 3015 ! This routine will clear the TPA$V_BLANKS flag. This will allow the ; 3016 ! normal parsing to work. ; 3017 ! ; 3018 ! CALLING SEQUENCE: ; 3019 ! ; 3020 ! HELP_DONE(); ; 3021 ! ; 3022 ! INPUT PARAMETERS: ; 3023 ! ; 3024 ! None. ; 3025 ! ; 3026 ! IMPLICIT INPUTS: ; 3027 ! ; 3028 ! None. ; 3029 ! ; 3030 ! OUTPUT PARAMETERS: ; 3031 ! ; 3032 ! None. ; 3033 ! ; 3034 ! IMPLICIT OUPTUTS: ; 3035 ! ; 3036 ! None. ; 3037 ! ; 3038 ! COMPLETION CODES: ; 3039 ! ; 3040 ! 0 - Failure ; 3041 ! 1 - Success ; 3042 ! ; 3043 ! SIDE EFFECTS: ; 3044 ! ; 3045 ! None. ; 3046 ! ; 3047 !-- ; 3048 ; 3049 BEGIN ; 3050 TPARSE_BLOCK [TPA$V_BLANKS] = 0; ; 3051 RETURN SS$_NORMAL; ; 3052 END; ! End of HELP_DONE ;HELP_DONE U.23: .WORD ^M<> ;Save nothing ; 3010 BICB2 #1, W^U.28+4 ;#1, U.28+4 ; 3050 MOVL #1, R0 ;#1, R0 ; 3049 RET ; ; 3010 ; Routine Size: 11 bytes, Routine Base: $CODE$ + 0933 ; 3053 %SBTTL 'SY_LOGOUT - delete the process.' ; 3054 ; 3055 GLOBAL ROUTINE SY_LOGOUT : NOVALUE = ; 3056 ; 3057 !++ ; 3058 ! FUNCTIONAL DESCRIPTION: ; 3059 ! ; 3060 ! This routine will delete this process. ; 3061 ! ; 3062 ! CALLING SEQUENCE: ; 3063 ! ; 3064 ! SY_LOGOUT (); ; 3065 ! ; 3066 ! INPUT PARAMETERS: ; 3067 ! ; 3068 ! None. ; 3069 ! ; 3070 ! IMPLICIT INPUTS: ; 3071 ! ; 3072 ! None. ; 3073 ! ; 3074 ! OUTPUT PARAMETERS: ; 3075 ! ; 3076 ! None. ; 3077 ! ; 3078 ! IMPLICIT OUTPUTS: ; 3079 ! ; 3080 ! None. ; 3081 ! ; 3082 ! COMPLETION CODES: ; 3083 ! ; 3084 ! None. ; 3085 ! ; 3086 ! SIDE EFFECTS: ; 3087 ! ; 3088 ! None. ; 3089 ! ; 3090 !-- ; 3091 ; 3092 BEGIN ; 3093 $DELPRC (); ; 3094 END; ! End of SY_LOGOUT .EXTRN SYS$DELPRC .ENTRY SY_LOGOUT, ^M<> ;SY_LOGOUT, Save nothing ; 3055 CLRQ -(SP) ;-(SP) ; 3093 CALLS #2, G^SYS$DELPRC ;#2, SYS$DELPRC ; RET ; ; 3055 ; Routine Size: 12 bytes, Routine Base: $CODE$ + 093E ; 3095 ; 3096 %SBTTL 'SY_DISMISS - Sleep for N seconds' ; 3097 ; 3098 GLOBAL ROUTINE SY_DISMISS (SECONDS) : NOVALUE = ; 3099 ; 3100 !++ ; 3101 ! FUNCTIONAL DESCRIPTION: ; 3102 ! ; 3103 ! This routine is called to cause KERMIT to sleep for the ; 3104 ! specified number of seconds. ; 3105 ! ; 3106 ! CALLING SEQUENCE: ; 3107 ! ; 3108 ! SY_DISMISS(Number of seconds); ; 3109 ! ; 3110 ! INPUT PARAMETERS: ; 3111 ! ; 3112 ! Number of seconds to sleep. ; 3113 ! ; 3114 ! IMPLICIT INPUTS: ; 3115 ! ; 3116 ! None. ; 3117 ! ; 3118 ! OUTPUT PARAMETERS: ; 3119 ! ; 3120 ! None. ; 3121 ! ; 3122 ! IMPLICIT OUTPUTS: ; 3123 ! ; 3124 ! None. ; 3125 ! ; 3126 ! COMPLETION CODES: ; 3127 ! ; 3128 ! None. ; 3129 ! ; 3130 ! SIDE EFFECTS: ; 3131 ! ; 3132 ! None. ; 3133 ! ; 3134 !-- ; 3135 ; 3136 BEGIN ; 3137 ; 3138 LOCAL ; 3139 STATUS, ; 3140 TOTAL_TIME : VECTOR [2, LONG]; ! Quad word for length of time to sleep ; 3141 ; 3142 IF .SECONDS EQL 0 THEN RETURN KER_NORMAL; ; 3143 ; 3144 TOTAL_TIME [0] = -.SECONDS*10*1000*1000; ; 3145 TOTAL_TIME [1] = -1; ; 3146 STATUS = $SETIMR (EFN = 1, DAYTIM = TOTAL_TIME); ; 3147 ; 3148 IF NOT .STATUS THEN LIB$SIGNAL (.STATUS); ; 3149 ; 3150 STATUS = $WAITFR (EFN = 1); ; 3151 ; 3152 IF NOT .STATUS THEN LIB$SIGNAL (.STATUS); ; 3153 ; 3154 END; ! End of SY_DISMISS(time) .EXTRN SYS$SETIMR .ENTRY SY_DISMISS, ^M ;SY_DISMISS, Save R2,R3 ; 3098 MOVAB G^LIB$SIGNAL, R3 ;LIB$SIGNAL, R3 ; SUBL2 #8, SP ;#8, SP ; TSTL 4(AP) ;SECONDS ; 3142 BEQL 2$ ;2$ ; MULL3 #10000000, 4(AP), R0 ;#10000000, SECONDS, R0 ; 3144 MNEGL R0, (SP) ;R0, TOTAL_TIME ; MNEGL #1, 4(SP) ;#1, TOTAL_TIME+4 ; 3145 CLRQ -(SP) ;-(SP) ; 3146 PUSHAB 8(SP) ;TOTAL_TIME ; PUSHL #1 ;#1 ; CALLS #4, G^SYS$SETIMR ;#4, SYS$SETIMR ; MOVL R0, R2 ;R0, STATUS ; BLBS R2, 1$ ;STATUS, 1$ ; 3148 PUSHL R2 ;STATUS ; CALLS #1, (R3) ;#1, LIB$SIGNAL ; 1$: PUSHL #1 ;#1 ; 3150 CALLS #1, G^SYS$WAITFR ;#1, SYS$WAITFR ; MOVL R0, R2 ;R0, STATUS ; BLBS R2, 2$ ;STATUS, 2$ ; 3152 PUSHL R2 ;STATUS ; CALLS #1, (R3) ;#1, LIB$SIGNAL ; 2$: RET ; ; 3098 ; Routine Size: 79 bytes, Routine Base: $CODE$ + 094A ; 3155 ; 3156 %SBTTL 'SY_TIME - Return elapsed time' ; 3157 ; 3158 GLOBAL ROUTINE SY_TIME = ; 3159 ; 3160 !++ ; 3161 ! FUNCTIONAL DESCRIPTION: ; 3162 ! ; 3163 ! This routine will return the elapsed time to the calling routine. ; 3164 ! This will allow for the calculation of the effective baud rate. ; 3165 ! ; 3166 ! CALLING SEQUENCE: ; 3167 ! ; 3168 ! TIME = SY_TIME (); ; 3169 ! ; 3170 ! INPUT PARAMETERS: ; 3171 ! ; 3172 ! None. ; 3173 ! ; 3174 ! IMPLICIT INPUTS: ; 3175 ! ; 3176 ! None. ; 3177 ! ; 3178 ! OUTPUT PARAMETERS: ; 3179 ! ; 3180 ! Time in milliseconds. ; 3181 ! ; 3182 ! IMPLICIT OUTPUTS: ; 3183 ! ; 3184 ! None. ; 3185 ! ; 3186 ! COMPLETION CODES: ; 3187 ! ; 3188 ! None. ; 3189 ! ; 3190 ! SIDE EFFECTS: ; 3191 ! ; 3192 ! None. ; 3193 ! ; 3194 !-- ; 3195 ; 3196 BEGIN ; 3197 ! ; 3198 ! Local storage ; 3199 ! ; 3200 ; 3201 LOCAL ; 3202 STATUS, ! Status returned by lower level ; 3203 TIMER_MILLI_SECONDS, ! Time in milliseconds ; 3204 TIMER_REMAINDER, ! Remainder on EDIV ; 3205 TIMER_VALUE : VECTOR [2, LONG], ! Quad word TIME value ; 3206 TEN_FOURTH : VECTOR [2, LONG], ! to hold 10**4 ; 3207 TIMER_CODE; ! Type of TIMER request ; 3208 ; 3209 ! ; 3210 ! Set up the type of request we want (elapsed time) ; 3211 ! ; 3212 TIMER_CODE = 1; ; 3213 ! ; 3214 ! Get the elapsed time from VMS ; 3215 ! ; 3216 STATUS = LIB$STAT_TIMER (TIMER_CODE, TIMER_VALUE, TIMER_HANDLE); ; 3217 ; 3218 IF NOT .STATUS THEN RETURN 0; ; 3219 ; 3220 ! ; 3221 ! Compute the LONG word value from the QUAD word given ; 3222 ! ; 3223 TEN_FOURTH [0] = 1000*10; ; 3224 TEN_FOURTH [1] = 0; ; 3225 STATUS = LIB$EDIV (TEN_FOURTH, TIMER_VALUE, TIMER_MILLI_SECONDS, TIMER_REMAINDER); ; 3226 ; 3227 IF NOT .STATUS THEN RETURN 0; ; 3228 ; 3229 RETURN .TIMER_MILLI_SECONDS; ; 3230 END; ! End of SY_TIME .ENTRY SY_TIME, ^M<> ;SY_TIME, Save nothing ; 3158 SUBL2 #28, SP ;#28, SP ; MOVL #1, 8(SP) ;#1, TIMER_CODE ; 3212 PUSHAB W^U.35 ;U.35 ; 3216 PUSHAB 24(SP) ;TIMER_VALUE ; PUSHAB 16(SP) ;TIMER_CODE ; CALLS #3, G^LIB$STAT_TIMER ;#3, LIB$STAT_TIMER ; BLBC R0, 1$ ;STATUS, 1$ ; 3218 MOVZWL #10000, 12(SP) ;#10000, TEN_FOURTH ; 3223 CLRL 16(SP) ;TEN_FOURTH+4 ; 3224 PUSHAB 4(SP) ;TIMER_REMAINDER ; 3225 PUSHAB 4(SP) ;TIMER_MILLI_SECONDS ; PUSHAB 28(SP) ;TIMER_VALUE ; PUSHAB 24(SP) ;TEN_FOURTH ; CALLS #4, G^LIB$EDIV ;#4, LIB$EDIV ; BLBC R0, 1$ ;STATUS, 1$ ; 3227 MOVL (SP), R0 ;TIMER_MILLI_SECONDS, R0 ; 3196 RET ; ; 1$: CLRL R0 ;R0 ; 3158 RET ; ; ; Routine Size: 67 bytes, Routine Base: $CODE$ + 0999 ; 3231 ; 3232 %SBTTL 'XFR_STATUS - Return the transfer status' ; 3233 ; 3234 GLOBAL ROUTINE XFR_STATUS (TYPE, SUB_TYPE) : NOVALUE = ; 3235 ; 3236 !++ ; 3237 ! FUNCTIONAL DESCRIPTION: ; 3238 ! ; 3239 ! This routine is called after either a packet has been received ; 3240 ! correctly at the receive level, a packet has been sent, or ; 3241 ! either a NAK has been sent or received. ; 3242 ! ; 3243 ! CALLING SEQUENCE: ; 3244 ! ; 3245 ! XFR_STATUS (Type); ; 3246 ! ; 3247 ! INPUT PARAMETERS: ; 3248 ! ; 3249 ! Type - ASCII Characters describing the type of transfer ; 3250 ! ; 3251 ! IMPLICIT INPUTS: ; 3252 ! ; 3253 ! None. ; 3254 ! ; 3255 ! OUPTUT PARAMETERS: ; 3256 ! ; 3257 ! None. ; 3258 ! ; 3259 ! IMPLICIT OUTPUTS: ; 3260 ! ; 3261 ! None. ; 3262 ! ; 3263 ! COMPLETION CODES: ; 3264 ! ; 3265 ! None. ; 3266 ! ; 3267 ! SIDE EFFECTS: ; 3268 ! ; 3269 ! None. ; 3270 ! ; 3271 !-- ; 3272 ; 3273 BEGIN ; 3274 IF .TY_PKT THEN ; 3275 BEGIN ; 3276 SELECTONE .TYPE OF ; 3277 SET ; 3278 ; 3279 [%ASCII'R'] : ; 3280 BEGIN ; 3281 ; 3282 IF .SUB_TYPE EQL %C'P' ; 3283 THEN ; 3284 BEGIN ; 3285 TT_TEXT (UPLIT (%ASCIZ' R')); ; 3286 TT_NUMBER (.RCV_COUNT); ; 3287 END; ; 3288 ; 3289 IF .SUB_TYPE EQL %C'N' ; 3290 THEN ; 3291 BEGIN ; 3292 TT_TEXT (UPLIT (%ASCIZ' R%')); ; 3293 TT_NUMBER (.RMSG_NAKS); ; 3294 END; ; 3295 ; 3296 END; ; 3297 ; 3298 [%ASCII'S'] : ; 3299 BEGIN ; 3300 ; 3301 IF .SUB_TYPE EQL %C'P' ; 3302 THEN ; 3303 BEGIN ; 3304 TT_TEXT (UPLIT (%ASCIZ' S')); ; 3305 TT_NUMBER (.SND_COUNT); ; 3306 END; ; 3307 ; 3308 IF .SUB_TYPE EQL %C'N' ; 3309 THEN ; 3310 BEGIN ; 3311 TT_TEXT (UPLIT (%ASCIZ' S%')); ; 3312 TT_NUMBER (.SMSG_NAKS); ; 3313 END; ; 3314 ; 3315 END; ; 3316 TES; ; 3317 ; 3318 TT_OUTPUT (); ; 3319 END; ; 3320 END; ! End of XFR_STATUS .PSECT $PLIT$,NOWRT,NOEXE,2 P.AEL: .ASCII \ R\<0><0> ; ; P.AEM: .ASCII \ R%\<0> ; ; P.AEN: .ASCII \ S\<0><0> ; ; P.AEO: .ASCII \ S%\<0> ; ; .PSECT $CODE$,NOWRT,2 .ENTRY XFR_STATUS, ^M ;XFR_STATUS, Save R2,R3 ; 3234 MOVAB W^TT_NUMBER, R3 ;TT_NUMBER, R3 ; MOVAB W^TT_TEXT, R2 ;TT_TEXT, R2 ; BLBC W^TY_PKT, 6$ ;TY_PKT, 6$ ; 3274 MOVL 4(AP), R0 ;TYPE, R0 ; 3276 CMPL R0, #82 ;R0, #82 ; BNEQ 2$ ;2$ ; CMPL 8(AP), #80 ;SUB_TYPE, #80 ; 3282 BNEQ 1$ ;1$ ; PUSHAB W^P.AEL ;P.AEL ; 3285 CALLS #1, (R2) ;#1, TT_TEXT ; PUSHL W^RCV_COUNT ;RCV_COUNT ; 3286 CALLS #1, (R3) ;#1, TT_NUMBER ; 1$: CMPL 8(AP), #78 ;SUB_TYPE, #78 ; 3289 BNEQ 5$ ;5$ ; PUSHAB W^P.AEM ;P.AEM ; 3292 CALLS #1, (R2) ;#1, TT_TEXT ; PUSHL W^RMSG_NAKS ;RMSG_NAKS ; 3293 BRB 4$ ;4$ ; 2$: CMPL R0, #83 ;R0, #83 ; 3276 BNEQ 5$ ;5$ ; CMPL 8(AP), #80 ;SUB_TYPE, #80 ; 3301 BNEQ 3$ ;3$ ; PUSHAB W^P.AEN ;P.AEN ; 3304 CALLS #1, (R2) ;#1, TT_TEXT ; PUSHL W^SND_COUNT ;SND_COUNT ; 3305 CALLS #1, (R3) ;#1, TT_NUMBER ; 3$: CMPL 8(AP), #78 ;SUB_TYPE, #78 ; 3308 BNEQ 5$ ;5$ ; PUSHAB W^P.AEO ;P.AEO ; 3311 CALLS #1, (R2) ;#1, TT_TEXT ; PUSHL W^SMSG_NAKS ;SMSG_NAKS ; 3312 4$: CALLS #1, (R3) ;#1, TT_NUMBER ; 5$: CALLS #0, W^TT_OUTPUT ;#0, TT_OUTPUT ; 3318 6$: RET ; ; 3234 ; Routine Size: 140 bytes, Routine Base: $CODE$ + 09DC ; 3321 ; 3322 %SBTTL 'CRCCLC - Calculate the CRC-CCITT for a message' ; 3323 ; 3324 GLOBAL ROUTINE CRCCLC (POINTER, SIZE) = ; 3325 ; 3326 !++ ; 3327 ! FUNCTIONAL DESCRIPTION: ; 3328 ! ; 3329 ! This routine will calculate the CRC for a message. It will use ; 3330 ! the VAX LIB$ routine to do all the work. ; 3331 ! ; 3332 ! CALLING SEQUENCE: ; 3333 ! ; 3334 ! CRC = CRCCLC(Pointer, Size) ; 3335 ! ; 3336 ! INPUT PARAMETERS: ; 3337 ! ; 3338 ! Pointer - Character pointer to the message. ; 3339 ! Size - Length of the message. ; 3340 ! ; 3341 ! IMPLICIT INPUTS: ; 3342 ! ; 3343 ! None. ; 3344 ! ; 3345 ! OUPTUT PARAMETERS: ; 3346 ! ; 3347 ! CRC for the message. ; 3348 ! ; 3349 ! IMPLICIT OUTPUTS: ; 3350 ! ; 3351 ! None. ; 3352 ! ; 3353 ! COMPLETION CODES: ; 3354 ! ; 3355 ! None. ; 3356 ! ; 3357 ! SIDE EFFECTS: ; 3358 ! ; 3359 ! None. ; 3360 ! ; 3361 !-- ; 3362 ; 3363 BEGIN ; 3364 LOCAL ; 3365 TEMP_DESC : BLOCK [8, BYTE], ! Temporary descriptor ; 3366 CRC_INITIAL; ! Initial CRC value ; 3367 ; 3368 CRC_INITIAL = 0; ! Set the initial value ; 3369 TEMP_DESC [DSC$B_CLASS] = DSC$K_CLASS_S; ; 3370 TEMP_DESC [DSC$B_DTYPE] = DSC$K_DTYPE_T; ; 3371 TEMP_DESC [DSC$W_LENGTH] = .SIZE; ; 3372 TEMP_DESC [DSC$A_POINTER] = .POINTER; ; 3373 ; 3374 RETURN LIB$CRC (CRC_TABLE, CRC_INITIAL, TEMP_DESC); ; 3375 ; 3376 END; ! End of CRCCLC .ENTRY CRCCLC, ^M<> ;CRCCLC, Save nothing ; 3324 SUBL2 #8, SP ;#8, SP ; CLRL -(SP) ;CRC_INITIAL ; 3368 MOVW #270, 6(SP) ;#270, TEMP_DESC+2 ; 3370 MOVW 8(AP), 4(SP) ;SIZE, TEMP_DESC ; 3371 MOVL 4(AP), 8(SP) ;POINTER, TEMP_DESC+4 ; 3372 PUSHAB 4(SP) ;TEMP_DESC ; 3374 PUSHAB 4(SP) ;CRC_INITIAL ; PUSHAB W^U.34 ;U.34 ; CALLS #3, G^LIB$CRC ;#3, LIB$CRC ; RET ; ; 3324 ; Routine Size: 41 bytes, Routine Base: $CODE$ + 0A68 ; 3377 %SBTTL 'KRM_ERROR - Issue an error message given error code' ; 3378 ; 3379 GLOBAL ROUTINE KRM_ERROR (ERROR_CODE) : NOVALUE = ; 3380 ; 3381 !++ ; 3382 ! FUNCTIONAL DESCRIPTION: ; 3383 ! ; 3384 ! This routine will cause an error message to be issued to the ; 3385 ! user's terminal and/or a message to be sent to the remote KERMIT. ; 3386 ! ; 3387 ! CALLING SEQUENCE: ; 3388 ! ; 3389 ! KRM_ERROR(KER_xxxxxx); ; 3390 ! ; 3391 ! INPUT PARAMETERS: ; 3392 ! ; 3393 ! KER_xxxxxx - Error code from KERERR.REQ ; 3394 ! ; 3395 ! IMPLICIT INPUTS: ; 3396 ! ; 3397 ! None. ; 3398 ! ; 3399 ! OUTPUT PARAMETERS: ; 3400 ! ; 3401 ! None. ; 3402 ! ; 3403 ! IMPLICIT OUTPUTS: ; 3404 ! ; 3405 ! None. ; 3406 ! ; 3407 ! COMPLETION CODES: ; 3408 ! ; 3409 ! None. ; 3410 ! ; 3411 ! SIDE EFFECTS: ; 3412 ! ; 3413 ! None. ; 3414 ! ; 3415 !-- ; 3416 ; 3417 BEGIN ; 3418 LIB$SIGNAL (.ERROR_CODE); ; 3419 END; ! End of KRM_ERROR .ENTRY KRM_ERROR, ^M<> ;KRM_ERROR, Save nothing ; 3379 PUSHL 4(AP) ;ERROR_CODE ; 3418 CALLS #1, G^LIB$SIGNAL ;#1, LIB$SIGNAL ; RET ; ; 3379 ; Routine Size: 13 bytes, Routine Base: $CODE$ + 0A91 ; 3420 ; 3421 %SBTTL 'KERM_HANDLER - Condition handler' ; 3422 ROUTINE KERM_HANDLER = ; 3423 ; 3424 !++ ; 3425 ! FUNCTIONAL DESCRIPTION: ; 3426 ! ; 3427 ! This is the condition handler for KERMIT-32. ; 3428 ! ; 3429 ! CALLING SEQUENCE: ; 3430 ! ; 3431 ! Called via LIB$SIGNAL. ; 3432 ! ; 3433 ! INPUT PARAMETERS: ; 3434 ! ; 3435 ! None. ; 3436 ! ; 3437 ! IMPLICIT INPUTS: ; 3438 ! ; 3439 ! None. ; 3440 ! ; 3441 ! OUTPUT PARAMETERS: ; 3442 ! ; 3443 ! None. ; 3444 ! ; 3445 ! IMPLICIT OUTPUTS: ; 3446 ! ; 3447 ! None. ; 3448 ! ; 3449 ! COMPLETION CODES: ; 3450 ! ; 3451 ! None. ; 3452 ! ; 3453 ! SIDE EFFECTS: ; 3454 ! ; 3455 ! None. ; 3456 ! ; 3457 !-- ; 3458 ; 3459 BEGIN ; 3460 ; 3461 BIND ; 3462 FACILITY_DESC = %ASCID'KERMIT32'; ; 3463 ; 3464 BUILTIN ; 3465 AP; ; 3466 ; 3467 LOCAL ; 3468 PUTMSG_VECTOR : VECTOR [10, LONG], ; 3469 SIGARGLST; ! Address of the signal argument list ; 3470 ; 3471 MAP ; 3472 AP : REF BLOCK [, BYTE], ; 3473 SIGARGLST : REF BLOCK [, BYTE]; ; 3474 ; 3475 !++ ; 3476 ! ; 3477 ! Routine to do the actual output of the error message ; 3478 ! ; 3479 !-- ; 3480 ; 3481 ROUTINE HANDLE_MSG = ; 3482 BEGIN ; 3483 ; 3484 BUILTIN ; 3485 AP; ; 3486 ; 3487 LOCAL ; 3488 ERR_DESC, ! Address of the error descriptor ; 3489 POINTER; ! Pointer to get characters ; 3490 ; 3491 MAP ; 3492 ERR_DESC : REF BLOCK [8, BYTE], ; 3493 AP : REF BLOCK [, BYTE]; ; 3494 ; 3495 ERR_DESC = .AP [4, 0, 32, 0]; ; 3496 ; 3497 IF .TERM_FLAG THEN SND_ERROR (.ERR_DESC [DSC$W_LENGTH], .ERR_DESC [DSC$A_POINTER]); ; 3498 ; 3499 IF NOT .CONNECT_FLAG ; 3500 THEN ; 3501 BEGIN ; 3502 POINTER = CH$PTR (.ERR_DESC [DSC$A_POINTER]); ; 3503 ; 3504 INCR I FROM 1 TO .ERR_DESC [DSC$W_LENGTH] DO ; 3505 TT_CHAR (CH$RCHAR_A (POINTER)); ; 3506 ; 3507 TT_CRLF (); ; 3508 END; ; 3509 ; 3510 RETURN 0; ; 3511 END; .PSECT $PLIT$,NOWRT,NOEXE,2 P.AEQ: .ASCII \KERMIT32\ ; ; P.AEP: .LONG 17694728 ; ; .ADDRESS P.AEQ ; ; FACILITY_DESC= P.AEP .PSECT $CODE$,NOWRT,2 HANDLE_MSG: .WORD ^M ;Save R2,R3,R4 ; 3481 MOVL 4(AP), R2 ;4(AP), ERR_DESC ; 3495 BLBC W^TERM_FLAG, 1$ ;TERM_FLAG, 1$ ; 3497 PUSHL 4(R2) ;4(ERR_DESC) ; MOVZWL (R2), -(SP) ;(ERR_DESC), -(SP) ; CALLS #2, W^SND_ERROR ;#2, SND_ERROR ; 1$: BLBS W^CONNECT_FLAG, 4$ ;CONNECT_FLAG, 4$ ; 3499 MOVL 4(R2), R4 ;4(ERR_DESC), POINTER ; 3502 MOVZWL (R2), R3 ;(ERR_DESC), R3 ; 3504 CLRL R2 ;I ; BRB 3$ ;3$ ; 2$: MOVZBL (R4)+, -(SP) ;(POINTER)+, -(SP) ; 3505 CALLS #1, W^TT_CHAR ;#1, TT_CHAR ; 3$: AOBLEQ R3, R2, 2$ ;R3, I, 2$ ; 3504 CALLS #0, W^TT_CRLF ;#0, TT_CRLF ; 3507 4$: CLRL R0 ;R0 ; 3482 RET ; ; 3481 ; Routine Size: 58 bytes, Routine Base: $CODE$ + 0A9E ; 3512 SIGARGLST = .AP [CHF$L_SIGARGLST]; ; 3513 ; 3514 IF .SIGARGLST [CHF$L_SIG_NAME] GEQ %X'400' AND .SIGARGLST [CHF$L_SIG_NAME] LEQ %X'5FF' ; 3515 THEN ; 3516 RETURN SS$_RESIGNAL; ; 3517 ; 3518 PUTMSG_VECTOR [0] = .SIGARGLST [CHF$L_SIG_ARGS] - 2; ! No PC and PSL ; 3519 PUTMSG_VECTOR [1] = .SIGARGLST [CHF$L_SIG_NAME]; ; 3520 PUTMSG_VECTOR [2] = .SIGARGLST [CHF$L_SIG_ARGS] - 3; ; 3521 ; 3522 INCR I FROM 0 TO .SIGARGLST [CHF$L_SIG_ARGS] - 4 DO ; 3523 PUTMSG_VECTOR [.I + 3] = .(SIGARGLST [CHF$L_SIG_ARG1] + (.I*4)); ; 3524 ; 3525 $PUTMSG (MSGVEC = PUTMSG_VECTOR, ACTRTN = HANDLE_MSG, FACNAM = FACILITY_DESC); ; 3526 RETURN SS$_CONTINUE; ; 3527 END; ! End of KERM_HANDLER .EXTRN SYS$PUTMSG ;KERM_HANDLER U.24: .WORD ^M ;Save R2 ; 3422 SUBL2 #40, SP ;#40, SP ; MOVL 4(AP), R1 ;4(AP), SIGARGLST ; 3512 CMPL 4(R1), #1024 ;4(SIGARGLST), #1024 ; 3514 BLSS 1$ ;1$ ; CMPL 4(R1), #1535 ;4(SIGARGLST), #1535 ; BGTR 1$ ;1$ ; MOVZWL #2328, R0 ;#2328, R0 ; 3516 RET ; ; 1$: SUBL3 #2, (R1), (SP) ;#2, (SIGARGLST), PUTMSG_VECTOR ; 3518 MOVL 4(R1), 4(SP) ;4(SIGARGLST), PUTMSG_VECTOR+4 ; 3519 SUBL3 #3, (R1), 8(SP) ;#3, (SIGARGLST), PUTMSG_VECTOR+8 ; 3520 SUBL3 #4, (R1), R2 ;#4, (SIGARGLST), R2 ; 3522 MNEGL #1, R0 ;#1, I ; BRB 3$ ;3$ ; 2$: MOVL 8(R1)[R0], 12(SP)[R0] ;8(SIGARGLST)[I], PUTMSG_VECTOR+12[I] ; 3523 3$: AOBLEQ R2, R0, 2$ ;R2, I, 2$ ; 3522 CLRL -(SP) ;-(SP) ; 3525 PUSHAB W^FACILITY_DESC ;FACILITY_DESC ; PUSHAB W^HANDLE_MSG ;HANDLE_MSG ; PUSHAB 12(SP) ;PUTMSG_VECTOR ; CALLS #4, G^SYS$PUTMSG ;#4, SYS$PUTMSG ; MOVL #1, R0 ;#1, R0 ; 3459 RET ; ; 3422 ; Routine Size: 93 bytes, Routine Base: $CODE$ + 0AD8 ; 3528 %SBTTL 'End of KERMIT.B32' ; 3529 END ! End of module ; 3530 ; 3531 ELUDOM ; PSECT SUMMARY ; ; Name Bytes Attributes ; ; $GLOBAL$ 92 NOVEC, WRT, RD ,NOEXE,NOSHR, LCL, REL, CON,NOPIC,ALIGN(2) ; $OWN$ 444 NOVEC, WRT, RD ,NOEXE,NOSHR, LCL, REL, CON,NOPIC,ALIGN(2) ; _LIB$KEY0$ 180 NOVEC,NOWRT, RD , EXE, SHR, LCL, REL, CON, PIC,ALIGN(1) ; _LIB$STATE$ 1126 NOVEC,NOWRT, RD , EXE, SHR, LCL, REL, CON, PIC,ALIGN(0) ; _LIB$KEY1$ 849 NOVEC,NOWRT, RD , EXE, SHR, LCL, REL, CON, PIC,ALIGN(0) ; $CODE$ 2869 NOVEC,NOWRT, RD , EXE,NOSHR, LCL, REL, CON,NOPIC,ALIGN(2) ; . ABS . 0 NOVEC,NOWRT,NORD ,NOEXE,NOSHR, LCL, ABS, CON,NOPIC,ALIGN(0) ; $PLIT$ 1764 NOVEC,NOWRT, RD ,NOEXE,NOSHR, LCL, REL, CON,NOPIC,ALIGN(2) ; LIBRARY STATISTICS ; ; -------- Symbols -------- Blocks ; File Total Loaded Percent Read ; ; SYS$SYSROOT:[SYSLIB]STARLET.L32;1 5809 39 0 237 ; SYS$SYSROOT:[SYSLIB]TPAMAC.L32;1 39 30 76 25 ; COMMAND QUALIFIERS ; BLISS KERMIT/LIST=KERMIT.MAR/MACHINE_CODE=(ASSEM,NOBINARY,UNIQUE)/NOOBJECT/SOURCE=NOHEADER ; Compilation Complete .END MAIN_ROUTINE