; 0001 MODULE KERMIT (IDENT = '1.0.000', ; 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 Create this program. ; 0031 !-- ; 0032 %SBTTL 'Routine definitions -- Forwards' ; 0033 ; 0034 ! ; 0035 ! ; 0036 ! Forward definitions ; 0037 ! ; 0038 ; 0039 ! Command processing routines ; 0040 ; 0041 FORWARD ROUTINE ; 0042 COMND, ! Process a command ; 0043 COMND_HELP : NOVALUE, ! Process the HELP command ; 0044 COMND_SHOW : NOVALUE, ! Process the SHOW command ; 0045 STORE_TEXT, ! Routine to store a file name ; 0046 COPY_DEVICE, ! Copy device name (TERM_xxxx) ; 0047 COPY_FILE, ! Copy file name (FILE_xxx) ; 0048 STORE_DEBUG, ! Store the debuging flag ; 0049 STORE_FTP, ! Store the file type ; 0050 STORE_ECHO, ! Store the local echo flag ; 0051 CHECK_PACKET_LEN, ! Validate PACKET length given ; 0052 CHECK_NPAD, ! Validate the number of pad characters ; 0053 CHECK_PAD_CHAR, ! Validate the padding character being set ; 0054 CHECK_EOL, ! Validate EOL character given. ; 0055 HELP_START, ! Start of the HELP command (set TPA$V_BLANK) ; 0056 HELP_DONE; ! End of the HELP command (clear TPA$V_BLANK) ; 0057 ; 0058 ! ; 0059 ! Error handling routines ; 0060 ! ; 0061 ; 0062 FORWARD ROUTINE ; 0063 KERM_HANDLER; ! Condition handler ; 0064 %SBTTL 'Include files' ; 0065 ; 0066 ! ; 0067 ! INCLUDE FILES: ; 0068 ! ; 0069 ; 0070 LIBRARY 'SYS$LIBRARY:STARLET'; ; 0071 ; 0072 LIBRARY 'SYS$LIBRARY:TPAMAC'; ; 0073 ; 0074 REQUIRE 'KERCOM'; ! Common definitions ; 0231 ; 0232 REQUIRE 'KERERR'; ! Error message symbol definitions ; 0281 ; 0282 %SBTTL 'Structure definitions -- $GETDVI arguments' ; 0283 ! ; 0284 ! $GETDVI interface fields and structure definition ; 0285 ! ; 0286 ; 0287 LITERAL ; 0288 DVI_SIZE = 3; ! Length of a DVI item list entry ; 0289 ; 0290 ! ; 0291 ! Fields for accessing the items in a DVI item list ; 0292 ! ; 0293 ; 0294 FIELD ; 0295 DVI_FIELDS = ; 0296 SET ; 0297 DVI_BFR_LENGTH = [0, 0, 16, 0], ; 0298 DVI_ITEM_CODE = [0, 16, 16, 0], ; 0299 DVI_BFR_ADDRESS = [1, 0, 32, 0], ; 0300 DVI_RTN_LENGTH = [2, 0, 32, 0] ; 0301 TES; ; 0302 ; 0303 ! ; 0304 ! Structure definition for item list ; 0305 ; 0306 STRUCTURE ; 0307 DVI_ITEM_LIST [I, O, P, S, E; N] = ; 0308 [(N + 1)*DVI_SIZE*4] ; 0309 (DVI_ITEM_LIST + ((I*DVI_SIZE) + O)*4); ; 0310 ; 0311 %SBTTL 'Macro definitions' ; 0312 ; 0313 ! ; 0314 ! MACROS: ; 0315 ! ; 0316 ; 0317 MACRO ; M 0318 TPARSE_ARGS = ; M 0319 BUILTIN AP; ; M 0320 MAP AP : REF BLOCK [,BYTE]; ; 0321 %; ; 0322 ; 0323 ! ; 0324 ! EQUATED SYMBOLS: ; 0325 ! ; 0326 ! Command offsets ; 0327 ; 0328 LITERAL ; 0329 CMD_CONN = 1, ! Connect command ; 0330 CMD_EXIT = 2, ! Exit command ; 0331 CMD_HELP = 3, ! Help command ; 0332 CMD_RECE = 4, ! Receive command ; 0333 CMD_SET = 5, ! Set command ; 0334 CMD_SEND = 6, ! Send command ; 0335 CMD_SHOW = 7, ! Show command ; 0336 CMD_SERVER = 8; ! SERVER command ; 0337 ; 0338 ! Items to show ; 0339 ; 0340 LITERAL ; 0341 SHOW_ALL = 1, ! Show everything ; 0342 SHOW_DEB = 2, ! Show debugging flag ; 0343 SHOW_DEL = 3, ! Show delay ; 0344 SHOW_ESC = 4, ! Show ESCAPE character ; 0345 SHOW_FTP = 5, ! Show the file type ; 0346 SHOW_LIN = 6, ! Show the line we are using ; 0347 SHOW_ECH = 7, ! Show the echo flag ; 0348 SHOW_SEN = 8, ! Show send parameters ; 0349 SHOW_REC = 9; ! Show the receive parameters ; 0350 ; 0351 ! Constants ; 0352 ; 0353 LITERAL ; 0354 CMD_BFR_LENGTH = 132, ! Command buffer length ; 0355 OUT_BFR_LENGTH = 80, ! Output buffer length (SHOW cmd) ; 0356 TERM_LENGTH = 80, ! Length of a terminal name ; 0357 HELP_LENGTH = 132, ! Length of the help buffer ; 0358 TEMP_LENGTH = 132; ! Length of the temporary area ; 0359 ; 0360 ! ; 0361 ! ; 0362 ! GLOBAL STORAGE: ; 0363 ! ; 0364 ; 0365 GLOBAL ; 0366 TERM_NAME : VECTOR [CH$ALLOCATION(TERM_LENGTH)], ; 0367 TERM_DESC : BLOCK [8, BYTE]; ! Terminal name descriptor ; 0368 ; 0369 ! ; 0370 ! OWN STORAGE: ; 0371 ! ; 0372 ; 0373 OWN ; 0374 ; 0375 ! Command scanning information ; 0376 ; 0377 TPARSE_BLOCK : BLOCK [TPA$K_LENGTH0, BYTE] ; 0378 INITIAL (TPA$K_COUNT0, ! Longword count ; 0379 TPA$M_ABBREV), ! Allow abbreviations ; 0380 COMMAND, ! Type of command we are doing ; 0381 SHOW_TYPE, ! Type of show command ; 0382 ; 0383 ! Misc constants. ; 0384 ; 0385 TEMP_DESC : BLOCK [8, BYTE], ! Temporary descriptor ; 0386 TEMP_NAME : VECTOR [CH$ALLOCATION(TEMP_LENGTH)], ; 0387 ; 0388 ESCAPE_CHR; ! Escape character for CONNECT ; 0389 ; 0390 ! ; 0391 ! ; 0392 ! ; 0393 ! EXTERNAL REFERENCES: ; 0394 ! ; 0395 ; 0396 EXTERNAL ROUTINE ; 0397 ! ; 0398 ! Library routines ; 0399 ! ; 0400 LIB$GET_FOREIGN : ADDRESSING_MODE(GENERAL), ; 0401 LIB$GET_INPUT : ADDRESSING_MODE(GENERAL), ; 0402 LIB$PUT_OUTPUT : ADDRESSING_MODE(GENERAL), ; 0403 LIB$TPARSE : ADDRESSING_MODE(GENERAL), ; 0404 LIB$SIGNAL : ADDRESSING_MODE(GENERAL) NOVALUE, ; 0405 LIB$ESTABLISH : ADDRESSING_MODE(GENERAL), ; 0406 ! ; 0407 ! KERMSG - KERMIT Message processing routines ; 0408 ! ; 0409 SEND_SWITCH, ! Send a file ; 0410 REC_SWITCH, ! Receive a file ; 0411 SERVER : NOVALUE, ! Server mode processing ; 0412 SND_ERROR : NOVALUE, ! Send E packet to remote ; 0413 MSG_INIT : NOVALUE, ! Initialization routine ; 0414 ! ; 0415 ! KERFIL - File processing. ; 0416 ! ; 0417 FILE_INIT : NOVALUE, ! Initialization routine ; 0418 ; 0419 ! ; 0420 ! KERTRM - Terminal processing. ; 0421 ! ; 0422 TERM_OPEN, ! Open the terminal line ; 0423 TERM_CLOSE, ! Close the terminal line ; 0424 TT_INIT : NOVALUE, ! Initialization routine ; 0425 TT_CHAR : NOVALUE, ! Output a single character ; 0426 TT_CRLF : NOVALUE; ! Output the line ; 0427 ! ; 0428 ! EXTERNAL Storage: ; 0429 ! ; 0430 ; 0431 EXTERNAL ; 0432 ! ; 0433 ! KERMSG storage ; 0434 ! ; 0435 ! Receive parameters ; 0436 ; 0437 RCV_PKT_SIZE, ! Receive packet size ; 0438 RCV_NPAD, ! Padding length ; 0439 RCV_PADCHAR, ! Padding character ; 0440 RCV_TIMEOUT, ! Time out ; 0441 RCV_EOL, ! EOL character ; 0442 RCV_QUOTE_CHR, ! Quote character ; 0443 RCV_8QUOTE_CHR, ! 8-bit quoting character ; 0444 ; 0445 ! Send parameters ; 0446 ; 0447 SND_PKT_SIZE, ! Send packet size ; 0448 SND_NPAD, ! Padding length ; 0449 SND_PADCHAR, ! Padding character ; 0450 SND_TIMEOUT, ! Time out ; 0451 SND_EOL, ! EOL character ; 0452 SND_QUOTE_CHR, ! Quote character ; 0453 SND_8QUOTE_CHR, ! 8-bit quoting character ; 0454 ; 0455 ! Misc constants. ; 0456 ; 0457 FILE_SIZE, ! Number of characters in FILE_NAME ; 0458 FILE_NAME : VECTOR [CH$ALLOCATION(MAX_FILE_NAME)], ; 0459 DELAY, ! Amount of time to delay ; 0460 DEBUG_FLAG, ! Debugging mode on/off ; 0461 WARN_FLAG, ! File warning flag ; 0462 ECHO_FLAG, ! Local echo flag ; 0463 CONNECT_FLAG; ! True if SYS$OUTPUT and line ; 0464 ! xfering over are the same. ; 0465 ! ; 0466 ! KERFIL storage ; 0467 ! ; 0468 EXTERNAL ; 0469 FILE_TYPE, ! Type of file being processed ; 0470 FILE_DESC : BLOCK [8, BYTE]; ! Descriptor for the file name ; 0471 ; 0472 ! ; 0473 ! KERTRM storage ; 0474 ! ; 0475 EXTERNAL ; 0476 TERM_FLAG; ! Terminal open flag ; 0477 ; 0478 ! ; 0479 ! ; 0480 !++ ; 0481 ! ; 0482 !The following are the command state tables for the KERMIT-32 ; 0483 !command processing. ; 0484 ! ; 0485 !-- ; 0486 ; 0487 $INIT_STATE (KERMIT_STATE, KERMIT_KEY); ; 0488 ; P 0489 $STATE (START, ; P 0490 ('CONNECT', CONN_STATE, , CMD_CONN, COMMAND), ; P 0491 ('EXIT', DONE_STATE, , CMD_EXIT, COMMAND), ; P 0492 ('HELP', HELP_STATE, HELP_START, CMD_HELP, COMMAND), ; P 0493 ('QUIT', DONE_STATE, , CMD_EXIT, COMMAND), ; P 0494 ('RECEIVE', REC_STATE, , CMD_RECE, COMMAND), ; P 0495 ('SET', SET_STATE, , CMD_SET, COMMAND), ; P 0496 ('SEND', SEND_STATE, , CMD_SEND, COMMAND), ; P 0497 ('SERVER', DONE_STATE, , CMD_SERVER, COMMAND), ; P 0498 ('SHOW', SHOW_STATE, , CMD_SHOW, COMMAND) ; 0499 ) ; 0500 ; 0501 !++ ; 0502 ! CONNECT command. Format is: ; 0503 ! ; 0504 ! Kermit-32>CONNECT device ; 0505 ! ; 0506 ! Where: ; 0507 ! Device - Terminal line to connect to ; 0508 ! ; 0509 !-- ; 0510 ; P 0511 $STATE (CONN_STATE, ; P 0512 (TPA$_SYMBOL, DONE_STATE) ; 0513 ) ; 0514 ; 0515 !++ ; 0516 ! EXIT command. Format is: ; 0517 ! ; 0518 ! Kermit-32>EXIT ; 0519 ! ; 0520 ! Just exit back to VMS. ; 0521 ! ; 0522 !-- ; 0523 ; 0524 !++ ; 0525 ! HELP command. Format is: ; 0526 ! ; 0527 ! Kermit-32>HELP ; 0528 ! ; 0529 ! Do HELP processing for KERMIT-32. ; 0530 ! ; 0531 !-- ; 0532 ; P 0533 $STATE (HELP_STATE, ; P 0534 (TPA$_ANY, HELP_STATE, STORE_TEXT), ; P 0535 (TPA$_LAMBDA, DONE_STATE, HELP_DONE) ; 0536 ) ; 0537 ; 0538 %SBTTL 'QUIT command table' ; 0539 ; 0540 !++ ; 0541 ! QUIT command. Format is: ; 0542 ! ; 0543 ! Kermit-32>QUIT ; 0544 ! ; 0545 ! This command will just exit back to VMS. ; 0546 ! ; 0547 !-- ; 0548 %SBTTL 'RECEIVE command table' ; 0549 ; 0550 !++ ; 0551 ! RECEIVE command. Format is: ; 0552 ! ; 0553 ! Kermit-32>RECEIVE file-specification ; 0554 ! ; 0555 ! This command will cause KERMIT to receive a file from the micro. ; 0556 ! It will assume that it is to used what ever line it currently is ; 0557 ! associated with (CONNECT or SET LINE). ; 0558 ! ; 0559 !-- ; 0560 ; P 0561 $STATE (REC_STATE, ; P 0562 (TPA$_ANY, REC_STATE, STORE_TEXT), ; P 0563 (TPA$_LAMBDA, DONE_STATE, COPY_FILE) ; 0564 ) ; 0565 %SBTTL 'SET command tables' ; 0566 ; 0567 !++ ; 0568 ! SET command. Format is: ; 0569 ! ; 0570 ! Kermit-32>SET parameter ; 0571 ! ; 0572 ! Where: ; 0573 ! Parameter - One of the following: ; 0574 ! SEND ; 0575 ! RECEIVE ; 0576 ! ; 0577 !-- ; 0578 ; P 0579 $STATE (SET_STATE, ; P 0580 ('DEBUGGING', SET_DEB_STATE), ; P 0581 ('DELAY', SET_DEL_STATE), ; P 0582 ('ESCAPE', SET_ESC_STATE), ; P 0583 ('FILE_TYPE', SET_FIL_STATE), ; P 0584 ('LINE', SET_LIN_STATE), ; P 0585 ('LOCAL_ECHO', SET_ECH_STATE), ; P 0586 ('RECEIVE', SET_REC_STATE), ; P 0587 ('SEND', SET_SND_STATE) ; 0588 ) ; 0589 ; 0590 !++ ; 0591 ! ; 0592 ! SET DEBUGGING command. The format is: ; 0593 ! ; 0594 ! Kermit-32>SET DEBUGGING (on/off) ; 0595 ! ; 0596 ! Where: ; 0597 ! on/off is either the ON or OFF keyword. ; 0598 ! ; 0599 !-- ; 0600 ; P 0601 $STATE (SET_DEB_STATE, ; P 0602 ('OFF', DONE_STATE, STORE_DEBUG, , ,FALSE), ; P 0603 ('ON', DONE_STATE, STORE_DEBUG, , ,TRUE) ; 0604 ) ; 0605 ; 0606 !++ ; 0607 ! ; 0608 ! SET DELAY command. The format is: ; 0609 ! ; 0610 ! Kermit-32>SET DELAY ; 0611 ! ; 0612 ! Where: ; 0613 ! is the number of seconds to delay before sending the ; 0614 ! SEND-INIT packet. ; 0615 !-- ; 0616 ; P 0617 $STATE (SET_DEL_STATE, ; P 0618 (TPA$_DECIMAL, DONE_STATE, , ,DELAY) ; 0619 ) ; 0620 ; 0621 !++ ; 0622 ! ; 0623 ! SET ESCAPE command. The format is: ; 0624 ! ; 0625 ! Kermit-32>SET ESCAPE ; 0626 ! ; 0627 ! Where: ; 0628 ! is the octal number representing the escape character ; 0629 ! for the CONNECT command processing. The default escape character ; 0630 ! is Cotnrol-]. ; 0631 !-- ; 0632 ; P 0633 $STATE (SET_ESC_STATE, ; P 0634 (TPA$_OCTAL, DONE_STATE, , ,ESCAPE_CHR) ; 0635 ) ; 0636 !++ ; 0637 ! ; 0638 ! SET FILE-TYPE command. The format is: ; 0639 ! ; 0640 ! Kermit-32>SET FILE-TYPE ; 0641 ! ; 0642 ! Where: ; 0643 ! is one of the following: ; 0644 ! ASCII - Normal ASCII file (stream ascii) ; 0645 ! BINARY - Micro binary file. ; 0646 !-- ; 0647 ; P 0648 $STATE (SET_FIL_STATE, ; P 0649 ('ASCII', DONE_STATE, STORE_FTP, , ,FILE_ASC), ; P 0650 ('BINARY', DONE_STATE, STORE_FTP, , ,FILE_BIN) ; 0651 ) ; 0652 ; 0653 !++ ; 0654 ! SET LINE command. Format is: ; 0655 ! ; 0656 ! Kermit-32>SET LINE terminal-device: ; 0657 ! ; 0658 ! Where: ; 0659 ! Terminal-device: is the terminal line to use to the transfer of ; 0660 ! the data and to use in the CONNECT command. ; 0661 ! ; 0662 !-- ; 0663 ; P 0664 $STATE (SET_LIN_STATE, ; P 0665 (TPA$_ANY, SET_LIN_STATE, STORE_TEXT), ; P 0666 (TPA$_LAMBDA, DONE_STATE, COPY_DEVICE) ; 0667 ) ; 0668 ; 0669 !++ ; 0670 ! SET LOCAL-ECHO command. Format is: ; 0671 ! ; 0672 ! Kermit-32>SET LOCAL-ECHO state ; 0673 ! ; 0674 ! Where: ; 0675 ! STATE is either the keyword ON or OFF. ; 0676 ! ; 0677 !- ; 0678 ; P 0679 $STATE (SET_ECH_STATE, ; P 0680 ('OFF', DONE_STATE, STORE_ECHO, , ,FALSE), ; P 0681 ('ON', DONE_STATE, STORE_ECHO, , ,TRUE) ; 0682 ) ; 0683 %SBTTL 'SET RECEIVE table' ; 0684 ; 0685 !++ ; 0686 ! SET RECEIVE command. Format is: ; 0687 ! ; 0688 ! Kermit-32>SET RECEIVE item ; 0689 ! ; 0690 ! Where: ; 0691 ! Item - One of the following: ; 0692 ! PACKET-LENGTH ; 0693 ! PADDING ; 0694 ! PADCHAR ; 0695 ! TIMEOUT ; 0696 ! END-OF-LINE ; 0697 ! QUOTE ; 0698 ! ; 0699 !-- ; 0700 ; P 0701 $STATE (SET_REC_STATE, ; P 0702 ! ('EIGHT-BIT-QUOTE, SR_PKT_STATE), ; P 0703 ('PACKET_LENGTH', SR_PKT_STATE), ; P 0704 ('PADDING', SR_PAD_STATE), ; P 0705 ('PADCHAR', SR_PDC_STATE), ; P 0706 ('TIMEOUT', SR_TIM_STATE), ; P 0707 ('END_OF_LINE', SR_EOL_STATE), ; P 0708 ('QUOTE', SR_QUO_STATE) ; 0709 ) ; 0710 ; 0711 !++ ; 0712 ! ; 0713 ! SET RECEIVE PACKET-LENGTH command. Format is: ; 0714 ! ; 0715 ! Kermit-32>SET RECEIVE PACKET-LENGTH ; 0716 ! ; 0717 ! Where: ; 0718 ! is a decimal number that specifies the length of a ; 0719 ! receive packet. ; 0720 ! ; 0721 !-- ; 0722 ; P 0723 $STATE (SR_PKT_STATE, ; P 0724 (TPA$_DECIMAL, DONE_STATE, CHECK_PACKET_LEN, ,RCV_PKT_SIZE) ; 0725 ) ; 0726 ; 0727 ; 0728 !++ ; 0729 ! ; 0730 ! SET RECEIVE PADDING command. The format of this command is: ; 0731 ! ; 0732 ! Kermit-32>SET RECEIVE PADDING ; 0733 ! ; 0734 ! Where: ; 0735 ! is the decimal number of padding characters to output. ; 0736 ! ; 0737 !-- ; 0738 ; P 0739 $STATE (SR_PAD_STATE, ; P 0740 (TPA$_DECIMAL, DONE_STATE, CHECK_NPAD, ,RCV_NPAD) ; 0741 ) ; 0742 ; 0743 !++ ; 0744 ! ; 0745 ! SET RECEIVE PADCHAR command. Format is: ; 0746 ! ; 0747 ! Kermit-32>SET RECEIVE PADCHAR ; 0748 ! ; 0749 ! Where: ; 0750 ! is the octal representation of the padding character ; 0751 ! that is to be used. ; 0752 ! ; 0753 !-- ; 0754 ; P 0755 $STATE (SR_PDC_STATE, ; P 0756 (TPA$_OCTAL, DONE_STATE, CHECK_PAD_CHAR, ,RCV_PADCHAR) ; 0757 ) ; 0758 ; 0759 !++ ; 0760 ! ; 0761 ! SET RECEIVE TIMEOUT command. The format is: ; 0762 ! ; 0763 ! Kermit-32>SET RECEIVE TIMEOUT ; 0764 ! ; 0765 ! Where: ; 0766 ! is the number of seconds before KERMIT-32 should time out ; 0767 ! attempting to receive a correct message. ; 0768 ! ; 0769 !-- ; 0770 ; P 0771 $STATE (SR_TIM_STATE, ; P 0772 (TPA$_DECIMAL, DONE_STATE, , ,RCV_TIMEOUT) ; 0773 ) ; 0774 ; 0775 !++ ; 0776 ! SET END-OF-LINE command. Format is: ; 0777 ! ; 0778 ! Kermit-32>SET RECEIVE END-OF-LINE ; 0779 ! ; 0780 ! Where: ; 0781 ! is the octal number representation of the character ; 0782 ! that is the end of line character. ; 0783 ! ; 0784 !-- ; 0785 ; P 0786 $STATE (SR_EOL_STATE, ; P 0787 (TPA$_OCTAL, DONE_STATE, CHECK_EOL, ,RCV_EOL) ; 0788 ) ; 0789 ; 0790 !++ ; 0791 ! SET RECEIVE QUOTA command. The format is: ; 0792 ! ; 0793 ! Kermit-32>SET RECEIVE QUOTA ; 0794 ! ; 0795 ! Where: ; 0796 ! is the octal number representing the quoting character. ; 0797 ! ; 0798 !-- ; 0799 ; P 0800 $STATE (SR_QUO_STATE, ; P 0801 (TPA$_OCTAL, DONE_STATE, , ,RCV_QUOTE_CHR) ; 0802 ) ; 0803 %SBTTL 'SET SEND tables' ; 0804 ; 0805 !++ ; 0806 ! SET SEND command. Format is: ; 0807 ! ; 0808 ! Kermit-32>SET SEND item ; 0809 ! ; 0810 ! Where: ; 0811 ! Item - One of the following: ; 0812 ! PACKET-LENGTH ; 0813 ! PADDING ; 0814 ! PADCHAR ; 0815 ! TIMEOUT ; 0816 ! END-OF-LINE ; 0817 ! QUOTE ; 0818 ! ; 0819 !-- ; 0820 ; P 0821 $STATE (SET_SND_STATE, ; P 0822 ! ('EIGHT_BIT_QUOTE, SS_PKT_STATE), ; P 0823 ('PACKET_LENGTH', SS_PKT_STATE), ; P 0824 ('PADDING', SS_PAD_STATE), ; P 0825 ('PADCHAR', SS_PDC_STATE), ; P 0826 ('TIMEOUT', SS_TIM_STATE), ; P 0827 ('END_OF_LINE', SS_EOL_STATE), ; P 0828 ('QUOTE', SS_QUO_STATE) ; 0829 ) ; 0830 ; 0831 ; 0832 ; 0833 !++ ; 0834 ! ; 0835 ! SET SEND PACKET-LENGTH command. Format is: ; 0836 ! ; 0837 ! Kermit-32>SET SEND PACKET-LENGTH ; 0838 ! ; 0839 ! Where: ; 0840 ! is a decimal number that specifies the length of a ; 0841 ! receive packet. ; 0842 ! ; 0843 !-- ; 0844 ; P 0845 $STATE (SS_PKT_STATE, ; P 0846 (TPA$_DECIMAL, DONE_STATE, CHECK_PACKET_LEN, ,SND_PKT_SIZE) ; 0847 ) ; 0848 ; 0849 ; 0850 !++ ; 0851 ! ; 0852 ! SET SEND PADDING command. The format of this command is: ; 0853 ! ; 0854 ! Kermit-32>SET SEND PADDING ; 0855 ! ; 0856 ! Where: ; 0857 ! is the decimal number of padding characters to output. ; 0858 ! ; 0859 !-- ; 0860 ; P 0861 $STATE (SS_PAD_STATE, ; P 0862 (TPA$_DECIMAL, DONE_STATE, CHECK_NPAD, ,SND_NPAD) ; 0863 ) ; 0864 ; 0865 !++ ; 0866 ! ; 0867 ! SET SEND PADCHAR command. Format is: ; 0868 ! ; 0869 ! Kermit-32>SET SEND PADCHAR ; 0870 ! ; 0871 ! Where: ; 0872 ! is the octal representation of the padding character ; 0873 ! that is to be used. ; 0874 ! ; 0875 !-- ; 0876 ; P 0877 $STATE (SS_PDC_STATE, ; P 0878 (TPA$_OCTAL, DONE_STATE, CHECK_PAD_CHAR, ,SND_PADCHAR) ; 0879 ) ; 0880 ; 0881 !++ ; 0882 ! ; 0883 ! SET SEND TIMEOUT command. The format is: ; 0884 ! ; 0885 ! Kermit-32>SET SEND TIMEOUT ; 0886 ! ; 0887 ! Where: ; 0888 ! is the number of seconds before KERMIT-32 should time out ; 0889 ! attempting to receive a correct message. ; 0890 ! ; 0891 !-- ; 0892 ; P 0893 $STATE (SS_TIM_STATE, ; P 0894 (TPA$_DECIMAL, DONE_STATE, , ,SND_TIMEOUT) ; 0895 ) ; 0896 ; 0897 !++ ; 0898 ! SET SEND END-OF-LINE command. Format is: ; 0899 ! ; 0900 ! Kermit-32>SET SEND END-OF-LINE ; 0901 ! ; 0902 ! Where: ; 0903 ! is the octal number representation of the character ; 0904 ! that is the end of line character. ; 0905 ! ; 0906 !-- ; 0907 ; P 0908 $STATE (SS_EOL_STATE, ; P 0909 (TPA$_OCTAL, DONE_STATE, CHECK_EOL, ,SND_EOL) ; 0910 ) ; 0911 ; 0912 !++ ; 0913 ! SET SEND QUOTA command. The format is: ; 0914 ! ; 0915 ! Kermit-32>SET SEND QUOTA ; 0916 ! ; 0917 ! Where: ; 0918 ! is the octal number representing the quoting character. ; 0919 ! ; 0920 !-- ; 0921 ; P 0922 $STATE (SS_QUO_STATE, ; P 0923 (TPA$_OCTAL, DONE_STATE, , ,SND_QUOTE_CHR) ; 0924 ) ; 0925 %SBTTL 'SEND command' ; 0926 ; 0927 !++ ; 0928 ! SEND command. The format is: ; 0929 ! ; 0930 ! Kermit-32>SEND file-specification ; 0931 ! ; 0932 ! Where: ; 0933 ! FILE-SPECIFICATION is any valid VAX/VMS file specification. ; 0934 ! ; 0935 !-- ; 0936 ; P 0937 $STATE (SEND_STATE, ; P 0938 (TPA$_ANY, SEND_STATE, STORE_TEXT), ; P 0939 (TPA$_LAMBDA, DONE_STATE, COPY_FILE) ; 0940 ) ; 0941 %SBTTL 'SHOW command' ; 0942 ; 0943 !++ ; 0944 ! SHOW command. The format is: ; 0945 ! ; 0946 ! Kermit-32>SHOW ; 0947 ! ; 0948 ! Where: ; 0949 ! is one of the following: ; 0950 ! SEND - Send parameters ; 0951 ! RECEIVE - Receive parameters ; 0952 ! DEBUGGING - State of the debugging flag ; 0953 ! FILE-TYPE - Type of the file ; 0954 ! LOCAL-ECHO - Local echo flag ; 0955 ! LINE - Current line associated ; 0956 ! ESCAPE - Current escape character ; 0957 ! DELAY - Delay parameter. ; 0958 ! ; 0959 !-- ; 0960 ; P 0961 $STATE (SHOW_STATE, ; P 0962 ('ALL', DONE_STATE, ,SHOW_ALL, SHOW_TYPE), ; P 0963 ('DEBUGGING', DONE_STATE, ,SHOW_DEB, SHOW_TYPE), ; P 0964 ('DELAY', DONE_STATE, ,SHOW_DEL, SHOW_TYPE), ; P 0965 ('ESCAPE', DONE_STATE, ,SHOW_ESC, SHOW_TYPE), ; P 0966 ('FILE_TYPE', DONE_STATE, ,SHOW_FTP, SHOW_TYPE), ; P 0967 ('LINE', DONE_STATE, ,SHOW_LIN, SHOW_TYPE), ; P 0968 ('LOCAL_ECHO', DONE_STATE, ,SHOW_ECH, SHOW_TYPE), ; P 0969 ('SEND', DONE_STATE, ,SHOW_SEN, SHOW_TYPE), ; P 0970 ('RECEIVE', DONE_STATE, ,SHOW_REC, SHOW_TYPE) ; 0971 ) ; 0972 %SBTTL 'Done state' ; 0973 ; 0974 !++ ; 0975 ! This is the single state that is the required CONFIRM for the end ; 0976 ! of the commands. ; 0977 !-- ; 0978 ; P 0979 $STATE (DONE_STATE, ; P 0980 (TPA$_EOS, TPA$_EXIT) ; 0981 ) ; 0982 ; 0983 !++ ; 0984 ! ; 0985 ! End of the KERMIT-32 command definitions ; 0986 ! ; 0987 !-- ; 0988 ; 0989 PSECT OWN = $OWN$; ; 0990 PSECT GLOBAL = $GLOBAL$; ; 0991 ; 0992 ! ; 0993 ROUTINE MAIN_ROUTINE : NOVALUE = ; 0994 ; 0995 !++ ; 0996 ! FUNCTIONAL DESCRIPTION: ; 0997 ! ; 0998 ! This is the main routine for KERMIT-32. This routine will ; 0999 ! initialize the various parameters and then call the command ; 1000 ! scanner to process commands. ; 1001 ! ; 1002 ! FORMAL PARAMETERS: ; 1003 ! ; 1004 ! None. ; 1005 ! ; 1006 ! IMPLICIT INPUTS: ; 1007 ! ; 1008 ! None. ; 1009 ! ; 1010 ! IMPLICIT OUTPUTS: ; 1011 ! ; 1012 ! None. ; 1013 ! ; 1014 ! ROUTINE VALUE and ; 1015 ! COMPLETION CODES: ; 1016 ! ; 1017 ! None. ; 1018 ! ; 1019 ! SIDE EFFECTS: ; 1020 ! ; 1021 ! None. ; 1022 ! ; 1023 !-- ; 1024 ; 1025 BEGIN ; 1026 ; 1027 LOCAL ; 1028 LOOP_FLAG; ; 1029 ; 1030 ! Initialize some variables ; 1031 MSG_INIT (); ; 1032 TT_INIT (); ; 1033 FILE_INIT (); ; 1034 ESCAPE_CHR = CHR_ESCAPE; ; 1035 LIB$ESTABLISH (KERM_HANDLER); ; 1036 ! Main command loop ; 1037 COMND (); ; 1038 END; ! end of routine MAIN_ROUTINE .TITLE KERMIT .IDENT \1.0.000\ .PSECT _LIB$KEY1$,NOWRT, SHR, PIC,0 ;TPA$KEYST0 U.27: .BLKB 0 ;TPA$KEYST U.29: .ASCII \CONNECT\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.35: .BLKB 0 ;TPA$KEYST U.37: .ASCII \EXIT\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.43: .BLKB 0 ;TPA$KEYST U.45: .ASCII \HELP\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.52: .BLKB 0 ;TPA$KEYST U.54: .ASCII \QUIT\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.59: .BLKB 0 ;TPA$KEYST U.61: .ASCII \RECEIVE\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.67: .BLKB 0 ;TPA$KEYST U.69: .ASCII \SET\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.75: .BLKB 0 ;TPA$KEYST U.77: .ASCII \SEND\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.83: .BLKB 0 ;TPA$KEYST U.85: .ASCII \SERVER\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.90: .BLKB 0 ;TPA$KEYST U.92: .ASCII \SHOW\ ; ; .BYTE -1 ; ; ;TPA$KEYFILL U.98: .BYTE -1 ; ; ;TPA$KEYST0 U.113: .BLKB 0 ;TPA$KEYST U.115: .ASCII \DEBUGGING\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.119: .BLKB 0 ;TPA$KEYST U.121: .ASCII \DELAY\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.125: .BLKB 0 ;TPA$KEYST U.127: .ASCII \ESCAPE\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.131: .BLKB 0 ;TPA$KEYST U.133: .ASCII \FILE_TYPE\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.137: .BLKB 0 ;TPA$KEYST U.139: .ASCII \LINE\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.143: .BLKB 0 ;TPA$KEYST U.145: .ASCII \LOCAL_ECHO\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.149: .BLKB 0 ;TPA$KEYST U.151: .ASCII \RECEIVE\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.155: .BLKB 0 ;TPA$KEYST U.157: .ASCII \SEND\ ; ; .BYTE -1 ; ; ;TPA$KEYFILL U.161: .BYTE -1 ; ; ;TPA$KEYST0 U.162: .BLKB 0 ;TPA$KEYST U.164: .ASCII \OFF\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.170: .BLKB 0 ;TPA$KEYST U.172: .ASCII \ON\ ; ; .BYTE -1 ; ; ;TPA$KEYFILL U.178: .BYTE -1 ; ; ;TPA$KEYST0 U.185: .BLKB 0 ;TPA$KEYST U.187: .ASCII \ASCII\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.193: .BLKB 0 ;TPA$KEYST U.195: .ASCII \BINARY\ ; ; .BYTE -1 ; ; ;TPA$KEYFILL U.201: .BYTE -1 ; ; ;TPA$KEYST0 U.208: .BLKB 0 ;TPA$KEYST U.210: .ASCII \OFF\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.216: .BLKB 0 ;TPA$KEYST U.218: .ASCII \ON\ ; ; .BYTE -1 ; ; ;TPA$KEYFILL U.224: .BYTE -1 ; ; ;TPA$KEYST0 U.225: .BLKB 0 ;TPA$KEYST U.227: .ASCII \PACKET_LENGTH\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.231: .BLKB 0 ;TPA$KEYST U.233: .ASCII \PADDING\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.237: .BLKB 0 ;TPA$KEYST U.239: .ASCII \PADCHAR\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.243: .BLKB 0 ;TPA$KEYST U.245: .ASCII \TIMEOUT\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.249: .BLKB 0 ;TPA$KEYST U.251: .ASCII \END_OF_LINE\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.255: .BLKB 0 ;TPA$KEYST U.257: .ASCII \QUOTE\ ; ; .BYTE -1 ; ; ;TPA$KEYFILL U.261: .BYTE -1 ; ; ;TPA$KEYST0 U.284: .BLKB 0 ;TPA$KEYST U.286: .ASCII \PACKET_LENGTH\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.290: .BLKB 0 ;TPA$KEYST U.292: .ASCII \PADDING\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.296: .BLKB 0 ;TPA$KEYST U.298: .ASCII \PADCHAR\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.302: .BLKB 0 ;TPA$KEYST U.304: .ASCII \TIMEOUT\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.308: .BLKB 0 ;TPA$KEYST U.310: .ASCII \END_OF_LINE\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.314: .BLKB 0 ;TPA$KEYST U.316: .ASCII \QUOTE\ ; ; .BYTE -1 ; ; ;TPA$KEYFILL U.320: .BYTE -1 ; ; ;TPA$KEYST0 U.349: .BLKB 0 ;TPA$KEYST U.351: .ASCII \ALL\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.356: .BLKB 0 ;TPA$KEYST U.358: .ASCII \DEBUGGING\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.363: .BLKB 0 ;TPA$KEYST U.365: .ASCII \DELAY\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.370: .BLKB 0 ;TPA$KEYST U.372: .ASCII \ESCAPE\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.377: .BLKB 0 ;TPA$KEYST U.379: .ASCII \FILE_TYPE\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.384: .BLKB 0 ;TPA$KEYST U.386: .ASCII \LINE\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.391: .BLKB 0 ;TPA$KEYST U.393: .ASCII \LOCAL_ECHO\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.398: .BLKB 0 ;TPA$KEYST U.400: .ASCII \SEND\ ; ; .BYTE -1 ; ; ;TPA$KEYST0 U.405: .BLKB 0 ;TPA$KEYST U.407: .ASCII \RECEIVE\ ; ; .BYTE -1 ; ; ;TPA$KEYFILL U.412: .BYTE -1 ; ; .PSECT _LIB$STATE$,NOWRT, SHR, PIC,0 KERMIT_STATE:: .BLKB 0 START: .BLKB 0 ;TPA$TYPE U.30: .WORD 28928 ; ; ;TPA$ADDR U.31: .LONG <-4> ; ; ;TPA$MASK U.32: .LONG 1 ; ; ;TPA$TARGET U.34: .WORD <-2> ; ; ;TPA$TYPE U.38: .WORD 28929 ; ; ;TPA$ADDR U.39: .LONG <-4> ; ; ;TPA$MASK U.40: .LONG 2 ; ; ;TPA$TARGET U.42: .WORD <-2> ; ; ;TPA$TYPE U.46: .WORD -3838 ; ; ;TPA$ACTION U.47: .LONG <-4> ; ; ;TPA$ADDR U.48: .LONG <-4> ; ; ;TPA$MASK U.49: .LONG 3 ; ; ;TPA$TARGET U.51: .WORD <-2> ; ; ;TPA$TYPE U.55: .WORD 28931 ; ; ;TPA$ADDR U.56: .LONG <-4> ; ; ;TPA$MASK U.57: .LONG 2 ; ; ;TPA$TARGET U.58: .WORD <-2> ; ; ;TPA$TYPE U.62: .WORD 28932 ; ; ;TPA$ADDR U.63: .LONG <-4> ; ; ;TPA$MASK U.64: .LONG 4 ; ; ;TPA$TARGET U.66: .WORD <-2> ; ; ;TPA$TYPE U.70: .WORD 28933 ; ; ;TPA$ADDR U.71: .LONG <-4> ; ; ;TPA$MASK U.72: .LONG 5 ; ; ;TPA$TARGET U.74: .WORD <-2> ; ; ;TPA$TYPE U.78: .WORD 28934 ; ; ;TPA$ADDR U.79: .LONG <-4> ; ; ;TPA$MASK U.80: .LONG 6 ; ; ;TPA$TARGET U.82: .WORD <-2> ; ; ;TPA$TYPE U.86: .WORD 28935 ; ; ;TPA$ADDR U.87: .LONG <-4> ; ; ;TPA$MASK U.88: .LONG 8 ; ; ;TPA$TARGET U.89: .WORD <-2> ; ; ;TPA$TYPE U.93: .WORD 29960 ; ; ;TPA$ADDR U.94: .LONG <-4> ; ; ;TPA$MASK U.95: .LONG 7 ; ; ;TPA$TARGET U.97: .WORD <-2> ; ; ;CONN_STATE U.33: .BLKB 0 ;TPA$TYPE U.99: .WORD 5617 ; ; ;TPA$TARGET U.100: .WORD <-2> ; ; ;HELP_STATE U.50: .BLKB 0 ;TPA$TYPE U.101: .WORD -28179 ; ; ;TPA$ACTION U.102: .LONG <-4> ; ; ;TPA$TARGET U.103: .WORD <-2> ; ; ;TPA$TYPE U.104: .WORD -27146 ; ; ;TPA$ACTION U.105: .LONG <-4> ; ; ;TPA$TARGET U.106: .WORD <-2> ; ; ;REC_STATE U.65: .BLKB 0 ;TPA$TYPE U.107: .WORD -28179 ; ; ;TPA$ACTION U.108: .LONG <-4> ; ; ;TPA$TARGET U.109: .WORD <-2> ; ; ;TPA$TYPE U.110: .WORD -27146 ; ; ;TPA$ACTION U.111: .LONG <-4> ; ; ;TPA$TARGET U.112: .WORD <-2> ; ; ;SET_STATE U.73: .BLKB 0 ;TPA$TYPE U.116: .WORD 4361 ; ; ;TPA$TARGET U.118: .WORD <-2> ; ; ;TPA$TYPE U.122: .WORD 4362 ; ; ;TPA$TARGET U.124: .WORD <-2> ; ; ;TPA$TYPE U.128: .WORD 4363 ; ; ;TPA$TARGET U.130: .WORD <-2> ; ; ;TPA$TYPE U.134: .WORD 4364 ; ; ;TPA$TARGET U.136: .WORD <-2> ; ; ;TPA$TYPE U.140: .WORD 4365 ; ; ;TPA$TARGET U.142: .WORD <-2> ; ; ;TPA$TYPE U.146: .WORD 4366 ; ; ;TPA$TARGET U.148: .WORD <-2> ; ; ;TPA$TYPE U.152: .WORD 4367 ; ; ;TPA$TARGET U.154: .WORD <-2> ; ; ;TPA$TYPE U.158: .WORD 5392 ; ; ;TPA$TARGET U.160: .WORD <-2> ; ; ;SET_DEB_STATE U.117: .BLKB 0 ;TPA$TYPE U.165: .WORD -27887 ; ; ;TPA$FLAGS2 U.166: .BYTE 1 ; ; ;TPA$PARAM U.167: .LONG 0 ; ; ;TPA$ACTION U.168: .LONG <-4> ; ; ;TPA$TARGET U.169: .WORD <-2> ; ; ;TPA$TYPE U.173: .WORD -26862 ; ; ;TPA$FLAGS2 U.174: .BYTE 1 ; ; ;TPA$PARAM U.175: .LONG 1 ; ; ;TPA$ACTION U.176: .LONG <-4> ; ; ;TPA$TARGET U.177: .WORD <-2> ; ; ;SET_DEL_STATE U.123: .BLKB 0 ;TPA$TYPE U.179: .WORD 22003 ; ; ;TPA$ADDR U.180: .LONG <-4> ; ; ;TPA$TARGET U.181: .WORD <-2> ; ; ;SET_ESC_STATE U.129: .BLKB 0 ;TPA$TYPE U.182: .WORD 22004 ; ; ;TPA$ADDR U.183: .LONG <-4> ; ; ;TPA$TARGET U.184: .WORD <-2> ; ; ;SET_FIL_STATE U.135: .BLKB 0 ;TPA$TYPE U.188: .WORD -27885 ; ; ;TPA$FLAGS2 U.189: .BYTE 1 ; ; ;TPA$PARAM U.190: .LONG 1 ; ; ;TPA$ACTION U.191: .LONG <-4> ; ; ;TPA$TARGET U.192: .WORD <-2> ; ; ;TPA$TYPE U.196: .WORD -26860 ; ; ;TPA$FLAGS2 U.197: .BYTE 1 ; ; ;TPA$PARAM U.198: .LONG 2 ; ; ;TPA$ACTION U.199: .LONG <-4> ; ; ;TPA$TARGET U.200: .WORD <-2> ; ; ;SET_LIN_STATE U.141: .BLKB 0 ;TPA$TYPE U.202: .WORD -28179 ; ; ;TPA$ACTION U.203: .LONG <-4> ; ; ;TPA$TARGET U.204: .WORD <-2> ; ; ;TPA$TYPE U.205: .WORD -27146 ; ; ;TPA$ACTION U.206: .LONG <-4> ; ; ;TPA$TARGET U.207: .WORD <-2> ; ; ;SET_ECH_STATE U.147: .BLKB 0 ;TPA$TYPE U.211: .WORD -27883 ; ; ;TPA$FLAGS2 U.212: .BYTE 1 ; ; ;TPA$PARAM U.213: .LONG 0 ; ; ;TPA$ACTION U.214: .LONG <-4> ; ; ;TPA$TARGET U.215: .WORD <-2> ; ; ;TPA$TYPE U.219: .WORD -26858 ; ; ;TPA$FLAGS2 U.220: .BYTE 1 ; ; ;TPA$PARAM U.221: .LONG 1 ; ; ;TPA$ACTION U.222: .LONG <-4> ; ; ;TPA$TARGET U.223: .WORD <-2> ; ; ;SET_REC_STATE U.153: .BLKB 0 ;TPA$TYPE U.228: .WORD 4375 ; ; ;TPA$TARGET U.230: .WORD <-2> ; ; ;TPA$TYPE U.234: .WORD 4376 ; ; ;TPA$TARGET U.236: .WORD <-2> ; ; ;TPA$TYPE U.240: .WORD 4377 ; ; ;TPA$TARGET U.242: .WORD <-2> ; ; ;TPA$TYPE U.246: .WORD 4378 ; ; ;TPA$TARGET U.248: .WORD <-2> ; ; ;TPA$TYPE U.252: .WORD 4379 ; ; ;TPA$TARGET U.254: .WORD <-2> ; ; ;TPA$TYPE U.258: .WORD 5404 ; ; ;TPA$TARGET U.260: .WORD <-2> ; ; ;SR_PKT_STATE U.229: .BLKB 0 ;TPA$TYPE U.262: .WORD -10765 ; ; ;TPA$ACTION U.263: .LONG <-4> ; ; ;TPA$ADDR U.264: .LONG <-4> ; ; ;TPA$TARGET U.265: .WORD <-2> ; ; ;SR_PAD_STATE U.235: .BLKB 0 ;TPA$TYPE U.266: .WORD -10765 ; ; ;TPA$ACTION U.267: .LONG <-4> ; ; ;TPA$ADDR U.268: .LONG <-4> ; ; ;TPA$TARGET U.269: .WORD <-2> ; ; ;SR_PDC_STATE U.241: .BLKB 0 ;TPA$TYPE U.270: .WORD -10764 ; ; ;TPA$ACTION U.271: .LONG <-4> ; ; ;TPA$ADDR U.272: .LONG <-4> ; ; ;TPA$TARGET U.273: .WORD <-2> ; ; ;SR_TIM_STATE U.247: .BLKB 0 ;TPA$TYPE U.274: .WORD 22003 ; ; ;TPA$ADDR U.275: .LONG <-4> ; ; ;TPA$TARGET U.276: .WORD <-2> ; ; ;SR_EOL_STATE U.253: .BLKB 0 ;TPA$TYPE U.277: .WORD -10764 ; ; ;TPA$ACTION U.278: .LONG <-4> ; ; ;TPA$ADDR U.279: .LONG <-4> ; ; ;TPA$TARGET U.280: .WORD <-2> ; ; ;SR_QUO_STATE U.259: .BLKB 0 ;TPA$TYPE U.281: .WORD 22004 ; ; ;TPA$ADDR U.282: .LONG <-4> ; ; ;TPA$TARGET U.283: .WORD <-2> ; ; ;SET_SND_STATE U.159: .BLKB 0 ;TPA$TYPE U.287: .WORD 4381 ; ; ;TPA$TARGET U.289: .WORD <-2> ; ; ;TPA$TYPE U.293: .WORD 4382 ; ; ;TPA$TARGET U.295: .WORD <-2> ; ; ;TPA$TYPE U.299: .WORD 4383 ; ; ;TPA$TARGET U.301: .WORD <-2> ; ; ;TPA$TYPE U.305: .WORD 4384 ; ; ;TPA$TARGET U.307: .WORD <-2> ; ; ;TPA$TYPE U.311: .WORD 4385 ; ; ;TPA$TARGET U.313: .WORD <-2> ; ; ;TPA$TYPE U.317: .WORD 5410 ; ; ;TPA$TARGET U.319: .WORD <-2> ; ; ;SS_PKT_STATE U.288: .BLKB 0 ;TPA$TYPE U.321: .WORD -10765 ; ; ;TPA$ACTION U.322: .LONG <-4> ; ; ;TPA$ADDR U.323: .LONG <-4> ; ; ;TPA$TARGET U.324: .WORD <-2> ; ; ;SS_PAD_STATE U.294: .BLKB 0 ;TPA$TYPE U.325: .WORD -10765 ; ; ;TPA$ACTION U.326: .LONG <-4> ; ; ;TPA$ADDR U.327: .LONG <-4> ; ; ;TPA$TARGET U.328: .WORD <-2> ; ; ;SS_PDC_STATE U.300: .BLKB 0 ;TPA$TYPE U.329: .WORD -10764 ; ; ;TPA$ACTION U.330: .LONG <-4> ; ; ;TPA$ADDR U.331: .LONG <-4> ; ; ;TPA$TARGET U.332: .WORD <-2> ; ; ;SS_TIM_STATE U.306: .BLKB 0 ;TPA$TYPE U.333: .WORD 22003 ; ; ;TPA$ADDR U.334: .LONG <-4> ; ; ;TPA$TARGET U.335: .WORD <-2> ; ; ;SS_EOL_STATE U.312: .BLKB 0 ;TPA$TYPE U.336: .WORD -10764 ; ; ;TPA$ACTION U.337: .LONG <-4> ; ; ;TPA$ADDR U.338: .LONG <-4> ; ; ;TPA$TARGET U.339: .WORD <-2> ; ; ;SS_QUO_STATE U.318: .BLKB 0 ;TPA$TYPE U.340: .WORD 22004 ; ; ;TPA$ADDR U.341: .LONG <-4> ; ; ;TPA$TARGET U.342: .WORD <-2> ; ; ;SEND_STATE U.81: .BLKB 0 ;TPA$TYPE U.343: .WORD -28179 ; ; ;TPA$ACTION U.344: .LONG <-4> ; ; ;TPA$TARGET U.345: .WORD <-2> ; ; ;TPA$TYPE U.346: .WORD -27146 ; ; ;TPA$ACTION U.347: .LONG <-4> ; ; ;TPA$TARGET U.348: .WORD <-2> ; ; ;SHOW_STATE U.96: .BLKB 0 ;TPA$TYPE U.352: .WORD 28963 ; ; ;TPA$ADDR U.353: .LONG <-4> ; ; ;TPA$MASK U.354: .LONG 1 ; ; ;TPA$TARGET U.355: .WORD <-2> ; ; ;TPA$TYPE U.359: .WORD 28964 ; ; ;TPA$ADDR U.360: .LONG <-4> ; ; ;TPA$MASK U.361: .LONG 2 ; ; ;TPA$TARGET U.362: .WORD <-2> ; ; ;TPA$TYPE U.366: .WORD 28965 ; ; ;TPA$ADDR U.367: .LONG <-4> ; ; ;TPA$MASK U.368: .LONG 3 ; ; ;TPA$TARGET U.369: .WORD <-2> ; ; ;TPA$TYPE U.373: .WORD 28966 ; ; ;TPA$ADDR U.374: .LONG <-4> ; ; ;TPA$MASK U.375: .LONG 4 ; ; ;TPA$TARGET U.376: .WORD <-2> ; ; ;TPA$TYPE U.380: .WORD 28967 ; ; ;TPA$ADDR U.381: .LONG <-4> ; ; ;TPA$MASK U.382: .LONG 5 ; ; ;TPA$TARGET U.383: .WORD <-2> ; ; ;TPA$TYPE U.387: .WORD 28968 ; ; ;TPA$ADDR U.388: .LONG <-4> ; ; ;TPA$MASK U.389: .LONG 6 ; ; ;TPA$TARGET U.390: .WORD <-2> ; ; ;TPA$TYPE U.394: .WORD 28969 ; ; ;TPA$ADDR U.395: .LONG <-4> ; ; ;TPA$MASK U.396: .LONG 7 ; ; ;TPA$TARGET U.397: .WORD <-2> ; ; ;TPA$TYPE U.401: .WORD 28970 ; ; ;TPA$ADDR U.402: .LONG <-4> ; ; ;TPA$MASK U.403: .LONG 8 ; ; ;TPA$TARGET U.404: .WORD <-2> ; ; ;TPA$TYPE U.408: .WORD 29995 ; ; ;TPA$ADDR U.409: .LONG <-4> ; ; ;TPA$MASK U.410: .LONG 9 ; ; ;TPA$TARGET U.411: .WORD <-2> ; ; ;DONE_STATE U.41: .BLKB 0 ;TPA$TYPE U.413: .WORD 5623 ; ; ;TPA$TARGET U.414: .WORD -1 ; ; .PSECT _LIB$KEY0$,NOWRT, SHR, PIC,1 KERMIT_KEY:: .BLKB 0 ;TPA$KEY0 U.26: .BLKB 0 ;TPA$KEY U.28: .WORD ; ; ;TPA$KEY U.36: .WORD ; ; ;TPA$KEY U.44: .WORD ; ; ;TPA$KEY U.53: .WORD ; ; ;TPA$KEY U.60: .WORD ; ; ;TPA$KEY U.68: .WORD ; ; ;TPA$KEY U.76: .WORD ; ; ;TPA$KEY U.84: .WORD ; ; ;TPA$KEY U.91: .WORD ; ; ;TPA$KEY U.114: .WORD ; ; ;TPA$KEY U.120: .WORD ; ; ;TPA$KEY U.126: .WORD ; ; ;TPA$KEY U.132: .WORD ; ; ;TPA$KEY U.138: .WORD ; ; ;TPA$KEY U.144: .WORD ; ; ;TPA$KEY U.150: .WORD ; ; ;TPA$KEY U.156: .WORD ; ; ;TPA$KEY U.163: .WORD ; ; ;TPA$KEY U.171: .WORD ; ; ;TPA$KEY U.186: .WORD ; ; ;TPA$KEY U.194: .WORD ; ; ;TPA$KEY U.209: .WORD ; ; ;TPA$KEY U.217: .WORD ; ; ;TPA$KEY U.226: .WORD ; ; ;TPA$KEY U.232: .WORD ; ; ;TPA$KEY U.238: .WORD ; ; ;TPA$KEY U.244: .WORD ; ; ;TPA$KEY U.250: .WORD ; ; ;TPA$KEY U.256: .WORD ; ; ;TPA$KEY U.285: .WORD ; ; ;TPA$KEY U.291: .WORD ; ; ;TPA$KEY U.297: .WORD ; ; ;TPA$KEY U.303: .WORD ; ; ;TPA$KEY U.309: .WORD ; ; ;TPA$KEY U.315: .WORD ; ; ;TPA$KEY U.350: .WORD ; ; ;TPA$KEY U.357: .WORD ; ; ;TPA$KEY U.364: .WORD ; ; ;TPA$KEY U.371: .WORD ; ; ;TPA$KEY U.378: .WORD ; ; ;TPA$KEY U.385: .WORD ; ; ;TPA$KEY U.392: .WORD ; ; ;TPA$KEY U.399: .WORD ; ; ;TPA$KEY U.406: .WORD ; ; .PSECT $OWN$,NOEXE,2 ;TPARSE_BLOCK U.19: .LONG 8, 2 ; ; .BLKB 28 ;COMMAND U.20: .BLKB 4 ;SHOW_TYPE U.21: .BLKB 4 ;TEMP_DESC U.22: .BLKB 8 ;TEMP_NAME U.23: .BLKB 132 ;ESCAPE_CHR U.24: .BLKB 4 .PSECT $GLOBAL$,NOEXE,2 TERM_NAME:: .BLKB 80 TERM_DESC:: .BLKB 8 .EXTRN LIB$GET_FOREIGN, LIB$GET_INPUT, LIB$PUT_OUTPUT, LIB$TPARSE, LIB$SIGNAL, LIB$ESTABLISH .EXTRN SEND_SWITCH, REC_SWITCH, SERVER, SND_ERROR, MSG_INIT, FILE_INIT, TERM_OPEN, TERM_CLOSE .EXTRN TT_INIT, TT_CHAR, TT_CRLF, RCV_PKT_SIZE, RCV_NPAD, RCV_PADCHAR, RCV_TIMEOUT, RCV_EOL .EXTRN RCV_QUOTE_CHR, RCV_8QUOTE_CHR, SND_PKT_SIZE, SND_NPAD, SND_PADCHAR, SND_TIMEOUT, SND_EOL .EXTRN SND_QUOTE_CHR, SND_8QUOTE_CHR, FILE_SIZE, FILE_NAME, DELAY, DEBUG_FLAG, WARN_FLAG .EXTRN ECHO_FLAG, CONNECT_FLAG, FILE_TYPE, FILE_DESC, TERM_FLAG .PSECT $CODE$,NOWRT,2 MAIN_ROUTINE: .WORD ^M<> ;Save nothing ; 0993 CALLS #0, W^MSG_INIT ;#0, MSG_INIT ; 1031 CALLS #0, W^TT_INIT ;#0, TT_INIT ; 1032 CALLS #0, W^FILE_INIT ;#0, FILE_INIT ; 1033 MOVL #29, W^U.24 ;#29, U.24 ; 1034 PUSHAB W^U.16 ;U.16 ; 1035 CALLS #1, G^LIB$ESTABLISH ;#1, LIB$ESTABLISH ; CALLS #0, W^U.1 ;#0, U.1 ; 1037 RET ; ; 0993 ; Routine Size: 39 bytes, Routine Base: $CODE$ + 0000 ; 1039 %SBTTL 'COMND' ; 1040 ROUTINE COMND = ; 1041 ; 1042 !++ ; 1043 ! FUNCTIONAL DESCRIPTION: ; 1044 ! This routine will do the command scanning for KERMIT-32. It ; 1045 ! will call the correct routines to process the commands. ; 1046 ! ; 1047 ! CALLING SEQUENCE: ; 1048 ! ; 1049 ! COMND(); ; 1050 ! ; 1051 ! INPUT PARAMETERS: ; 1052 ! ; 1053 ! None. ; 1054 ! ; 1055 ! IMPLICIT INPUTS: ; 1056 ! ; 1057 ! None. ; 1058 ! ; 1059 ! OUTPUT PARAMETERS: ; 1060 ! ; 1061 ! None. ; 1062 ! ; 1063 ! IMPLICIT OUTPUTS: ; 1064 ! ; 1065 ! None. ; 1066 ! ; 1067 ! COMPLETION CODES: ; 1068 ! ; 1069 ! None. ; 1070 ! ; 1071 ! SIDE EFFECTS: ; 1072 ! ; 1073 ! None. ; 1074 ! ; 1075 !-- ; 1076 ; 1077 BEGIN ; 1078 ; 1079 BIND ; 1080 SERVER_TEXT = %ASCID'[Kermit Server running on VAX host. Please type your escape sequence to', ; L 1081 SERVER_TEXT_1 = %ASCID ; 1082 ' return to your local machine. Shut down the server by typing the Kermit BYE', ; 1083 SERVER_TEXT_2 = %ASCID' command on your local machine.]'; ; 1084 ; 1085 OWN ; 1086 DESC : BLOCK [8, BYTE], ; 1087 CMD_BUF : VECTOR [80, BYTE, UNSIGNED], ; 1088 CMD_SIZE : UNSIGNED WORD, ; 1089 FORCE_PROMPT, ! Cause prompt to be forced ; 1090 STATUS : UNSIGNED LONG; ; 1091 ; 1092 FORCE_PROMPT = 0; ; 1093 ; 1094 RETURN ; 1095 WHILE TRUE DO ; 1096 BEGIN ; 1097 ! Initialize some per-command data areas. ; 1098 TEMP_DESC [DSC$B_CLASS] = DSC$K_CLASS_S; ; 1099 TEMP_DESC [DSC$B_DTYPE] = DSC$K_DTYPE_T; ; 1100 TEMP_DESC [DSC$W_LENGTH] = 0; ; 1101 TEMP_DESC [DSC$A_POINTER] = TEMP_NAME; ; 1102 COMMAND = 0; ; 1103 SHOW_TYPE = 0; ; 1104 ! Initialize variables for the scanning of a command. ; 1105 DESC [DSC$B_CLASS] = DSC$K_CLASS_S; ; 1106 DESC [DSC$B_DTYPE] = DSC$K_DTYPE_T; ; 1107 DESC [DSC$W_LENGTH] = 80; ; 1108 DESC [DSC$A_POINTER] = CMD_BUF; ; 1109 ; 1110 DO ; 1111 STATUS = LIB$GET_FOREIGN (DESC, %ASCID'Kermit-32>', CMD_SIZE, FORCE_PROMPT) ; 1112 UNTIL (.CMD_SIZE NEQ 0 OR .STATUS NEQ SS$_NORMAL); ; 1113 ; 1114 IF .STATUS EQL RMS$_EOF THEN EXITLOOP SS$_NORMAL; ; 1115 ; 1116 DESC [DSC$W_LENGTH] = .CMD_SIZE; ; 1117 ; 1118 IF .STATUS ; 1119 THEN ; 1120 BEGIN ; 1121 TPARSE_BLOCK [TPA$L_STRINGCNT] = .CMD_SIZE; ; 1122 TPARSE_BLOCK [TPA$L_STRINGPTR] = CMD_BUF; ; 1123 STATUS = LIB$TPARSE (TPARSE_BLOCK, KERMIT_STATE, KERMIT_KEY); ; 1124 ; 1125 IF .STATUS ; 1126 THEN ; 1127 BEGIN ; 1128 ; 1129 SELECTONE .COMMAND OF ; 1130 SET ; 1131 ; 1132 [CMD_CONN] : ; 1133 BEGIN ; 1134 STATUS = LIB$PUT_OUTPUT (%ASCID'CONNECT is not implemented yet'); ; 1135 ; 1136 IF .STATUS NEQ SS$_NORMAL THEN LIB$SIGNAL (.STATUS); ; 1137 ; 1138 ! TERM_CONNECT(); ; 1139 END; ; 1140 ; 1141 [CMD_EXIT] : ; 1142 EXITLOOP KER_NORMAL; ; 1143 ; 1144 [CMD_HELP] : ; 1145 COMND_HELP (); ; 1146 ; 1147 [CMD_RECE] : ; 1148 ; 1149 IF TERM_OPEN () ; 1150 THEN ; 1151 BEGIN ; 1152 REC_SWITCH (); ; 1153 TERM_CLOSE (); ; 1154 END; ; 1155 ; 1156 [CMD_SEND] : ; 1157 ; 1158 IF TERM_OPEN () ; 1159 THEN ; 1160 BEGIN ; 1161 SEND_SWITCH (); ; 1162 TERM_CLOSE (); ; 1163 END; ; 1164 ; 1165 [CMD_SERVER] : ; 1166 BEGIN ; 1167 STATUS = LIB$PUT_OUTPUT (SERVER_TEXT); ; 1168 STATUS = LIB$PUT_OUTPUT (SERVER_TEXT_1); ; 1169 STATUS = LIB$PUT_OUTPUT (SERVER_TEXT_2); ; 1170 ; 1171 IF TERM_OPEN () ; 1172 THEN ; 1173 BEGIN ; 1174 SERVER (); ; 1175 TERM_CLOSE (); ; 1176 EXITLOOP KER_NORMAL; ; 1177 END; ; 1178 ; 1179 END; ; 1180 ; 1181 [CMD_SHOW] : ; 1182 COMND_SHOW (); ; 1183 TES; ; 1184 ; 1185 END ; 1186 ELSE ; 1187 LIB$SIGNAL (.STATUS); ; 1188 ; 1189 END ; 1190 ELSE ; 1191 LIB$SIGNAL (.STATUS); ; 1192 ; 1193 END; ! End of WHILE TRUE DO BEGIN ; 1194 ; 1195 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 ; ; P.AAJ: .ASCII \CONNECT is not implemented yet\<0><0> ; ; P.AAI: .LONG 17694750 ; ; .ADDRESS P.AAJ ; ; .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 ; 1040 MOVAB W^TERM_OPEN, R5 ;TERM_OPEN, R5 ; MOVAB G^LIB$PUT_OUTPUT, R4 ;LIB$PUT_OUTPUT, R4 ; MOVAB W^STATUS, R3 ;STATUS, R3 ; CLRL -4(R3) ;FORCE_PROMPT ; 1092 1$: MOVL #17694720, -240(R3) ;#17694720, TEMP_DESC ; 1100 MOVAB -232(R3), -236(R3) ;TEMP_NAME, TEMP_DESC+4 ; 1101 CLRQ -248(R3) ;COMMAND ; 1102 MOVL #17694800, -96(R3) ;#17694800, DESC ; 1107 MOVAB -88(R3), -92(R3) ;CMD_BUF, DESC+4 ; 1108 2$: PUSHAB -4(R3) ;FORCE_PROMPT ; 1111 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 ; 1112 BNEQ 3$ ;3$ ; CMPL (R3), #1 ;STATUS, #1 ; BEQL 2$ ;2$ ; 3$: MOVL (R3), R1 ;STATUS, R1 ; 1114 CMPL R1, #98938 ;R1, #98938 ; BNEQ 4$ ;4$ ; MOVL #1, R0 ;#1, R0 ; RET ; ; 4$: MOVW R0, -96(R3) ;R0, DESC ; 1116 BLBS R1, 5$ ;R1, 5$ ; 1118 BRW 15$ ;15$ ; 5$: MOVL R0, -276(R3) ;R0, TPARSE_BLOCK+8 ; 1121 MOVAB -88(R3), -272(R3) ;CMD_BUF, TPARSE_BLOCK+12 ; 1122 PUSHAB W^KERMIT_KEY ;KERMIT_KEY ; 1123 PUSHAB W^KERMIT_STATE ;KERMIT_STATE ; PUSHAB -284(R3) ;TPARSE_BLOCK ; CALLS #3, G^LIB$TPARSE ;#3, LIB$TPARSE ; MOVL R0, (R3) ;R0, STATUS ; BLBC (R3), 6$ ;STATUS, 6$ ; 1125 MOVL -248(R3), R2 ;COMMAND, R2 ; 1129 CMPL R2, #1 ;R2, #1 ; BNEQ 7$ ;7$ ; PUSHAB W^P.AAI ;P.AAI ; 1134 CALLS #1, (R4) ;#1, LIB$PUT_OUTPUT ; MOVL R0, (R3) ;R0, STATUS ; CMPL (R3), #1 ;STATUS, #1 ; 1136 BEQL 11$ ;11$ ; 6$: PUSHL (R3) ;STATUS ; BRW 16$ ;16$ ; 7$: CMPL R2, #2 ;R2, #2 ; 1129 BEQL 13$ ;13$ ; CMPL R2, #3 ;R2, #3 ; BNEQ 8$ ;8$ ; CALLS #0, W^U.2 ;#0, U.2 ; 1145 BRB 17$ ;17$ ; 1129 8$: CMPL R2, #4 ;R2, #4 ; BNEQ 9$ ;9$ ; CALLS #0, (R5) ;#0, TERM_OPEN ; 1149 BLBC R0, 17$ ;R0, 17$ ; CALLS #0, W^REC_SWITCH ;#0, REC_SWITCH ; 1152 BRB 10$ ;10$ ; 1153 9$: CMPL R2, #6 ;R2, #6 ; 1129 BNEQ 12$ ;12$ ; CALLS #0, (R5) ;#0, TERM_OPEN ; 1158 BLBC R0, 17$ ;R0, 17$ ; CALLS #0, W^SEND_SWITCH ;#0, SEND_SWITCH ; 1161 10$: CALLS #0, W^TERM_CLOSE ;#0, TERM_CLOSE ; 1162 11$: BRB 17$ ;17$ ; 1129 12$: CMPL R2, #8 ;R2, #8 ; BNEQ 14$ ;14$ ; PUSHAB W^SERVER_TEXT ;SERVER_TEXT ; 1167 CALLS #1, (R4) ;#1, LIB$PUT_OUTPUT ; MOVL R0, (R3) ;R0, STATUS ; PUSHAB W^SERVER_TEXT_1 ;SERVER_TEXT_1 ; 1168 CALLS #1, (R4) ;#1, LIB$PUT_OUTPUT ; MOVL R0, (R3) ;R0, STATUS ; PUSHAB W^SERVER_TEXT_2 ;SERVER_TEXT_2 ; 1169 CALLS #1, (R4) ;#1, LIB$PUT_OUTPUT ; MOVL R0, (R3) ;R0, STATUS ; CALLS #0, (R5) ;#0, TERM_OPEN ; 1171 BLBC R0, 17$ ;R0, 17$ ; CALLS #0, W^SERVER ;#0, SERVER ; 1174 CALLS #0, W^TERM_CLOSE ;#0, TERM_CLOSE ; 1175 13$: MOVL #134316043, R0 ;#134316043, R0 ; 1173 RET ; ; 14$: CMPL R2, #7 ;R2, #7 ; 1129 BNEQ 17$ ;17$ ; CALLS #0, W^U.3 ;#0, U.3 ; 1182 BRB 17$ ;17$ ; 1125 15$: PUSHL R1 ;R1 ; 1191 16$: CALLS #1, G^LIB$SIGNAL ;#1, LIB$SIGNAL ; 17$: BRW 1$ ;1$ ; 1095 ; Routine Size: 322 bytes, Routine Base: $CODE$ + 0027 ; 1196 %SBTTL 'COMND_HELP' ; 1197 ROUTINE COMND_HELP : NOVALUE = ; 1198 ; 1199 !++ ; 1200 ! FUNCTIONAL DESCRIPTION: ; 1201 ! ; 1202 ! This routine will do the HELP command processing for KERMIT. It ; 1203 ! will call the library routines. ; 1204 ! ; 1205 ! CALLING SEQUENCE: ; 1206 ! ; 1207 ! COMND_HELP(); ; 1208 ! ; 1209 ! INPUT PARAMETERS: ; 1210 ! ; 1211 ! None. ; 1212 ! ; 1213 ! IMPLICIT INPUTS: ; 1214 ! ; 1215 ! None. ; 1216 ! ; 1217 ! OUTPUT PARAMETERS: ; 1218 ! ; 1219 ! None. ; 1220 ! ; 1221 ! IMPLICIT OUTPUTS: ; 1222 ! ; 1223 ! None. ; 1224 ! ; 1225 ! COMPLETION CODES: ; 1226 ! ; 1227 ! None. ; 1228 ! ; 1229 ! SIDE EFFECTS: ; 1230 ! ; 1231 ! None. ; 1232 ! ; 1233 !-- ; 1234 ; 1235 BEGIN ; 1236 ; 1237 LOCAL ; 1238 STATUS : UNSIGNED LONG; ; 1239 ; 1240 EXTERNAL ROUTINE ; 1241 LBR$OUTPUT_HELP : ADDRESSING_MODE (GENERAL); ; 1242 ; 1243 ! ; 1244 ! Do the help processing. ; 1245 ! ; 1246 STATUS = LBR$OUTPUT_HELP (LIB$PUT_OUTPUT, 0, TEMP_DESC, %ASCID'KERMIT', UPLIT(HLP$M_PROMPT), ; 1247 LIB$GET_INPUT); ; 1248 ; 1249 IF NOT .STATUS THEN LIB$SIGNAL (.STATUS); ; 1250 ; 1251 END; .PSECT $PLIT$,NOWRT,NOEXE,2 P.AAL: .ASCII \KERMIT\<0><0> ; ; P.AAK: .LONG 17694726 ; ; .ADDRESS P.AAL ; ; P.AAM: .LONG 1 ; ; .EXTRN LBR$OUTPUT_HELP .PSECT $CODE$,NOWRT,2 ;COMND_HELP U.2: .WORD ^M<> ;Save nothing ; 1197 PUSHAB G^LIB$GET_INPUT ;LIB$GET_INPUT ; 1246 PUSHAB W^P.AAM ;P.AAM ; PUSHAB W^P.AAK ;P.AAK ; PUSHAB W^U.22 ;U.22 ; 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$ ; 1249 PUSHL R0 ;STATUS ; CALLS #1, G^LIB$SIGNAL ;#1, LIB$SIGNAL ; 1$: RET ; ; 1197 ; Routine Size: 48 bytes, Routine Base: $CODE$ + 0169 ; 1252 %SBTTL 'COMND_SHOW' ; 1253 ROUTINE COMND_SHOW : NOVALUE = ; 1254 ; 1255 !++ ; 1256 ! FUNCTIONAL DESCRIPTION: ; 1257 ! ; 1258 ! This routine will process the SHOW command. This routine ; 1259 ! expects that the command has already been processed and that ; 1260 ! the type of SHOW command is stored in SHOW_TYPE. ; 1261 ! ; 1262 ! CALLING SEQUENCE: ; 1263 ! ; 1264 ! COMND_SHOW(); ; 1265 ! ; 1266 ! INPUT PARAMETERS: ; 1267 ! ; 1268 ! None. ; 1269 ! ; 1270 ! IMPLICIT INPUTS: ; 1271 ! ; 1272 ! None. ; 1273 ! ; 1274 ! OUTPUT PARAMETERS: ; 1275 ! ; 1276 ! None. ; 1277 ! ; 1278 ! IMPLICIT OUTPUTS: ; 1279 ! ; 1280 ! None. ; 1281 ! ; 1282 ! COMPLETION CODES: ; 1283 ! ; 1284 ! None. ; 1285 ! ; 1286 ! SIDE EFFECTS: ; 1287 ! ; 1288 ! None. ; 1289 ! ; 1290 !-- ; 1291 ; 1292 BEGIN ; 1293 ; 1294 OWN ; 1295 OUTPUT_LINE : VECTOR [OUT_BFR_LENGTH, BYTE, UNSIGNED], ; 1296 OUTPUT_DESC : BLOCK [8, BYTE], ; 1297 OUTPUT_SIZE : WORD UNSIGNED; ; 1298 ; 1299 LOCAL ; 1300 STATUS : WORD; ! Status returned ; 1301 ; 1302 ! Bind some addresses to text ; 1303 ; 1304 BIND ; 1305 OFF_TEXT = %ASCID'OFF', ! Item is off ; 1306 ON_TEXT = %ASCID'ON', ! Item is on ; 1307 SHOW_DEB_MSG = %ASCID' Debugging !AS', ; 1308 SHOW_DEL_MSG = %ASCID' Delay !ZL (sec)', ; 1309 SHOW_ESC_MSG = %ASCID' Escape character !3OL (octal)', ; 1310 SHOW_FTP_MSG = %ASCID' File type !AS', ; 1311 FTP_ASCII = %ASCID'ASCII', ; 1312 FTP_BINARY = %ASCID'BINARY', ; 1313 SHOW_LIN_MSG = %ASCID' Line used !AS', ; 1314 SHOW_ECH_MSG = %ASCID' Local echo !AS', ; 1315 SHOW_REC_HDR = %ASCID' Receive parameters', ; 1316 SHOW_REC_PKT_MSG = %ASCID' Packet length !ZL (dec)', ; 1317 SHOW_REC_PAD_MSG = %ASCID' Padding length !ZL (dec)', ; 1318 SHOW_REC_PDC_MSG = %ASCID' Padding character !3OL (octal)', ; 1319 SHOW_REC_TIM_MSG = %ASCID' Time out !ZL (sec)', ; 1320 SHOW_REC_EOL_MSG = %ASCID' End of line character !3OL (octal)', ; 1321 SHOW_REC_QUO_MSG = %ASCID' Quoting character !3OL (octal)', ; 1322 SHOW_SND_HDR = %ASCID' Send parameters', ; 1323 SHOW_SND_PKT_MSG = %ASCID' Packet length !ZL (dec)', ; 1324 SHOW_SND_PAD_MSG = %ASCID' Padding length !ZL (dec)', ; 1325 SHOW_SND_PDC_MSG = %ASCID' Paddind character !3OL (octal)', ; 1326 SHOW_SND_TIM_MSG = %ASCID' Time out !ZL (sec)', ; 1327 SHOW_SND_EOL_MSG = %ASCID' End of line character !3OL (octal)', ; 1328 SHOW_SND_QUO_MSG = %ASCID' Quoting character !3OL (octal)'; ; 1329 ; 1330 ROUTINE INIT_DESC : NOVALUE = ; 1331 BEGIN ; 1332 OUTPUT_DESC [DSC$B_CLASS] = DSC$K_CLASS_S; ; 1333 OUTPUT_DESC [DSC$B_DTYPE] = DSC$K_DTYPE_T; ; 1334 OUTPUT_DESC [DSC$W_LENGTH] = OUT_BFR_LENGTH; ; 1335 OUTPUT_DESC [DSC$A_POINTER] = OUTPUT_LINE; ; 1336 END; .PSECT $PLIT$,NOWRT,NOEXE,2 P.AAO: .ASCII \OFF\<0> ; ; P.AAN: .LONG 17694723 ; ; .ADDRESS P.AAO ; ; P.AAQ: .ASCII \ON\<0><0> ; ; P.AAP: .LONG 17694722 ; ; .ADDRESS P.AAQ ; ; P.AAS: .ASCII \ Debugging\<9><9><9>\!AS\ ; ; P.AAR: .LONG 17694736 ; ; .ADDRESS P.AAS ; ; P.AAU: .ASCII \ Delay\<9><9><9><9>\!ZL (sec)\<0> ; ; P.AAT: .LONG 17694739 ; ; .ADDRESS P.AAU ; ; P.AAW: .ASCII \ Escape character\<9><9>\!3OL (octal)\<0> ; ; P.AAV: .LONG 17694751 ; ; .ADDRESS P.AAW ; ; P.AAY: .ASCII \ File type\<9><9><9>\!AS\ ; ; P.AAX: .LONG 17694736 ; ; .ADDRESS P.AAY ; ; P.ABA: .ASCII \ASCII\<0><0><0> ; ; P.AAZ: .LONG 17694725 ; ; .ADDRESS P.ABA ; ; P.ABC: .ASCII \BINARY\<0><0> ; ; P.ABB: .LONG 17694726 ; ; .ADDRESS P.ABC ; ; P.ABE: .ASCII \ Line used\<9><9><9>\!AS\ ; ; P.ABD: .LONG 17694736 ; ; .ADDRESS P.ABE ; ; P.ABG: .ASCII \ Local echo\<9><9><9>\!AS\<0><0><0> ; ; P.ABF: .LONG 17694737 ; ; .ADDRESS P.ABG ; ; P.ABI: .ASCII \ Receive parameters\<0> ; ; P.ABH: .LONG 17694739 ; ; .ADDRESS P.ABI ; ; P.ABK: .ASCII \ Packet length\<9><9><9>\!ZL (dec)\<0> ; ; P.ABJ: .LONG 17694747 ; ; .ADDRESS P.ABK ; ; P.ABM: .ASCII \ Padding length\<9><9>\!ZL (dec)\<0> ; ; P.ABL: .LONG 17694747 ; ; .ADDRESS P.ABM ; ; P.ABO: .ASCII \ Padding character\<9><9>\!3OL (octal)\<0><0><0> ; ; P.ABN: .LONG 17694753 ; ; .ADDRESS P.ABO ; ; P.ABQ: .ASCII \ Time out\<9><9><9>\!ZL (sec)\<0><0> ; ; P.ABP: .LONG 17694742 ; ; .ADDRESS P.ABQ ; ; P.ABS: .ASCII \ End of line character\<9><9>\!3OL (octal)\<0><0><0> ; ; P.ABR: .LONG 17694757 ; ; .ADDRESS P.ABS ; ; P.ABU: .ASCII \ Quoting character\<9><9>\!3OL (octal)\<0><0><0> ; ; P.ABT: .LONG 17694753 ; ; .ADDRESS P.ABU ; ; P.ABW: .ASCII \ Send parameters\ ; ; P.ABV: .LONG 17694736 ; ; .ADDRESS P.ABW ; ; P.ABY: .ASCII \ Packet length\<9><9><9>\!ZL (dec)\<0> ; ; P.ABX: .LONG 17694747 ; ; .ADDRESS P.ABY ; ; P.ACA: .ASCII \ Padding length\<9><9>\!ZL (dec)\<0> ; ; P.ABZ: .LONG 17694747 ; ; .ADDRESS P.ACA ; ; P.ACC: .ASCII \ Paddind character\<9><9>\!3OL (octal)\<0><0><0> ; ; P.ACB: .LONG 17694753 ; ; .ADDRESS P.ACC ; ; P.ACE: .ASCII \ Time out\<9><9><9>\!ZL (sec)\<0><0> ; ; P.ACD: .LONG 17694742 ; ; .ADDRESS P.ACE ; ; P.ACG: .ASCII \ End of line character\<9><9>\!3OL (octal)\<0><0><0> ; ; P.ACF: .LONG 17694757 ; ; .ADDRESS P.ACG ; ; P.ACI: .ASCII \ Quoting character\<9><9>\!3OL (octal)\<0><0><0> ; ; P.ACH: .LONG 17694753 ; ; .ADDRESS P.ACI ; ; .PSECT $OWN$,NOEXE,2 OUTPUT_LINE: .BLKB 80 OUTPUT_DESC: .BLKB 8 OUTPUT_SIZE: .BLKB 2 OFF_TEXT= P.AAN ON_TEXT= P.AAP SHOW_DEB_MSG= P.AAR SHOW_DEL_MSG= P.AAT SHOW_ESC_MSG= P.AAV SHOW_FTP_MSG= P.AAX FTP_ASCII= P.AAZ FTP_BINARY= P.ABB SHOW_LIN_MSG= P.ABD SHOW_ECH_MSG= P.ABF SHOW_REC_HDR= P.ABH SHOW_REC_PKT_MSG= P.ABJ SHOW_REC_PAD_MSG= P.ABL SHOW_REC_PDC_MSG= P.ABN SHOW_REC_TIM_MSG= P.ABP SHOW_REC_EOL_MSG= P.ABR SHOW_REC_QUO_MSG= P.ABT SHOW_SND_HDR= P.ABV SHOW_SND_PKT_MSG= P.ABX SHOW_SND_PAD_MSG= P.ABZ SHOW_SND_PDC_MSG= P.ACB SHOW_SND_TIM_MSG= P.ACD SHOW_SND_EOL_MSG= P.ACF SHOW_SND_QUO_MSG= P.ACH .PSECT $CODE$,NOWRT,2 INIT_DESC: .WORD ^M<> ;Save nothing ; 1330 MOVL #17694800, W^OUTPUT_DESC ;#17694800, OUTPUT_DESC ; 1334 MOVAB W^OUTPUT_LINE, W^OUTPUT_DESC+4 ;OUTPUT_LINE, OUTPUT_DESC+4 ; 1335 RET ; ; 1330 ; Routine Size: 19 bytes, Routine Base: $CODE$ + 0199 ; 1337 ; 1338 !++ ; 1339 ! FUNCTIONAL DESCRIPTION: ; 1340 ! This routine is used to output the various long word parameters ; 1341 ! that are shown by the SHOW command. All text is defined in the level ; 1342 ! 0 of this program. ; 1343 ! ; 1344 ! CALLING SEQUENCE: ; 1345 ! ; 1346 ! OUTPUT_LONG_WORD( MSG_ASCID, LONG_WORD_TO_OUTPUT); ; 1347 ! ; 1348 ! INPUT PARAMETERS: ; 1349 ! ; 1350 ! MSG_ASCID - %ASCID of the text to use for the $FAO call. ; 1351 ! ; 1352 ! LONG_WORD_TO_OUTPUT - Address of the long word to pass to the $FAO. ; 1353 ! ; 1354 ! IMPLICIT INPUTS: ; 1355 ! ; 1356 ! None. ; 1357 ! ; 1358 ! OUTPUT PARAMETERS: ; 1359 ! ; 1360 ! None. ; 1361 ! ; 1362 ! IMPLICIT OUTPUTS: ; 1363 ! ; 1364 ! None. ; 1365 ! ; 1366 ! COMPLETION CODES: ; 1367 ! ; 1368 ! None. ; 1369 ! ; 1370 ! SIDE EFFECTS: ; 1371 ! ; 1372 ! None. ; 1373 ! ; 1374 !-- ; 1375 ; 1376 ROUTINE OUTPUT_LONG_WORD (MSG_ADDR, LONG_ADDR) : NOVALUE = ; 1377 BEGIN ; 1378 ; 1379 MAP ; 1380 LONG_ADDR : LONG UNSIGNED, ; 1381 MSG_ADDR : LONG UNSIGNED; ; 1382 ; 1383 LOCAL ; 1384 STATUS : UNSIGNED; ! Status return by LIB$xxx ; 1385 ; 1386 INIT_DESC (); ; 1387 $FAO (.MSG_ADDR, OUTPUT_SIZE, OUTPUT_DESC, ..LONG_ADDR); ; 1388 OUTPUT_DESC [DSC$W_LENGTH] = .OUTPUT_SIZE; ; 1389 STATUS = LIB$PUT_OUTPUT (OUTPUT_DESC); ; 1390 END; .EXTRN SYS$FAO OUTPUT_LONG_WORD: .WORD ^M ;Save R2 ; 1376 MOVAB W^OUTPUT_DESC, R2 ;OUTPUT_DESC, R2 ; CALLS #0, B^INIT_DESC ;#0, INIT_DESC ; 1386 PUSHL @8(AP) ;@LONG_ADDR ; 1387 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 ; 1388 PUSHL R2 ;R2 ; 1389 CALLS #1, G^LIB$PUT_OUTPUT ;#1, LIB$PUT_OUTPUT ; RET ; ; 1376 ; Routine Size: 43 bytes, Routine Base: $CODE$ + 01AC ; 1391 ; 1392 !++ ; 1393 ! FUNCTIONAL DESCRIPTION: ; 1394 ! ; 1395 ! This routine is used to output the keywords TRUE or FALSE. ; 1396 ! All text that this routine uses is defined in the level 0 BEGIN/END ; 1397 ! of the program. ; 1398 ! ; 1399 ! CALLING SEQUENCE: ; 1400 ! ; 1401 ! OUTPUT_TRUE_FALSE( MSG_ASCID, FLAG_WORD); ; 1402 ! ; 1403 ! INPUT PARAMETERS: ; 1404 ! ; 1405 ! MSG_ASCID - %ASCID of the text to use for the $FAO call. ; 1406 ! ; 1407 ! FLAG_WORD - Long word containing the value of either TRUE or FALSE. ; 1408 ! ; 1409 ! IMPLICIT INPUTS: ; 1410 ! ; 1411 ! None. ; 1412 ! ; 1413 ! OUTPUT PARAMETERS: ; 1414 ! ; 1415 ! None. ; 1416 ! ; 1417 ! IMPLICIT OUTPUTS: ; 1418 ! ; 1419 ! None. ; 1420 ! ; 1421 ! COMPLETION CODES: ; 1422 ! ; 1423 ! None. ; 1424 ! ; 1425 ! SIDE EFFECTS: ; 1426 ! ; 1427 ! None. ; 1428 ! ; 1429 !-- ; 1430 ; 1431 ROUTINE OUTPUT_TRUE_FALSE (MSG_ADDR, FLAG_ADDR) : NOVALUE = ; 1432 BEGIN ; 1433 ; 1434 MAP ; 1435 FLAG_ADDR : LONG UNSIGNED, ; 1436 MSG_ADDR : LONG UNSIGNED; ; 1437 ; 1438 LOCAL ; 1439 STATUS : UNSIGNED; ! Status return by LIB$xxx ; 1440 ; 1441 INIT_DESC (); ; P 1442 $FAO (.MSG_ADDR, OUTPUT_SIZE, OUTPUT_DESC, ; P 1443 (SELECTONE ..FLAG_ADDR OF ; P 1444 SET ; P 1445 [TRUE] : ON_TEXT; ; P 1446 [FALSE] : OFF_TEXT; ; 1447 TES)); ; 1448 OUTPUT_DESC [DSC$W_LENGTH] = .OUTPUT_SIZE; ; 1449 STATUS = LIB$PUT_OUTPUT (OUTPUT_DESC); ; 1450 END; OUTPUT_TRUE_FALSE: .WORD ^M ;Save R2 ; 1431 MOVAB W^OUTPUT_DESC, R2 ;OUTPUT_DESC, R2 ; CALLS #0, B^INIT_DESC ;#0, INIT_DESC ; 1441 MOVL @8(AP), R1 ;@FLAG_ADDR, R1 ; 1447 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 ; 1448 PUSHL R2 ;R2 ; 1449 CALLS #1, G^LIB$PUT_OUTPUT ;#1, LIB$PUT_OUTPUT ; RET ; ; 1431 ; Routine Size: 72 bytes, Routine Base: $CODE$ + 01D7 ; 1451 ; 1452 SELECT .SHOW_TYPE OF ; 1453 SET ; 1454 ; 1455 [SHOW_ALL, SHOW_DEB] : ; 1456 OUTPUT_TRUE_FALSE (SHOW_DEB_MSG, DEBUG_FLAG); ; 1457 ; 1458 [SHOW_ALL, SHOW_DEL] : ; 1459 OUTPUT_LONG_WORD (SHOW_DEL_MSG, DELAY); ; 1460 ; 1461 [SHOW_ALL, SHOW_ESC] : ; 1462 OUTPUT_LONG_WORD (SHOW_ESC_MSG, ESCAPE_CHR); ; 1463 ; 1464 [SHOW_ALL, SHOW_FTP] : ; 1465 BEGIN ; 1466 INIT_DESC (); ; P 1467 $FAO (SHOW_FTP_MSG, OUTPUT_SIZE, OUTPUT_DESC, ; P 1468 (SELECTONE .FILE_TYPE OF ; P 1469 SET ; P 1470 [FILE_ASC] : FTP_ASCII; ; P 1471 [FILE_BIN] : FTP_BINARY; ; 1472 TES)); ; 1473 OUTPUT_DESC [DSC$W_LENGTH] = .OUTPUT_SIZE; ; 1474 STATUS = LIB$PUT_OUTPUT (OUTPUT_DESC); ; 1475 END; ; 1476 ; 1477 [SHOW_ALL, SHOW_LIN] : ; 1478 BEGIN ; 1479 INIT_DESC (); ; 1480 $FAO (SHOW_LIN_MSG, OUTPUT_SIZE, OUTPUT_DESC, TERM_DESC); ; 1481 OUTPUT_DESC [DSC$W_LENGTH] = .OUTPUT_SIZE; ; 1482 STATUS = LIB$PUT_OUTPUT (OUTPUT_DESC); ; 1483 END; ; 1484 ; 1485 [SHOW_ALL, SHOW_ECH] : ; 1486 OUTPUT_TRUE_FALSE (SHOW_ECH_MSG, ECHO_FLAG); ; 1487 ; 1488 [SHOW_ALL, SHOW_SEN] : ; 1489 BEGIN ; 1490 STATUS = LIB$PUT_OUTPUT (SHOW_SND_HDR); ; 1491 OUTPUT_LONG_WORD (SHOW_SND_PKT_MSG, SND_PKT_SIZE); ; 1492 OUTPUT_LONG_WORD (SHOW_SND_PAD_MSG, SND_NPAD); ; 1493 OUTPUT_LONG_WORD (SHOW_SND_PDC_MSG, SND_PADCHAR); ; 1494 OUTPUT_LONG_WORD (SHOW_SND_TIM_MSG, SND_TIMEOUT); ; 1495 OUTPUT_LONG_WORD (SHOW_SND_EOL_MSG, SND_EOL); ; 1496 OUTPUT_LONG_WORD (SHOW_SND_QUO_MSG, SND_QUOTE_CHR); ; 1497 END; ; 1498 ; 1499 [SHOW_ALL, SHOW_REC] : ; 1500 BEGIN ; 1501 STATUS = LIB$PUT_OUTPUT (SHOW_REC_HDR); ; 1502 OUTPUT_LONG_WORD (SHOW_REC_PKT_MSG, RCV_PKT_SIZE); ; 1503 OUTPUT_LONG_WORD (SHOW_REC_PAD_MSG, RCV_NPAD); ; 1504 OUTPUT_LONG_WORD (SHOW_REC_PDC_MSG, RCV_PADCHAR); ; 1505 OUTPUT_LONG_WORD (SHOW_REC_TIM_MSG, RCV_TIMEOUT); ; 1506 OUTPUT_LONG_WORD (SHOW_REC_EOL_MSG, RCV_EOL); ; 1507 OUTPUT_LONG_WORD (SHOW_REC_QUO_MSG, RCV_QUOTE_CHR); ; 1508 END; ; 1509 TES; ; 1510 ; 1511 END; ! End of COMND_SHOW ;COMND_SHOW U.3: .WORD ^M ;Save R2,R3,R4,R5,R6,R7,R8 ; 1253 MOVAB G^SYS$FAO, R8 ;SYS$FAO, R8 ; MOVAB G^LIB$PUT_OUTPUT, R7 ;LIB$PUT_OUTPUT, R7 ; MOVAB W^OUTPUT_DESC, R6 ;OUTPUT_DESC, R6 ; MOVAB W^OUTPUT_LONG_WORD, R5 ;OUTPUT_LONG_WORD, R5 ; MOVAB W^SHOW_DEB_MSG, R4 ;SHOW_DEB_MSG, R4 ; MOVL -328(R6), R2 ;SHOW_TYPE, R2 ; 1452 BLEQ 1$ ;1$ ; CMPL R2, #2 ;R2, #2 ; BGTR 1$ ;1$ ; PUSHAB W^DEBUG_FLAG ;DEBUG_FLAG ; 1456 PUSHL R4 ;R4 ; CALLS #2, 43(R5) ;#2, OUTPUT_TRUE_FALSE ; 1$: CMPL R2, #1 ;R2, #1 ; 1452 BEQL 2$ ;2$ ; CMPL R2, #3 ;R2, #3 ; BNEQ 3$ ;3$ ; 2$: PUSHAB W^DELAY ;DELAY ; 1459 PUSHAB 28(R4) ;SHOW_DEL_MSG ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; 3$: CMPL R2, #1 ;R2, #1 ; 1452 BEQL 4$ ;4$ ; CMPL R2, #4 ;R2, #4 ; BNEQ 5$ ;5$ ; 4$: PUSHAB -184(R6) ;ESCAPE_CHR ; 1462 PUSHAB 68(R4) ;SHOW_ESC_MSG ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; 5$: CMPL R2, #1 ;R2, #1 ; 1452 BEQL 6$ ;6$ ; CMPL R2, #5 ;R2, #5 ; BNEQ 11$ ;11$ ; 6$: CALLS #0, -19(R5) ;#0, INIT_DESC ; 1466 MOVL W^FILE_TYPE, R1 ;FILE_TYPE, R1 ; 1472 CMPL R1, #1 ;R1, #1 ; BNEQ 7$ ;7$ ; MOVAB 108(R4), R0 ;FTP_ASCII, R0 ; BRB 9$ ;9$ ; 7$: CMPL R1, #2 ;R1, #2 ; BEQL 8$ ;8$ ; MNEGL #1, -(SP) ;#1, -(SP) ; BRB 10$ ;10$ ; 8$: MOVAB 124(R4), R0 ;FTP_BINARY, R0 ; 9$: PUSHL R0 ;R0 ; 10$: PUSHL R6 ;R6 ; PUSHAB 8(R6) ;OUTPUT_SIZE ; PUSHAB 92(R4) ;SHOW_FTP_MSG ; CALLS #4, (R8) ;#4, SYS$FAO ; MOVW 8(R6), (R6) ;OUTPUT_SIZE, OUTPUT_DESC ; 1473 PUSHL R6 ;R6 ; 1474 CALLS #1, (R7) ;#1, LIB$PUT_OUTPUT ; MOVW R0, R3 ;R0, STATUS ; 11$: CMPL R2, #1 ;R2, #1 ; 1452 BEQL 12$ ;12$ ; CMPL R2, #6 ;R2, #6 ; BNEQ 13$ ;13$ ; 12$: CALLS #0, -19(R5) ;#0, INIT_DESC ; 1479 PUSHAB W^TERM_DESC ;TERM_DESC ; 1480 PUSHL R6 ;R6 ; PUSHAB 8(R6) ;OUTPUT_SIZE ; PUSHAB 148(R4) ;SHOW_LIN_MSG ; CALLS #4, (R8) ;#4, SYS$FAO ; MOVW 8(R6), (R6) ;OUTPUT_SIZE, OUTPUT_DESC ; 1481 PUSHL R6 ;R6 ; 1482 CALLS #1, (R7) ;#1, LIB$PUT_OUTPUT ; MOVW R0, R3 ;R0, STATUS ; 13$: CMPL R2, #1 ;R2, #1 ; 1452 BEQL 14$ ;14$ ; CMPL R2, #7 ;R2, #7 ; BNEQ 15$ ;15$ ; 14$: PUSHAB W^ECHO_FLAG ;ECHO_FLAG ; 1486 PUSHAB 176(R4) ;SHOW_ECH_MSG ; CALLS #2, 43(R5) ;#2, OUTPUT_TRUE_FALSE ; 15$: CMPL R2, #1 ;R2, #1 ; 1452 BEQL 16$ ;16$ ; CMPL R2, #8 ;R2, #8 ; BNEQ 17$ ;17$ ; 16$: PUSHAB 468(R4) ;SHOW_SND_HDR ; 1490 CALLS #1, (R7) ;#1, LIB$PUT_OUTPUT ; MOVW R0, R3 ;R0, STATUS ; PUSHAB W^SND_PKT_SIZE ;SND_PKT_SIZE ; 1491 PUSHAB 504(R4) ;SHOW_SND_PKT_MSG ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHAB W^SND_NPAD ;SND_NPAD ; 1492 PUSHAB 540(R4) ;SHOW_SND_PAD_MSG ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHAB W^SND_PADCHAR ;SND_PADCHAR ; 1493 PUSHAB 584(R4) ;SHOW_SND_PDC_MSG ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHAB W^SND_TIMEOUT ;SND_TIMEOUT ; 1494 PUSHAB 616(R4) ;SHOW_SND_TIM_MSG ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHAB W^SND_EOL ;SND_EOL ; 1495 PUSHAB 664(R4) ;SHOW_SND_EOL_MSG ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHAB W^SND_QUOTE_CHR ;SND_QUOTE_CHR ; 1496 PUSHAB 708(R4) ;SHOW_SND_QUO_MSG ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; 17$: CMPL R2, #1 ;R2, #1 ; 1452 BEQL 18$ ;18$ ; CMPL R2, #9 ;R2, #9 ; BNEQ 19$ ;19$ ; 18$: PUSHAB 204(R4) ;SHOW_REC_HDR ; 1501 CALLS #1, (R7) ;#1, LIB$PUT_OUTPUT ; MOVW R0, R3 ;R0, STATUS ; PUSHAB W^RCV_PKT_SIZE ;RCV_PKT_SIZE ; 1502 PUSHAB 240(R4) ;SHOW_REC_PKT_MSG ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHAB W^RCV_NPAD ;RCV_NPAD ; 1503 PUSHAB 276(R4) ;SHOW_REC_PAD_MSG ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHAB W^RCV_PADCHAR ;RCV_PADCHAR ; 1504 PUSHAB 320(R4) ;SHOW_REC_PDC_MSG ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHAB W^RCV_TIMEOUT ;RCV_TIMEOUT ; 1505 PUSHAB 352(R4) ;SHOW_REC_TIM_MSG ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHAB W^RCV_EOL ;RCV_EOL ; 1506 PUSHAB 400(R4) ;SHOW_REC_EOL_MSG ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; PUSHAB W^RCV_QUOTE_CHR ;RCV_QUOTE_CHR ; 1507 PUSHAB 444(R4) ;SHOW_REC_QUO_MSG ; CALLS #2, (R5) ;#2, OUTPUT_LONG_WORD ; 19$: RET ; ; 1253 ; Routine Size: 399 bytes, Routine Base: $CODE$ + 021F ; 1512 %SBTTL 'TPARSE support -- STORE_DEBUG' ; 1513 ROUTINE STORE_DEBUG = ; 1514 ; 1515 !++ ; 1516 ! FUNCTIONAL DESCRIPTION: ; 1517 ! ; 1518 ! This routine will store the debug flag into the DEBUG_FLAG ; 1519 ! location. ; 1520 ! ; 1521 ! CALLING SEQUENCE: ; 1522 ! ; 1523 ! Standard LIB$TPARSE routine call. ; 1524 ! ; 1525 ! INPUT PARAMETERS: ; 1526 ! ; 1527 ! None. ; 1528 ! ; 1529 ! IMPLICIT INPUTS: ; 1530 ! ; 1531 ! None. ; 1532 ! ; 1533 ! OUPTUT PARAMETERS: ; 1534 ! ; 1535 ! None. ; 1536 ! ; 1537 ! IMPLICIT OUTPUTS: ; 1538 ! ; 1539 ! None. ; 1540 ! ; 1541 ! COMPLETION CODES: ; 1542 ! ; 1543 ! None. ; 1544 ! ; 1545 ! SIDE EFFECTS: ; 1546 ! ; 1547 ! None. ; 1548 ! ; 1549 !-- ; 1550 ; 1551 BEGIN ; 1552 TPARSE_ARGS; ; 1553 DEBUG_FLAG = .AP [TPA$L_PARAM]; ; 1554 RETURN SS$_NORMAL; ; 1555 END; ! End of STORE_DEBUG ;STORE_DEBUG U.7: .WORD ^M<> ;Save nothing ; 1513 MOVL 32(AP), W^DEBUG_FLAG ;32(AP), DEBUG_FLAG ; 1553 MOVL #1, R0 ;#1, R0 ; 1551 RET ; ; 1513 ; Routine Size: 12 bytes, Routine Base: $CODE$ + 03AE ; 1556 %SBTTL 'TPARSE support -- STORE_FTP - Store file type' ; 1557 ROUTINE STORE_FTP = ; 1558 ; 1559 !++ ; 1560 ! FUNCTIONAL DESCRIPTION: ; 1561 ! ; 1562 ! This routine will store the file type that was specified by the ; 1563 ! user for the KERFIL processing. ; 1564 ! ; 1565 ! CALLING SEQUENCE: ; 1566 ! ; 1567 ! Standard call from LIB$TPARSE. ; 1568 ! ; 1569 ! INPUT PARAMETERS: ; 1570 ! ; 1571 ! None. ; 1572 ! ; 1573 ! IMPLICIT INPUTS: ; 1574 ! ; 1575 ! None. ; 1576 ! ; 1577 ! OUPTUT PARAMETERS: ; 1578 ! ; 1579 ! None. ; 1580 ! ; 1581 ! IMPLICIT OUTPUTS: ; 1582 ! ; 1583 ! None. ; 1584 ! ; 1585 ! COMPLETION CODES: ; 1586 ! ; 1587 ! None. ; 1588 ! ; 1589 ! SIDE EFFECTS: ; 1590 ! ; 1591 ! None. ; 1592 ! ; 1593 !-- ; 1594 ; 1595 BEGIN ; 1596 TPARSE_ARGS; ; 1597 FILE_TYPE = .AP [TPA$L_PARAM]; ; 1598 RETURN SS$_NORMAL; ; 1599 END; ! End of STORE_FTP ;STORE_FTP U.8: .WORD ^M<> ;Save nothing ; 1557 MOVL 32(AP), W^FILE_TYPE ;32(AP), FILE_TYPE ; 1597 MOVL #1, R0 ;#1, R0 ; 1595 RET ; ; 1557 ; Routine Size: 12 bytes, Routine Base: $CODE$ + 03BA ; 1600 %SBTTL 'TPARSE support -- STORE_ECHO - Store local echo flag' ; 1601 ROUTINE STORE_ECHO = ; 1602 ; 1603 !++ ; 1604 ! FUNCTIONAL DESCRIPTION: ; 1605 ! ; 1606 ! This routine will store the state of the local echo flag as the ; 1607 ! user set it. ; 1608 ! ; 1609 ! CALLING SEQUENCE: ; 1610 ! ; 1611 ! Standard TPARSE argument call. ; 1612 ! ; 1613 ! INPUT PARAMETERS: ; 1614 ! ; 1615 ! None. ; 1616 ! ; 1617 ! IMPLICIT INPUTS: ; 1618 ! ; 1619 ! None. ; 1620 ! ; 1621 ! OUPTUT PARAMETERS: ; 1622 ! ; 1623 ! None. ; 1624 ! ; 1625 ! IMPLICIT OUTPUTS: ; 1626 ! ; 1627 ! None. ; 1628 ! ; 1629 ! COMPLETION CODES: ; 1630 ! ; 1631 ! None. ; 1632 ! ; 1633 ! SIDE EFFECTS: ; 1634 ! ; 1635 ! None. ; 1636 ! ; 1637 !-- ; 1638 ; 1639 BEGIN ; 1640 TPARSE_ARGS; ; 1641 ECHO_FLAG = .AP [TPA$L_PARAM]; ; 1642 RETURN SS$_NORMAL; ; 1643 END; ! End of STORE_ECHO ;STORE_ECHO U.9: .WORD ^M<> ;Save nothing ; 1601 MOVL 32(AP), W^ECHO_FLAG ;32(AP), ECHO_FLAG ; 1641 MOVL #1, R0 ;#1, R0 ; 1639 RET ; ; 1601 ; Routine Size: 12 bytes, Routine Base: $CODE$ + 03C6 ; 1644 %SBTTL 'TPARSE support -- CHECK_EOL' ; 1645 ROUTINE CHECK_EOL = ; 1646 ; 1647 !++ ; 1648 ! FUNCTIONAL DESCRIPTION: ; 1649 ! ; 1650 ! This routine will valid the SEND and RECEIVE eol character that ; 1651 ! is being set by the user. ; 1652 ! ; 1653 ! CALLING SEQUENCE: ; 1654 ! ; 1655 ! Standard TPARSE routine calling sequence. ; 1656 ! ; 1657 ! INPUT PARAMETERS: ; 1658 ! ; 1659 ! None. ; 1660 ! ; 1661 ! IMPLICIT INPUTS: ; 1662 ! ; 1663 ! None. ; 1664 ! ; 1665 ! OUPTUT PARAMETERS: ; 1666 ! ; 1667 ! None. ; 1668 ! ; 1669 ! IMPLICIT OUTPUTS: ; 1670 ! ; 1671 ! None. ; 1672 ! ; 1673 ! COMPLETION CODES: ; 1674 ! ; 1675 ! None. ; 1676 ! ; 1677 ! SIDE EFFECTS: ; 1678 ! ; 1679 ! None. ; 1680 ! ; 1681 !-- ; 1682 ; 1683 BEGIN ; 1684 TPARSE_ARGS; ; 1685 ; 1686 IF .AP [TPA$L_NUMBER] LSS %C' ' THEN RETURN SS$_NORMAL ELSE RETURN KER_ILLEOL; ; 1687 ; 1688 END; ! End of CHECK_EOL ;CHECK_EOL U.13: .WORD ^M<> ;Save nothing ; 1645 CMPL 28(AP), #32 ;28(AP), #32 ; 1686 BGEQ 1$ ;1$ ; MOVL #1, R0 ;#1, R0 ; 1683 RET ; ; 1$: MOVL #134316066, R0 ;#134316066, R0 ; RET ; ; 1645 ; Routine Size: 20 bytes, Routine Base: $CODE$ + 03D2 ; 1689 %SBTTL 'TPARSE support -- CHECK_PAD_CHAR' ; 1690 ROUTINE CHECK_PAD_CHAR = ; 1691 ; 1692 !++ ; 1693 ! FUNCTIONAL DESCRIPTION: ; 1694 ! ; 1695 ! This routine will valid the SEND and RECEIVE eol character that ; 1696 ! is being set by the user. ; 1697 ! ; 1698 ! CALLING SEQUENCE: ; 1699 ! ; 1700 ! Standard TPARSE routine calling sequence. ; 1701 ! ; 1702 ! INPUT PARAMETERS: ; 1703 ! ; 1704 ! None. ; 1705 ! ; 1706 ! IMPLICIT INPUTS: ; 1707 ! ; 1708 ! None. ; 1709 ! ; 1710 ! OUPTUT PARAMETERS: ; 1711 ! ; 1712 ! None. ; 1713 ! ; 1714 ! IMPLICIT OUTPUTS: ; 1715 ! ; 1716 ! None. ; 1717 ! ; 1718 ! COMPLETION CODES: ; 1719 ! ; 1720 ! None. ; 1721 ! ; 1722 ! SIDE EFFECTS: ; 1723 ! ; 1724 ! None. ; 1725 ! ; 1726 !-- ; 1727 ; 1728 BEGIN ; 1729 TPARSE_ARGS; ; 1730 ; 1731 IF .AP [TPA$L_NUMBER] LSS %C' ' OR .AP [TPA$L_NUMBER] EQL CHR_DEL ; 1732 THEN ; 1733 RETURN SS$_NORMAL ; 1734 ELSE ; 1735 RETURN KER_ILLPADCHR; ; 1736 ; 1737 END; ! End of CHECK_PAD_CHAR ;CHECK_PAD_CHAR U.12: .WORD ^M<> ;Save nothing ; 1690 CMPL 28(AP), #32 ;28(AP), #32 ; 1731 BLSS 1$ ;1$ ; CMPL 28(AP), #127 ;28(AP), #127 ; BNEQ 2$ ;2$ ; 1$: MOVL #1, R0 ;#1, R0 ; 1728 RET ; ; 2$: MOVL #134316082, R0 ;#134316082, R0 ; RET ; ; 1690 ; Routine Size: 30 bytes, Routine Base: $CODE$ + 03E6 ; 1738 %SBTTL 'TPARSE support -- CHECK_NPAD' ; 1739 ROUTINE CHECK_NPAD = ; 1740 ; 1741 !++ ; 1742 ! FUNCTIONAL DESCRIPTION: ; 1743 ! ; 1744 ! This routine will determine if the packet length specified by the ; 1745 ! user is valid. ; 1746 ! ; 1747 ! CALLING SEQUENCE: ; 1748 ! ; 1749 ! Standard TPARSE calling sequence. ; 1750 ! ; 1751 ! INPUT PARAMETERS: ; 1752 ! ; 1753 ! None. ; 1754 ! ; 1755 ! IMPLICIT INPUTS: ; 1756 ! ; 1757 ! None. ; 1758 ! ; 1759 ! OUPTUT PARAMETERS: ; 1760 ! ; 1761 ! None. ; 1762 ! ; 1763 ! IMPLICIT OUTPUTS: ; 1764 ! ; 1765 ! None. ; 1766 ! ; 1767 ! COMPLETION CODES: ; 1768 ! ; 1769 ! None. ; 1770 ! ; 1771 ! SIDE EFFECTS: ; 1772 ! ; 1773 ! None. ; 1774 ! ; 1775 !-- ; 1776 ; 1777 BEGIN ; 1778 TPARSE_ARGS; ; 1779 ; 1780 IF .AP [TPA$L_NUMBER] LEQ 0 THEN RETURN KER_ILLNPAD ELSE RETURN SS$_NORMAL; ; 1781 ; 1782 END; ! End of CHECK_NPAD ;CHECK_NPAD U.11: .WORD ^M<> ;Save nothing ; 1739 TSTL 28(AP) ;28(AP) ; 1780 BGTR 1$ ;1$ ; MOVL #134316090, R0 ;#134316090, R0 ; 1777 RET ; ; 1$: MOVL #1, R0 ;#1, R0 ; RET ; ; 1739 ; Routine Size: 19 bytes, Routine Base: $CODE$ + 0404 ; 1783 %SBTTL 'TPARSE support -- CHECK_PACKET_LEN' ; 1784 ROUTINE CHECK_PACKET_LEN = ; 1785 ; 1786 !++ ; 1787 ! FUNCTIONAL DESCRIPTION: ; 1788 ! ; 1789 ! This routine will determine if the packet length specified by the ; 1790 ! user is valid. ; 1791 ! ; 1792 ! CALLING SEQUENCE: ; 1793 ! ; 1794 ! Standard TPARSE calling sequence. ; 1795 ! ; 1796 ! INPUT PARAMETERS: ; 1797 ! ; 1798 ! None. ; 1799 ! ; 1800 ! IMPLICIT INPUTS: ; 1801 ! ; 1802 ! None. ; 1803 ! ; 1804 ! OUPTUT PARAMETERS: ; 1805 ! ; 1806 ! None. ; 1807 ! ; 1808 ! IMPLICIT OUTPUTS: ; 1809 ! ; 1810 ! None. ; 1811 ! ; 1812 ! COMPLETION CODES: ; 1813 ! ; 1814 ! None. ; 1815 ! ; 1816 ! SIDE EFFECTS: ; 1817 ! ; 1818 ! None. ; 1819 ! ; 1820 !-- ; 1821 ; 1822 BEGIN ; 1823 TPARSE_ARGS; ; 1824 ; 1825 IF .AP [TPA$L_NUMBER] LSS 10 OR .AP [TPA$L_NUMBER] GTR MAX_MSG ; 1826 THEN ; 1827 RETURN KER_ILLPKTLEN ; 1828 ELSE ; 1829 RETURN SS$_NORMAL; ; 1830 ; 1831 END; ! End of CHECK_PACKET_LEN ;CHECK_PACKET_LEN U.10: .WORD ^M<> ;Save nothing ; 1784 CMPL 28(AP), #10 ;28(AP), #10 ; 1825 BLSS 1$ ;1$ ; CMPL 28(AP), #96 ;28(AP), #96 ; BLEQ 2$ ;2$ ; 1$: MOVL #134316074, R0 ;#134316074, R0 ; 1822 RET ; ; 2$: MOVL #1, R0 ;#1, R0 ; RET ; ; 1784 ; Routine Size: 30 bytes, Routine Base: $CODE$ + 0417 ; 1832 %SBTTL 'STORE_TEXT' ; 1833 ROUTINE STORE_TEXT = ; 1834 ; 1835 !++ ; 1836 ! FUNCTIONAL DESCRIPTION: ; 1837 ! ; 1838 ! This routine will store a single character of the file specification ; 1839 ! that the user gives to the SEND and RECEIVE commands. ; 1840 ! ; 1841 ! FORMAL PARAMETERS: ; 1842 ! ; 1843 ! Character that was parsed. ; 1844 ! ; 1845 ! IMPLICIT INPUTS: ; 1846 ! ; 1847 ! None. ; 1848 ! ; 1849 ! IMPLICIT OUTPUTS: ; 1850 ! ; 1851 ! Character stored into the file specification vector. ; 1852 ! ; 1853 ! ROUTINE VALUE and ; 1854 ! COMPLETION CODES: ; 1855 ! ; 1856 ! None. ; 1857 ! ; 1858 ! SIDE EFFECTS: ; 1859 ! ; 1860 ! None. ; 1861 ! ; 1862 !-- ; 1863 ; 1864 BEGIN ; 1865 TPARSE_ARGS; ; 1866 ; 1867 IF (TEMP_DESC [DSC$W_LENGTH] = .TEMP_DESC [DSC$W_LENGTH] + 1) LEQ TEMP_LENGTH ; 1868 THEN ; 1869 BEGIN ; 1870 CH$WCHAR (.AP [TPA$B_CHAR], CH$PTR (TEMP_NAME, .TEMP_DESC [DSC$W_LENGTH] - 1)); ; 1871 RETURN SS$_NORMAL; ; 1872 END ; 1873 ELSE ; 1874 RETURN KER_LINTOOLNG; ; 1875 ; 1876 END; ! End of STORE_TEXT ;STORE_TEXT U.4: .WORD ^M ;Save R2 ; 1833 MOVAB W^U.22, R2 ;U.22, R2 ; MOVZWL (R2), R0 ;TEMP_DESC, R0 ; 1867 INCL R0 ;R0 ; MOVW R0, (R2) ;R0, TEMP_DESC ; CMPL R0, #132 ;R0, #132 ; BGTR 1$ ;1$ ; MOVZWL (R2), R0 ;TEMP_DESC, R0 ; 1870 MOVB 24(AP), 7(R2)[R0] ;24(AP), TEMP_NAME-1[R0] ; MOVL #1, R0 ;#1, R0 ; 1864 RET ; ; 1$: MOVL #134316098, R0 ;#134316098, R0 ; RET ; ; 1833 ; Routine Size: 45 bytes, Routine Base: $CODE$ + 0435 ; 1877 %SBTTL 'COPY_FILE' ; 1878 ROUTINE COPY_FILE = ; 1879 ; 1880 !++ ; 1881 ! FUNCTIONAL DESCRIPTION: ; 1882 ! ; 1883 ! This routine will copy the file name from the temporary ; 1884 ! descriptor to the descriptor that is used for the file name. ; 1885 ! (FILE_NAME and FILE_DESC). ; 1886 ! ; 1887 ! CALLING SEQUENCE: ; 1888 ! ; 1889 ! COPY_FILE(); ; 1890 ! ; 1891 ! INPUT PARAMETERS: ; 1892 ! ; 1893 ! None. ; 1894 ! ; 1895 ! IMPLICIT INPUTS: ; 1896 ! ; 1897 ! TEMP_DESC and TEMP_NAME set up with the device name and length ; 1898 ! in the descriptor. ; 1899 ! ; 1900 ! OUTPUT PARAMETERS: ; 1901 ! ; 1902 ! None. ; 1903 ! ; 1904 ! IMPLICIT OUTPUTS: ; 1905 ! ; 1906 ! FILE_NAME and FILE_DESC set up with what was in TEMP_NAME and ; 1907 ! TEMP_DESC. ; 1908 ! ; 1909 ! COMPLETION CODES: ; 1910 ! ; 1911 ! 0 - Failure. ; 1912 ! 1 - Success. ; 1913 ! ; 1914 ! SIDE EFFECTS: ; 1915 ! ; 1916 ! None. ; 1917 ! ; 1918 !-- ; 1919 ; 1920 BEGIN ; 1921 FILE_DESC [DSC$W_LENGTH] = .TEMP_DESC [DSC$W_LENGTH]; ; 1922 FILE_SIZE = .FILE_DESC [DSC$W_LENGTH]; ; 1923 CH$COPY (.TEMP_DESC [DSC$W_LENGTH], CH$PTR (TEMP_NAME), 0, .TEMP_DESC [DSC$W_LENGTH] + 1, ; 1924 CH$PTR (FILE_NAME)); ; 1925 RETURN SS$_NORMAL; ; 1926 END; ! End of COPY_FILE ;COPY_FILE U.6: .WORD ^M ;Save R2,R3,R4,R5 ; 1878 MOVZWL W^U.22, R1 ;U.22, R1 ; 1921 MOVW R1, W^FILE_DESC ;R1, FILE_DESC ; MOVZWL W^FILE_DESC, W^FILE_SIZE ;FILE_DESC, FILE_SIZE ; 1922 MOVAB 1(R1), R0 ;1(R1), R0 ; 1923 MOVC5 R1, W^U.23, #0, R0, W^FILE_NAME ;R1, U.23, #0, R0, FILE_NAME ; MOVL #1, R0 ;#1, R0 ; 1920 RET ; ; 1878 ; Routine Size: 37 bytes, Routine Base: $CODE$ + 0462 ; 1927 %SBTTL 'COPY_DEVICE' ; 1928 ROUTINE COPY_DEVICE = ; 1929 ; 1930 !++ ; 1931 ! FUNCTIONAL DESCRIPTION: ; 1932 ! ; 1933 ! This routine will copy the device name from the temporary ; 1934 ! descriptor to the descriptor that is used for the terminal name. ; 1935 ! (TERM_NAME and TERM_DESC). ; 1936 ! ; 1937 ! CALLING SEQUENCE: ; 1938 ! ; 1939 ! COPY_DEVICE(); ; 1940 ! ; 1941 ! INPUT PARAMETERS: ; 1942 ! ; 1943 ! None. ; 1944 ! ; 1945 ! IMPLICIT INPUTS: ; 1946 ! ; 1947 ! TEMP_DESC and TEMP_NAME set up with the device name and length ; 1948 ! in the descriptor. ; 1949 ! ; 1950 ! OUTPUT PARAMETERS: ; 1951 ! ; 1952 ! None. ; 1953 ! ; 1954 ! IMPLICIT OUTPUTS: ; 1955 ! ; 1956 ! TERM_NAME and TERM_DESC set up with what was in TEMP_NAME and ; 1957 ! TEMP_DESC. ; 1958 ! ; 1959 ! COMPLETION CODES: ; 1960 ! ; 1961 ! 0 - Failure. ; 1962 ! 1 - Success. ; 1963 ! ; 1964 ! SIDE EFFECTS: ; 1965 ! ; 1966 ! None. ; 1967 ! ; 1968 !-- ; 1969 ; 1970 BEGIN ; 1971 TERM_DESC [DSC$W_LENGTH] = .TEMP_DESC [DSC$W_LENGTH]; ; 1972 CH$COPY (.TEMP_DESC [DSC$W_LENGTH], CH$PTR (TEMP_NAME), 0, .TEMP_DESC [DSC$W_LENGTH], CH$PTR (TERM_NAME)); ; 1973 RETURN SS$_NORMAL; ; 1974 END; ! End of COPY_DEVICE ;COPY_DEVICE U.5: .WORD ^M ;Save R2,R3,R4,R5 ; 1928 MOVZWL W^U.22, R0 ;U.22, R0 ; 1971 MOVW R0, W^TERM_DESC ;R0, TERM_DESC ; MOVC3 R0, W^U.23, W^TERM_NAME ;R0, U.23, TERM_NAME ; 1972 MOVL #1, R0 ;#1, R0 ; 1970 RET ; ; 1928 ; Routine Size: 24 bytes, Routine Base: $CODE$ + 0487 ; 1975 %SBTTL 'HELP_START' ; 1976 ROUTINE HELP_START = ; 1977 ; 1978 !++ ; 1979 ! FUNCTIONAL DESCRIPTION: ; 1980 ! ; 1981 ! This routine is called after the HELP verb has been parsed off ; 1982 ! of the command. This routine will then turn the TPA$V_BLANK bit ; 1983 ! on in the TPARSE_BLOCK. This will allow us to scan multi-words in ; 1984 ! the "HELP xyz" command. ; 1985 ! ; 1986 ! CALLING SEQUENCE: ; 1987 ! ; 1988 ! HELP_START(); ; 1989 ! ; 1990 ! INPUT PARAMETERS: ; 1991 ! ; 1992 ! None. ; 1993 ! ; 1994 ! IMPLICIT INPUTS: ; 1995 ! ; 1996 ! None. ; 1997 ! ; 1998 ! OUPTUT PARAMETERS: ; 1999 ! ; 2000 ! None. ; 2001 ! ; 2002 ! IMPLICIT OUPTUTS: ; 2003 ! ; 2004 ! None. ; 2005 ! ; 2006 ! COMPLETION CODES: ; 2007 ! ; 2008 ! 0 - Failure ; 2009 ! 1 - Success ; 2010 ! ; 2011 ! SIDE EFFECTS: ; 2012 ! ; 2013 ! None. ; 2014 ! ; 2015 !-- ; 2016 ; 2017 BEGIN ; 2018 TPARSE_BLOCK [TPA$V_BLANKS] = 1; ; 2019 RETURN SS$_NORMAL; ; 2020 END; ! End of HELP_START ;HELP_START U.14: .WORD ^M<> ;Save nothing ; 1976 BISB2 #1, W^U.19+4 ;#1, U.19+4 ; 2018 MOVL #1, R0 ;#1, R0 ; 2017 RET ; ; 1976 ; Routine Size: 11 bytes, Routine Base: $CODE$ + 049F ; 2021 %SBTTL 'HELP_DONE' ; 2022 ROUTINE HELP_DONE = ; 2023 ; 2024 !++ ; 2025 ! FUNCTIONAL DESCRIPTION: ; 2026 ! ; 2027 ! This routine will clear the TPA$V_BLANKS flag. This will allow the ; 2028 ! normal parsing to work. ; 2029 ! ; 2030 ! CALLING SEQUENCE: ; 2031 ! ; 2032 ! HELP_DONE(); ; 2033 ! ; 2034 ! INPUT PARAMETERS: ; 2035 ! ; 2036 ! None. ; 2037 ! ; 2038 ! IMPLICIT INPUTS: ; 2039 ! ; 2040 ! None. ; 2041 ! ; 2042 ! OUPTUT PARAMETERS: ; 2043 ! ; 2044 ! None. ; 2045 ! ; 2046 ! IMPLICIT OUPTUTS: ; 2047 ! ; 2048 ! None. ; 2049 ! ; 2050 ! COMPLETION CODES: ; 2051 ! ; 2052 ! 0 - Failure ; 2053 ! 1 - Success ; 2054 ! ; 2055 ! SIDE EFFECTS: ; 2056 ! ; 2057 ! None. ; 2058 ! ; 2059 !-- ; 2060 ; 2061 BEGIN ; 2062 TPARSE_BLOCK [TPA$V_BLANKS] = 0; ; 2063 RETURN SS$_NORMAL; ; 2064 END; ! End of HELP_DONE ;HELP_DONE U.15: .WORD ^M<> ;Save nothing ; 2022 BICB2 #1, W^U.19+4 ;#1, U.19+4 ; 2062 MOVL #1, R0 ;#1, R0 ; 2061 RET ; ; 2022 ; Routine Size: 11 bytes, Routine Base: $CODE$ + 04AA ; 2065 %SBTTL 'SYS_LOGOUT - delete the process.' ; 2066 ; 2067 GLOBAL ROUTINE SYS_LOGOUT : NOVALUE = ; 2068 ; 2069 !++ ; 2070 ! FUNCTIONAL DESCRIPTION: ; 2071 ! ; 2072 ! This routine will delete this process. ; 2073 ! ; 2074 ! CALLING SEQUENCE: ; 2075 ! ; 2076 ! SYS_LOGOUT (); ; 2077 ! ; 2078 ! INPUT PARAMETERS: ; 2079 ! ; 2080 ! None. ; 2081 ! ; 2082 ! IMPLICIT INPUTS: ; 2083 ! ; 2084 ! None. ; 2085 ! ; 2086 ! OUPTUT PARAMETERS: ; 2087 ! ; 2088 ! None. ; 2089 ! ; 2090 ! IMPLICIT OUTPUTS: ; 2091 ! ; 2092 ! None. ; 2093 ! ; 2094 ! COMPLETION CODES: ; 2095 ! ; 2096 ! None. ; 2097 ! ; 2098 ! SIDE EFFECTS: ; 2099 ! ; 2100 ! None. ; 2101 ! ; 2102 !-- ; 2103 ; 2104 BEGIN ; 2105 $DELPRC (); ; 2106 END; ! End of SYS_LOGOUT .EXTRN SYS$DELPRC .ENTRY SYS_LOGOUT, ^M<> ;SYS_LOGOUT, Save nothing ; 2067 CLRQ -(SP) ;-(SP) ; 2105 CALLS #2, G^SYS$DELPRC ;#2, SYS$DELPRC ; RET ; ; 2067 ; Routine Size: 12 bytes, Routine Base: $CODE$ + 04B5 ; 2107 %SBTTL 'DISMISS - Sleep for N seconds' ; 2108 ; 2109 GLOBAL ROUTINE DISMISS (SECONDS) : NOVALUE = ; 2110 ; 2111 !++ ; 2112 ! FUNCTIONAL DESCRIPTION: ; 2113 ! ; 2114 ! This routine is called to cause KERMIT to sleep for the ; 2115 ! specified number of seconds. ; 2116 ! ; 2117 ! CALLING SEQUENCE: ; 2118 ! ; 2119 ! DISMISS(Number of seconds); ; 2120 ! ; 2121 ! INPUT PARAMETERS: ; 2122 ! ; 2123 ! Number of seconds to sleep. ; 2124 ! ; 2125 ! IMPLICIT INPUTS: ; 2126 ! ; 2127 ! None. ; 2128 ! ; 2129 ! OUTPUT PARAMETERS: ; 2130 ! ; 2131 ! None. ; 2132 ! ; 2133 ! IMPLICIT OUTPUTS: ; 2134 ! ; 2135 ! None. ; 2136 ! ; 2137 ! COMPLETION CODES: ; 2138 ! ; 2139 ! None. ; 2140 ! ; 2141 ! SIDE EFFECTS: ; 2142 ! ; 2143 ! None. ; 2144 ! ; 2145 !-- ; 2146 ; 2147 BEGIN ; 2148 ; 2149 LOCAL ; 2150 STATUS, ; 2151 TOTAL_TIME : VECTOR [2, LONG]; ! Quad word for length of time to sleep ; 2152 ; 2153 IF .SECONDS EQL 0 THEN RETURN KER_NORMAL; ; 2154 ; 2155 TOTAL_TIME [0] = -.SECONDS*10*1000*1000; ; 2156 TOTAL_TIME [1] = -1; ; 2157 STATUS = $SETIMR (EFN = 1, DAYTIM = TOTAL_TIME); ; 2158 ; 2159 IF NOT .STATUS THEN LIB$SIGNAL (.STATUS); ; 2160 ; 2161 STATUS = $WAITFR (EFN = 1); ; 2162 ; 2163 IF NOT .STATUS THEN LIB$SIGNAL (.STATUS); ; 2164 ; 2165 END; ! End of DISMISS(time) .EXTRN SYS$SETIMR, SYS$WAITFR .ENTRY DISMISS, ^M ;DISMISS, Save R2,R3 ; 2109 MOVAB G^LIB$SIGNAL, R3 ;LIB$SIGNAL, R3 ; SUBL2 #8, SP ;#8, SP ; TSTL 4(AP) ;SECONDS ; 2153 BEQL 2$ ;2$ ; MULL3 #10000000, 4(AP), R0 ;#10000000, SECONDS, R0 ; 2155 MNEGL R0, (SP) ;R0, TOTAL_TIME ; MNEGL #1, 4(SP) ;#1, TOTAL_TIME+4 ; 2156 CLRQ -(SP) ;-(SP) ; 2157 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$ ; 2159 PUSHL R2 ;STATUS ; CALLS #1, (R3) ;#1, LIB$SIGNAL ; 1$: PUSHL #1 ;#1 ; 2161 CALLS #1, G^SYS$WAITFR ;#1, SYS$WAITFR ; MOVL R0, R2 ;R0, STATUS ; BLBS R2, 2$ ;STATUS, 2$ ; 2163 PUSHL R2 ;STATUS ; CALLS #1, (R3) ;#1, LIB$SIGNAL ; 2$: RET ; ; 2109 ; Routine Size: 79 bytes, Routine Base: $CODE$ + 04C1 ; 2166 ; 2167 %SBTTL 'KRM_ERROR - Issue an error message given error code' ; 2168 ; 2169 GLOBAL ROUTINE KRM_ERROR (ERROR_CODE) : NOVALUE = ; 2170 ; 2171 !++ ; 2172 ! FUNCTIONAL DESCRIPTION: ; 2173 ! ; 2174 ! This routine will cause an error message to be issued to the ; 2175 ! user's terminal and/or a message to be sent to the remote KERMIT. ; 2176 ! ; 2177 ! CALLING SEQUENCE: ; 2178 ! ; 2179 ! KRM_ERROR(KER_xxxxxx); ; 2180 ! ; 2181 ! INPUT PARAMETERS: ; 2182 ! ; 2183 ! KER_xxxxxx - Error code from KERERR.REQ ; 2184 ! ; 2185 ! IMPLICIT INPUTS: ; 2186 ! ; 2187 ! None. ; 2188 ! ; 2189 ! OUPTUT PARAMETERS: ; 2190 ! ; 2191 ! None. ; 2192 ! ; 2193 ! IMPLICIT OUTPUTS: ; 2194 ! ; 2195 ! None. ; 2196 ! ; 2197 ! COMPLETION CODES: ; 2198 ! ; 2199 ! None. ; 2200 ! ; 2201 ! SIDE EFFECTS: ; 2202 ! ; 2203 ! None. ; 2204 ! ; 2205 !-- ; 2206 ; 2207 BEGIN ; 2208 LIB$SIGNAL (.ERROR_CODE); ; 2209 END; ! End of KRM_ERROR .ENTRY KRM_ERROR, ^M<> ;KRM_ERROR, Save nothing ; 2169 PUSHL 4(AP) ;ERROR_CODE ; 2208 CALLS #1, G^LIB$SIGNAL ;#1, LIB$SIGNAL ; RET ; ; 2169 ; Routine Size: 13 bytes, Routine Base: $CODE$ + 0510 ; 2210 ; 2211 %SBTTL 'KERM_HANDLER - Condition handler' ; 2212 ROUTINE KERM_HANDLER = ; 2213 ; 2214 !++ ; 2215 ! FUNCTIONAL DESCRIPTION: ; 2216 ! ; 2217 ! This is the condition handler for KERMIT-32. ; 2218 ! ; 2219 ! CALLING SEQUENCE: ; 2220 ! ; 2221 ! Called via LIB$SIGNAL. ; 2222 ! ; 2223 ! INPUT PARAMETERS: ; 2224 ! ; 2225 ! None. ; 2226 ! ; 2227 ! IMPLICIT INPUTS: ; 2228 ! ; 2229 ! None. ; 2230 ! ; 2231 ! OUPTUT PARAMETERS: ; 2232 ! ; 2233 ! None. ; 2234 ! ; 2235 ! IMPLICIT OUTPUTS: ; 2236 ! ; 2237 ! None. ; 2238 ! ; 2239 ! COMPLETION CODES: ; 2240 ! ; 2241 ! None. ; 2242 ! ; 2243 ! SIDE EFFECTS: ; 2244 ! ; 2245 ! None. ; 2246 ! ; 2247 !-- ; 2248 ; 2249 BEGIN ; 2250 ; 2251 BIND ; 2252 FACILITY_DESC = %ASCID'KERMIT32'; ; 2253 ; 2254 BUILTIN ; 2255 AP; ; 2256 ; 2257 LOCAL ; 2258 PUTMSG_VECTOR : VECTOR [10, LONG], ; 2259 SIGARGLST; ! Address of the signal argument list ; 2260 ; 2261 MAP ; 2262 AP : REF BLOCK [, BYTE], ; 2263 SIGARGLST : REF BLOCK [, BYTE]; ; 2264 ; 2265 !++ ; 2266 ! ; 2267 ! Routine to do the actual output of the error message ; 2268 ! ; 2269 !-- ; 2270 ; 2271 ROUTINE HANDLE_MSG = ; 2272 BEGIN ; 2273 ; 2274 BUILTIN ; 2275 AP; ; 2276 ; 2277 LOCAL ; 2278 ERR_DESC, ! Address of the error descriptor ; 2279 POINTER; ! Pointer to get characters ; 2280 ; 2281 MAP ; 2282 ERR_DESC : REF BLOCK [8, BYTE], ; 2283 AP : REF BLOCK [, BYTE]; ; 2284 ; 2285 ERR_DESC = .AP [4, 0, 32, 0]; ; 2286 ; 2287 IF .TERM_FLAG THEN SND_ERROR (.ERR_DESC [DSC$W_LENGTH], .ERR_DESC [DSC$A_POINTER]); ; 2288 ; 2289 IF NOT .CONNECT_FLAG ; 2290 THEN ; 2291 BEGIN ; 2292 POINTER = CH$PTR (.ERR_DESC [DSC$A_POINTER]); ; 2293 ; 2294 INCR I FROM 1 TO .ERR_DESC [DSC$W_LENGTH] DO ; 2295 TT_CHAR (CH$RCHAR_A (POINTER)); ; 2296 ; 2297 TT_CRLF (); ; 2298 END; ; 2299 ; 2300 RETURN 0; ; 2301 END; .PSECT $PLIT$,NOWRT,NOEXE,2 P.ACK: .ASCII \KERMIT32\ ; ; P.ACJ: .LONG 17694728 ; ; .ADDRESS P.ACK ; ; FACILITY_DESC= P.ACJ .PSECT $CODE$,NOWRT,2 HANDLE_MSG: .WORD ^M ;Save R2,R3,R4 ; 2271 MOVL 4(AP), R2 ;4(AP), ERR_DESC ; 2285 BLBC W^TERM_FLAG, 1$ ;TERM_FLAG, 1$ ; 2287 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$ ; 2289 MOVL 4(R2), R4 ;4(ERR_DESC), POINTER ; 2292 MOVZWL (R2), R3 ;(ERR_DESC), R3 ; 2294 CLRL R2 ;I ; BRB 3$ ;3$ ; 2$: MOVZBL (R4)+, -(SP) ;(POINTER)+, -(SP) ; 2295 CALLS #1, W^TT_CHAR ;#1, TT_CHAR ; 3$: AOBLEQ R3, R2, 2$ ;R3, I, 2$ ; 2294 CALLS #0, W^TT_CRLF ;#0, TT_CRLF ; 2297 4$: CLRL R0 ;R0 ; 2272 RET ; ; 2271 ; Routine Size: 58 bytes, Routine Base: $CODE$ + 051D ; 2302 ; 2303 SIGARGLST = .AP [CHF$L_SIGARGLST]; ; 2304 IF .SIGARGLST [CHF$L_SIG_NAME] GEQ %X'400' AND .SIGARGLST [CHF$L_SIG_NAME] ; 2305 LEQ %X'5FF' THEN RETURN SS$_RESIGNAL; ; 2306 ; 2307 PUTMSG_VECTOR [0] = .SIGARGLST [CHF$L_SIG_ARGS] - 2; ! No PC and PSL ; 2308 PUTMSG_VECTOR [1] = .SIGARGLST [CHF$L_SIG_NAME]; ; 2309 PUTMSG_VECTOR [2] = .SIGARGLST [CHF$L_SIG_ARGS] - 3; ; 2310 ; 2311 INCR I FROM 0 TO .SIGARGLST [CHF$L_SIG_ARGS] - 4 DO ; 2312 PUTMSG_VECTOR [.I + 3] = .(SIGARGLST [CHF$L_SIG_ARG1] + (.I*4)); ; 2313 ; 2314 $PUTMSG (MSGVEC = PUTMSG_VECTOR, ACTRTN = HANDLE_MSG, FACNAM = FACILITY_DESC); ; 2315 RETURN SS$_CONTINUE; ; 2316 END; ! End of KERM_HANDLER .EXTRN SYS$PUTMSG ;KERM_HANDLER U.16: .WORD ^M ;Save R2 ; 2212 SUBL2 #40, SP ;#40, SP ; MOVL 4(AP), R1 ;4(AP), SIGARGLST ; 2303 CMPL 4(R1), #1024 ;4(SIGARGLST), #1024 ; 2304 BLSS 1$ ;1$ ; CMPL 4(R1), #1535 ;4(SIGARGLST), #1535 ; 2305 BGTR 1$ ;1$ ; MOVZWL #2328, R0 ;#2328, R0 ; RET ; ; 1$: SUBL3 #2, (R1), (SP) ;#2, (SIGARGLST), PUTMSG_VECTOR ; 2307 MOVL 4(R1), 4(SP) ;4(SIGARGLST), PUTMSG_VECTOR+4 ; 2308 SUBL3 #3, (R1), 8(SP) ;#3, (SIGARGLST), PUTMSG_VECTOR+8 ; 2309 SUBL3 #4, (R1), R2 ;#4, (SIGARGLST), R2 ; 2311 MNEGL #1, R0 ;#1, I ; BRB 3$ ;3$ ; 2$: MOVL 8(R1)[R0], 12(SP)[R0] ;8(SIGARGLST)[I], PUTMSG_VECTOR+12[I] ; 2312 3$: AOBLEQ R2, R0, 2$ ;R2, I, 2$ ; 2311 CLRL -(SP) ;-(SP) ; 2314 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 ; 2249 RET ; ; 2212 ; Routine Size: 93 bytes, Routine Base: $CODE$ + 0557 ; 2317 %SBTTL 'End of KERMIT.B32' ; 2318 END ! End of module ; 2319 ; 2320 ELUDOM ; PSECT SUMMARY ; ; Name Bytes Attributes ; ; $GLOBAL$ 88 NOVEC, WRT, RD ,NOEXE,NOSHR, LCL, REL, CON,NOPIC,ALIGN(2) ; $OWN$ 378 NOVEC, WRT, RD ,NOEXE,NOSHR, LCL, REL, CON,NOPIC,ALIGN(2) ; _LIB$KEY0$ 88 NOVEC,NOWRT, RD , EXE, SHR, LCL, REL, CON, PIC,ALIGN(1) ; _LIB$STATE$ 594 NOVEC,NOWRT, RD , EXE, SHR, LCL, REL, CON, PIC,ALIGN(0) ; _LIB$KEY1$ 327 NOVEC,NOWRT, RD , EXE, SHR, LCL, REL, CON, PIC,ALIGN(0) ; $CODE$ 1460 NOVEC,NOWRT, RD , EXE,NOSHR, LCL, REL, CON,NOPIC,ALIGN(2) ; $PLIT$ 1060 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 33 0 233 ; SYS$SYSROOT:[SYSLIB]TPAMAC.L32;1 39 31 79 25 ; COMMAND QUALIFIERS ; BLISS KERMIT/LIST=KERMIT.MAR/MACHINE_CODE=(ASSEM,NOBINARY,UNIQUE)/NOOBJECT/SOURCE=NOHEADER ; Compilation Complete .END MAIN_ROUTINE