.NLIST .ENABL LC .NLIST BIN,LOC .LIST ; 0001 MODULE KERTT (IDENT = '2.0.004' ; 0002 ) = ; 0003 BEGIN ; 0004 ; 0005 SWITCHES LANGUAGE (COMMON); ; 0006 ; 0007 ! ; 0008 ; 0009 !++ ; 0010 ! FACILITY: ; 0011 ! ; 0012 ! KERMIT text processing ; 0013 ! ; 0014 ! ABSTRACT: ; 0015 ! ; 0016 ! This module contains all of the text processing required for ; 0017 ! KERMSG. ; 0018 ! ; 0019 ! ENVIRONMENT: ; 0020 ! ; 0021 ! TOPS-10, P/OS, VAX/VMS ; 0022 ! ; 0023 ! AUTHOR: Robert C. McQueen, CREATION DATE: 29-August-1983 ; 0024 !-- ; 0025 ; 0026 ; 0027 %SBTTL 'Table of Contents' ; 0028 ! ; 0029 ! TABLE OF CONTENTS: ; 0030 ! ; 0031 ; 0032 %SBTTL 'Revision History' ; 0033 ; 0034 !++ ; 0035 ! ; 0036 ! Create this module for PRO/Kermit 1.0, Kermit-10 2(100) and Kermit-32 1.2 ; 0037 ! ; 0038 ! 1.2.000 By: Robert C. McQueen On: 29-August-1983 ; 0039 ! Create this module. ; 0040 ! ; 0041 ! 1.2.001 By: Robert C. McQueen On: 9-Sept-1983 ; 0042 ! Make the string passed to TERM_DUMP a counted ASCIZ string, ; 0043 ! not a counted ASCII string. ; 0044 ! ; 0045 ! 1.2.002 By: Robert C. McQueen On: 16-September-1983 ; 0046 ! Make TT_OUTPUT a global routine, so we can force information ; 0047 ! output a various points in time. ; 0048 ! ; 0049 ! 2.0.003 Release for TOPS-10 KERMIT-10 version 2. ; 0050 ! Release for VAX/VMS KERMIT-32 version 2. ; 0051 ! ; 0052 ! 2.0.004 By: Nick Bush On: 22-December-1983 ; 0053 ! Add TT_HOLD to indicate that output should not be dumped ; 0054 ! when LF's are seen, only when buffer is full. ; 0055 !-- ; 0056 ; 0057 ; 0058 %SBTTL 'Library files' ; 0059 ! ; 0060 ! INCLUDE FILES: ; 0061 ! ; 0062 ! ; 0063 ! KERMIT common definitions ; 0064 ! ; 0065 ; 0066 REQUIRE 'KERCOM'; ; 0266 ; 0267 ; 0268 %SBTTL 'Symbol definitions' ; 0269 ! ; 0270 ! EQUATED SYMBOLS: ; 0271 ! ; 0272 ; 0273 LITERAL ; 0274 TEXT_BFR_LENGTH = 256; ! Length of the text buffer ; 0275 ; 0276 ; 0277 %SBTTL 'Storage' ; 0278 ! ; 0279 ! OWN STORAGE: ; 0280 ! ; 0281 ! ; 0282 ! TT_xxxxx routine storage ; 0283 ! ; 0284 ; 0285 OWN ; 0286 HOLD_FLAG, ! Output should be held even if CRLF seen ; 0287 DUMP_ROUTINE, ! Address of routine to dump text ; 0288 TEXT_COUNT, ! Count of the characters ; 0289 TEXT_POINTER, ! Pointer to store characters ; 0290 TEXT_BUFFER : VECTOR [CH$ALLOCATION (TEXT_BFR_LENGTH)]; ! Buffer of characters ; 0291 ; 0292 ; 0293 %SBTTL 'External storage' ; 0294 ; 0295 !++ ; 0296 ! The following is the various external storage locations that are ; 0297 ! referenced from this module. ; 0298 !-- ; 0299 ; 0300 ! ; 0301 ! KERMSG storage ; 0302 ! ; 0303 ; 0304 EXTERNAL ; 0305 CONNECT_FLAG; ! Flag if communications line is TT: ; 0306 ; 0307 !++ ; 0308 ! The following is the only external routine used by this module. This ; 0309 ! routine will cause the terminal buffer that we have been building to be ; 0310 ! output on the terminal ; 0311 !-- ; 0312 ; 0313 EXTERNAL ROUTINE ; 0314 TERM_DUMP : NOVALUE; ! Output the terminal buffer ; 0315 ; 0316 ; 0317 %SBTTL 'Terminal routines -- TT_INIT - Initialize this module' ; 0318 ; 0319 GLOBAL ROUTINE TT_INIT : NOVALUE = ; 0320 ; 0321 !++ ; 0322 ! FUNCTIONAL DESCRIPTION: ; 0323 ! ; 0324 ! This routine will initialize the terminal processing module. It will ; 0325 ! initialize the various data locations in this module. ; 0326 ! ; 0327 ! CALLING SEQUENCE: ; 0328 ! ; 0329 ! TT_INIT(); ; 0330 ! ; 0331 ! INPUT PARAMETERS: ; 0332 ! ; 0333 ! None. ; 0334 ! ; 0335 ! IMPLICIT INPUTS: ; 0336 ! ; 0337 ! None. ; 0338 ! ; 0339 ! OUTPUT PARAMETERS: ; 0340 ! ; 0341 ! None. ; 0342 ! ; 0343 ! IMPLICIT OUTPUTS: ; 0344 ! ; 0345 ! None. ; 0346 ! ; 0347 ! COMPLETION CODES: ; 0348 ! ; 0349 ! None. ; 0350 ! ; 0351 ! SIDE EFFECTS: ; 0352 ! ; 0353 ! None. ; 0354 ! ; 0355 !-- ; 0356 ; 0357 BEGIN ; 0358 ! ; 0359 ! Now initialize the various pointers ; 0360 ! ; 0361 TEXT_COUNT = 0; ; 0362 TEXT_POINTER = CH$PTR (TEXT_BUFFER); ; 0363 DUMP_ROUTINE = TERM_DUMP; ! Initial output routine is to terminal ; 0364 HOLD_FLAG = FALSE; ! Dump output on CRLF's ; 0365 END; ! End of TT_INIT .NLIST .LIST BIN,LOC .LIST .TITLE KERTT .IDENT /2.0.00/ .PSECT $OWN$, D ; HOLD.FLAG U.1: .BLKW 1 ; DUMP.ROUTINE U.2: .BLKW 1 ; TEXT.COUNT U.3: .BLKW 1 ; TEXT.POINTER U.4: .BLKW 1 ; TEXT.BUFFER U.5: .BLKW 200 .GLOBL CONNECT.FLAG, TERM.DUMP FNM.NORMAL== 1 FNM.FULL== 2 FNM.UNTRAN== 4 PR.MIN== 0 PR.NONE== 0 PR.MARK== 1 PR.EVEN== 2 PR.ODD== 3 PR.SPACE== 4 PR.MAX== 4 GC.MIN== 1 GC.EXIT== 1 GC.DIRECTORY== 2 GC.DISK.USAGE== 3 GC.DELETE== 4 GC.TYPE== 5 GC.HELP== 6 GC.LOGOUT== 7 GC.LGN== 10 GC.CONNECT== 11 GC.RENAME== 12 GC.COPY== 13 GC.WHO== 14 GC.SEND.MSG== 15 GC.STATUS== 16 GC.COMMAND== 17 GC.MAX== 17 DP.FULL== 0 DP.HALF== 1 CHK.1CHAR== 61 CHK.2CHAR== 62 CHK.CRC== 63 MAX.MSG== 140 .SBTTL TT.INIT Terminal routines -- TT_INIT - Initialize this .PSECT $CODE$, RO .NLIST .ENABL LSB .LIST TT.INIT:: CLR U.3 ; 0361 MOV #U.5,U.4 ; 0362 MOV #TERM.DUMP,U.2 ; 0363 CLR U.1 ; 0364 RTS PC ; 0319 ; Routine Size: 11 words, Routine Base: $CODE$ + 0000 ; Maximum stack depth per invocation: 0 words .NLIST .DSABL LSB .NLIST BIN,LOC .LIST ; 0366 ; 0367 ; 0368 %SBTTL 'TT_SET_OUTPUT - Set output routine to use' ; 0369 ; 0370 GLOBAL ROUTINE TT_SET_OUTPUT (OUT_RTN) = ; 0371 ; 0372 !++ ; 0373 ! FUNCTIONAL DESCRIPTION: ; 0374 ! ; 0375 ! This routine will set the output routine to use for the TT_xxx routines. ; 0376 !The argument is a routine address which will output a counted ASCIZ string. ; 0377 !It will return the address of the previous output routine. ; 0378 ! ; 0379 ! CALLING SEQUENCE: ; 0380 ! ; 0381 ! OLD_RTN = TT_SET_OUTPUT (OUT_RTN); ; 0382 ! ; 0383 ! INPUT PARAMETERS: ; 0384 ! ; 0385 ! OUT_RTN - Address of routine to output a counted ASCIZ string ; 0386 ! called as OUT_RTN (Address of string, length of string) ; 0387 ! ; 0388 ! IMPLICIT INPUTS: ; 0389 ! ; 0390 ! DUMP_ROUTINE - Previous output routine ; 0391 ! ; 0392 ! OUPTUT PARAMETERS: ; 0393 ! ; 0394 ! The value of the routine is the previous output routine address. ; 0395 ! ; 0396 ! IMPLICIT OUTPUTS: ; 0397 ! ; 0398 ! DUMP_ROUTINE - New output routine ; 0399 ! ; 0400 ! COMPLETION CODES: ; 0401 ! ; 0402 ! None. ; 0403 ! ; 0404 ! SIDE EFFECTS: ; 0405 ! ; 0406 ! None. ; 0407 ! ; 0408 !-- ; 0409 ; 0410 BEGIN ; 0411 ; 0412 LOCAL ; 0413 OLD_RTN; ! Old routine address ; 0414 ; 0415 OLD_RTN = .DUMP_ROUTINE; ! Remember the old address ; 0416 DUMP_ROUTINE = .OUT_RTN; ! Save the new ; 0417 RETURN .OLD_RTN; ! And return the old value ; 0418 END; ! End of TT_SET_OUTPUT .NLIST .LIST BIN,LOC .LIST .SBTTL TT.SET.OUTPUT TT_SET_OUTPUT - Set output routine to use .NLIST .ENABL LSB .LIST TT.SET.OUTPUT:: MOV U.2,R0 ; *,OLD.RTN 0415 MOV 2(SP),U.2 ; OUT.RTN,* 0416 RTS PC ; 0370 ; Routine Size: 6 words, Routine Base: $CODE$ + 0026 ; Maximum stack depth per invocation: 0 words .NLIST .DSABL LSB .NLIST BIN,LOC .LIST ; 0419 ; 0420 ; 0421 %SBTTL 'TT_HOLD - Start holding text until TT_OUTPUT call' ; 0422 ; 0423 GLOBAL ROUTINE TT_HOLD (FLAG) : NOVALUE = ; 0424 ; 0425 !++ ; 0426 ! FUNCTIONAL DESCRIPTION: ; 0427 ! ; 0428 ! This routine is called to start buffering an amount of data ; 0429 ! which should not be output until TT_OUTPUT is called. It ; 0430 ! sets a flag to indicate that output should not be done on ; 0431 ! CRLF's. ; 0432 ! ; 0433 ! CALLING SEQUENCE: ; 0434 ! ; 0435 ! TT_HOLD (TRUE or FALSE); ; 0436 ! ; 0437 ! INPUT PARAMETERS: ; 0438 ! ; 0439 ! FLAG - True if output should be held past LF's. False if output ; 0440 ! should be dumped on each LF. ; 0441 ! ; 0442 ! IMPLICIT INPUTS: ; 0443 ! ; 0444 ! None. ; 0445 ! ; 0446 ! OUPTUT PARAMETERS: ; 0447 ! ; 0448 ! None. ; 0449 ! ; 0450 ! IMPLICIT OUTPUTS: ; 0451 ! ; 0452 ! HOLD_FLAG is set to true. ; 0453 ! ; 0454 ! COMPLETION CODES: ; 0455 ! ; 0456 ! None. ; 0457 ! ; 0458 ! SIDE EFFECTS: ; 0459 ! ; 0460 ! None. ; 0461 ! ; 0462 !-- ; 0463 ; 0464 BEGIN ; 0465 HOLD_FLAG = .FLAG; ; 0466 END; ! End of TT_HOLD .NLIST .LIST BIN,LOC .LIST .SBTTL TT.HOLD TT_HOLD - Start holding text until TT_OUTPUT ca .NLIST .ENABL LSB .LIST TT.HOLD:: MOV 2(SP),U.1 ; FLAG,* 0465 RTS PC ; 0423 ; Routine Size: 4 words, Routine Base: $CODE$ + 0042 ; Maximum stack depth per invocation: 0 words .NLIST .DSABL LSB .NLIST BIN,LOC .LIST ; 0467 ; 0468 ; 0469 %SBTTL 'Terminal routines -- TT_OUTPUT - Output the buffer' ; 0470 ; 0471 GLOBAL ROUTINE TT_OUTPUT : NOVALUE = ; 0472 ; 0473 !++ ; 0474 ! FUNCTIONAL DESCRIPTION: ; 0475 ! ; 0476 ! This routine will dump the text buffer on the output device. ; 0477 ! ; 0478 ! CALLING SEQUENCE: ; 0479 ! ; 0480 ! TT_OUTPUT(); ; 0481 ! ; 0482 ! INPUT PARAMETERS: ; 0483 ! ; 0484 ! None. ; 0485 ! ; 0486 ! IMPLICIT INPUTS: ; 0487 ! ; 0488 ! None. ; 0489 ! ; 0490 ! OUTPUT PARAMETERS: ; 0491 ! ; 0492 ! None. ; 0493 ! ; 0494 ! IMPLICIT OUTPUTS: ; 0495 ! ; 0496 ! None. ; 0497 ! ; 0498 ! COMPLETION CODES: ; 0499 ! ; 0500 ! None. ; 0501 ! ; 0502 ! SIDE EFFECTS: ; 0503 ! ; 0504 ! None. ; 0505 ! ; 0506 !-- ; 0507 ; 0508 BEGIN ; 0509 ; 0510 LOCAL ; 0511 STATUS; ! Status returned by the library routine ; 0512 ; 0513 ! ; 0514 ! Output the text ; 0515 ! ; 0516 CH$WCHAR_A (CHR_NUL, TEXT_POINTER); ; 0517 (.DUMP_ROUTINE) (TEXT_BUFFER, .TEXT_COUNT); ! Output the buffer to the correct place ; 0518 ! ; 0519 ! Now reset the descriptor and the pointer to a virgin state ; 0520 ! ; 0521 TEXT_COUNT = 0; ; 0522 TEXT_POINTER = CH$PTR (TEXT_BUFFER); ; 0523 ! ; 0524 END; ! End of TT_OUTPUT .NLIST .LIST BIN,LOC .LIST .SBTTL TT.OUTPUT Terminal routines -- TT_OUTPUT - Output the buf .NLIST .ENABL LSB .LIST TT.OUTPUT:: CLRB @U.4 ; 0516 INC U.4 MOV #U.5,-(SP) ; 0517 MOV U.3,-(SP) JSR PC,@U.2 CLR U.3 ; 0521 MOV #U.5,U.4 ; 0522 CMP (SP)+,(SP)+ ; 0508 RTS PC ; 0471 ; Routine Size: 17 words, Routine Base: $CODE$ + 0052 ; Maximum stack depth per invocation: 3 words .NLIST .DSABL LSB .NLIST BIN,LOC .LIST ; 0525 ; 0526 ; 0527 %SBTTL 'Terminal routines -- TT_CHAR - Output a single character' ; 0528 ; 0529 GLOBAL ROUTINE TT_CHAR (CHARACTER) : NOVALUE = ; 0530 ; 0531 !++ ; 0532 ! FUNCTIONAL DESCRIPTION: ; 0533 ! ; 0534 ! This routine will store a character into the text buffer. It will ; 0535 ! cause the text to be output if the character is a line terminator. ; 0536 ! ; 0537 ! CALLING SEQUENCE: ; 0538 ! ; 0539 ! TT_CHAR(Character); ; 0540 ! ; 0541 ! INPUT PARAMETERS: ; 0542 ! ; 0543 ! Character - Character to store into the text buffer. ; 0544 ! ; 0545 ! IMPLICIT INPUTS: ; 0546 ! ; 0547 ! None. ; 0548 ! ; 0549 ! OUTPUT PARAMETERS: ; 0550 ! ; 0551 ! None. ; 0552 ! ; 0553 ! IMPLICIT OUTPUTS: ; 0554 ! ; 0555 ! None. ; 0556 ! ; 0557 ! COMPLETION CODES: ; 0558 ! ; 0559 ! None. ; 0560 ! ; 0561 ! SIDE EFFECTS: ; 0562 ! ; 0563 ! None. ; 0564 ! ; 0565 !-- ; 0566 ; 0567 BEGIN ; 0568 ! ; 0569 ! Increment the count of the characters ; 0570 ! ; 0571 TEXT_COUNT = .TEXT_COUNT + 1; ; 0572 ! ; 0573 ! And store the character ; 0574 ! ; 0575 CH$WCHAR_A (.CHARACTER, TEXT_POINTER); ; 0576 ! ; 0577 ! If this is a line feed then just output the text string ; 0578 ! ; 0579 ; 0580 IF (.CHARACTER EQL CHR_LFD) AND NOT .HOLD_FLAG THEN TT_OUTPUT (); ; 0581 ; 0582 ! ; 0583 ! Check to make sure we are not exceeding the limit of the buffer ; 0584 ! ; 0585 ; 0586 IF .TEXT_COUNT EQL TEXT_BFR_LENGTH - 1 THEN TT_OUTPUT (); ; 0587 ; 0588 ! ; 0589 END; ! End of TT_CHAR .NLIST .LIST BIN,LOC .LIST .SBTTL TT.CHAR Terminal routines -- TT_CHAR - Output a single .NLIST .ENABL LSB .LIST TT.CHAR:: INC U.3 ; 0571 MOVB 2(SP),@U.4 ; CHARACTER,* 0575 INC U.4 CMP 2(SP),#12 ; CHARACTER,* 0580 BNE 1$ BIT #1,U.1 BNE 1$ JSR PC,TT.OUTPUT 1$: CMP U.3,#377 ; 0586 BNE 2$ JSR PC,TT.OUTPUT 2$: RTS PC ; 0529 ; Routine Size: 24 words, Routine Base: $CODE$ + 0114 ; Maximum stack depth per invocation: 1 word .NLIST .DSABL LSB .NLIST BIN,LOC .LIST ; 0590 ; 0591 ; 0592 %SBTTL 'Terminal routines -- TT_TEXT - Output a text string' ; 0593 ; 0594 GLOBAL ROUTINE TT_TEXT (ADDRESS) : NOVALUE = ; 0595 ; 0596 !++ ; 0597 ! FUNCTIONAL DESCRIPTION: ; 0598 ! ; 0599 ! This routine will output text on the user's terminal. It will ; 0600 ! assume that it must check to determine if it can output the text ; 0601 ! or not. ; 0602 ! ; 0603 ! CALLING SEQUENCE: ; 0604 ! ; 0605 ! TT_TEXT(TEXT_ADDRESS); ; 0606 ! ; 0607 ! INPUT PARAMETERS: ; 0608 ! ; 0609 ! None. ; 0610 ! ; 0611 ! IMPLICIT INPUTS: ; 0612 ! ; 0613 ! None. ; 0614 ! ; 0615 ! OUTPUT PARAMETERS: ; 0616 ! ; 0617 ! None. ; 0618 ! ; 0619 ! IMPLICIT OUTPUTS: ; 0620 ! ; 0621 ! None. ; 0622 ! ; 0623 ! COMPLETION CODES: ; 0624 ! ; 0625 ! None. ; 0626 ! ; 0627 ! SIDE EFFECTS: ; 0628 ! ; 0629 ! None. ; 0630 ! ; 0631 !-- ; 0632 ; 0633 BEGIN ; 0634 ; 0635 LOCAL ; 0636 CHARACTER, ! Character being processed ; 0637 ARG_POINTER; ! Pointer to the argument's text ; 0638 ; 0639 ! ; 0640 ! Construct a pointer to the argument. ; 0641 ! ; 0642 ARG_POINTER = CH$PTR (.ADDRESS); ; 0643 ! ; 0644 ! Get the first character that was passed. ; 0645 ! ; 0646 CHARACTER = CH$RCHAR_A (ARG_POINTER); ; 0647 ! ; 0648 ! Loop reading characters and calling the output routine to process ; 0649 ! them ; 0650 ! ; 0651 ; 0652 WHILE .CHARACTER NEQ CHR_NUL DO ; 0653 BEGIN ; 0654 TT_CHAR (.CHARACTER); ; 0655 CHARACTER = CH$RCHAR_A (ARG_POINTER); ; 0656 END; ; 0657 ; 0658 END; ! End of TT_TEXT .NLIST .LIST BIN,LOC .LIST .SBTTL TT.TEXT Terminal routines -- TT_TEXT - Output a text st .NLIST .ENABL LSB .LIST TT.TEXT:: JSR R1,$SAVE2 ; 0594 MOV 10(SP),R1 ; ADDRESS,ARG.POINTER 0642 CLR R2 ; CHARACTER 0646 BISB (R1)+,R2 ; ARG.POINTER,CHARACTER 1$: TST R2 ; CHARACTER 0652 BEQ 2$ MOV R2,-(SP) ; CHARACTER,* 0654 JSR PC,TT.CHAR CLR R2 ; CHARACTER 0655 BISB (R1)+,R2 ; ARG.POINTER,CHARACTER TST (SP)+ ; 0653 BR 1$ ; 0652 2$: RTS PC ; 0594 ; Routine Size: 16 words, Routine Base: $CODE$ + 0174 ; Maximum stack depth per invocation: 5 words .NLIST .DSABL LSB .NLIST BIN,LOC .LIST ; 0659 ; 0660 ; 0661 %SBTTL 'Terminal routines -- TT_NUMBER - Output a three digit number' ; 0662 ; 0663 GLOBAL ROUTINE TT_NUMBER (NUMBER) : NOVALUE = ; 0664 ; 0665 !++ ; 0666 ! FUNCTIONAL DESCRIPTION: ; 0667 ! ; 0668 ! This routine will store a three digit number into the text buffer. ; 0669 ! It will just return if the number is greater than 999. ; 0670 ! ; 0671 ! CALLING SEQUENCE: ; 0672 ! ; 0673 ! TT_NUMBER(Value); ; 0674 ! ; 0675 ! INPUT PARAMETERS: ; 0676 ! ; 0677 ! Value - Value to output. ; 0678 ! ; 0679 ! IMPLICIT INPUTS: ; 0680 ! ; 0681 ! None. ; 0682 ! ; 0683 ! OUTPUT PARAMETERS: ; 0684 ! ; 0685 ! None. ; 0686 ! ; 0687 ! IMPLICIT OUTPUTS: ; 0688 ! ; 0689 ! None. ; 0690 ! ; 0691 ! COMPLETION CODES: ; 0692 ! ; 0693 ! None. ; 0694 ! ; 0695 ! SIDE EFFECTS: ; 0696 ! ; 0697 ! None. ; 0698 ! ; 0699 !-- ; 0700 ; 0701 BEGIN ; 0702 ROUTINE TT_NUM_WORKER (VALUE) : NOVALUE = ; 0703 BEGIN ; 0704 ; 0705 IF .VALUE LEQ 9 ; 0706 THEN ; 0707 TT_CHAR (.VALUE + %C'0') ; 0708 ELSE ; 0709 BEGIN ; 0710 TT_NUM_WORKER (.VALUE/10); ; 0711 TT_CHAR ((.VALUE MOD 10) + %C'0'); ; 0712 END; ; 0713 ; 0714 END; .NLIST .LIST BIN,LOC .LIST .SBTTL TT.NUM.WORKER Terminal routines -- TT_NUMBER - Output a three .NLIST .ENABL LSB .LIST ; TT.NUM.WORKER U.13: JSR R1,$SAVE2 ; 0702 MOV 10(SP),R2 ; VALUE,* 0705 CMP R2,#11 BGT 1$ MOV R2,-(SP) ; 0707 BR 2$ 1$: MOV R2,R1 ; 0710 SXT R0 DIV #12,R0 MOV R0,-(SP) JSR PC,U.13 MOV R2,R1 ; 0711 SXT R0 DIV #12,R0 MOV R1,(SP) 2$: ADD #60,(SP) JSR PC,TT.CHAR TST (SP)+ ; 0703 RTS PC ; 0702 ; Routine Size: 27 words, Routine Base: $CODE$ + 0234 ; Maximum stack depth per invocation: 5 words .NLIST .DSABL LSB .NLIST BIN,LOC .LIST ; 0715 ; 0716 IF .NUMBER LSS 0 ; 0717 THEN ; 0718 BEGIN ; 0719 TT_CHAR (%C'-'); ; 0720 NUMBER = -.NUMBER; ; 0721 END; ; 0722 ; 0723 TT_NUM_WORKER (.NUMBER); ; 0724 END; ! End of TT_NUMBER .NLIST .LIST BIN,LOC .LIST .SBTTL TT.NUMBER Terminal routines -- TT_NUMBER - Output a three .NLIST .ENABL LSB .LIST TT.NUMBER:: TST 2(SP) ; NUMBER 0716 BGE 1$ MOV #55,-(SP) ; 0719 JSR PC,TT.CHAR NEG 4(SP) ; NUMBER 0720 TST (SP)+ ; 0718 1$: MOV 2(SP),-(SP) ; NUMBER,* 0723 JSR PC,U.13 TST (SP)+ ; 0701 RTS PC ; 0663 ; Routine Size: 16 words, Routine Base: $CODE$ + 0322 ; Maximum stack depth per invocation: 2 words .NLIST .DSABL LSB .NLIST BIN,LOC .LIST ; 0725 ; 0726 ; 0727 %SBTTL 'Terminal routines -- TT_CRLF - Output a CRLF' ; 0728 ; 0729 GLOBAL ROUTINE TT_CRLF : NOVALUE = ; 0730 ; 0731 !++ ; 0732 ! FUNCTIONAL DESCRIPTION: ; 0733 ! ; 0734 ! This routine will cause the contents of the terminal buffer to be ; 0735 ! output to SYS$OUTPUT:. ; 0736 ! ; 0737 ! CALLING SEQUENCE: ; 0738 ! ; 0739 ! TT_CRLF(); ; 0740 ! ; 0741 ! INPUT PARAMETERS: ; 0742 ! ; 0743 ! None. ; 0744 ! ; 0745 ! IMPLICIT INPUTS: ; 0746 ! ; 0747 ! None. ; 0748 ! ; 0749 ! OUTPUT PARAMETERS: ; 0750 ! ; 0751 ! None. ; 0752 ! ; 0753 ! IMPLICIT OUTPUTS: ; 0754 ! ; 0755 ! None. ; 0756 ! ; 0757 ! COMPLETION CODES: ; 0758 ! ; 0759 ! None. ; 0760 ! ; 0761 ! SIDE EFFECTS: ; 0762 ! ; 0763 ! None. ; 0764 ! ; 0765 !-- ; 0766 ; 0767 BEGIN ; 0768 TT_CHAR (CHR_CRT); ; 0769 TT_CHAR (CHR_LFD); ; 0770 END; ! End of TT_CRLF .NLIST .LIST BIN,LOC .LIST .SBTTL TT.CRLF Terminal routines -- TT_CRLF - Output a CRLF .NLIST .ENABL LSB .LIST TT.CRLF:: MOV #15,-(SP) ; 0768 JSR PC,TT.CHAR MOV #12,(SP) ; 0769 JSR PC,TT.CHAR TST (SP)+ ; 0767 RTS PC ; 0729 ; Routine Size: 10 words, Routine Base: $CODE$ + 0362 ; Maximum stack depth per invocation: 2 words .NLIST .DSABL LSB .NLIST BIN,LOC .LIST ; 0771 ; 0772 ; 0773 %SBTTL 'End of KERTRM' ; 0774 END ! End of module ; 0775 ; 0776 ELUDOM .NLIST .LIST BIN,LOC .LIST ; OTS external references .GLOBL $SAVE2 ; PSECT SUMMARY ; ; Psect Name Words ; Attributes ; $OWN$ 132 ; RW , D , LCL, REL, CON ; $CODE$ 131 ; RO , I , LCL, REL, CON ; Compilation Complete .END