home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / b / vmstt.mar < prev    next >
Text File  |  2020-01-01  |  24KB  |  802 lines
  1. ;   0001  0    MODULE KERTT (IDENT = '2.0.004'
  2. ;   0002  0            ) =
  3. ;   0003  1    BEGIN
  4. ;   0004  1    
  5. ;   0005  1    SWITCHES LANGUAGE (COMMON);
  6. ;   0006  1    
  7. ;   0007  1    !<BLF/WIDTH:100>
  8. ;   0008  1    
  9. ;   0009  1    !++
  10. ;   0010  1    ! FACILITY:
  11. ;   0011  1    !
  12. ;   0012  1    !    KERMIT text processing
  13. ;   0013  1    !
  14. ;   0014  1    ! ABSTRACT:
  15. ;   0015  1    !
  16. ;   0016  1    !    This module contains all of the text processing required for
  17. ;   0017  1    !    KERMSG.
  18. ;   0018  1    !
  19. ;   0019  1    ! ENVIRONMENT:
  20. ;   0020  1    !
  21. ;   0021  1    !    TOPS-10, P/OS, VAX/VMS
  22. ;   0022  1    !
  23. ;   0023  1    ! AUTHOR: Robert C. McQueen, CREATION DATE: 29-August-1983
  24. ;   0024  1    !--
  25. ;   0025  1    
  26. ;   0026  1     %SBTTL 'Table of Contents'
  27. ;   0027  1    !
  28. ;   0028  1    ! TABLE OF CONTENTS:
  29. ;   0029  1    !
  30. ;   0030  1     %SBTTL 'Revision History'
  31. ;   0031  1    
  32. ;   0032  1    !++
  33. ;   0033  1    !
  34. ;   0034  1    ! Create this module for PRO/Kermit 1.0, Kermit-10 2(100) and Kermit-32 1.2
  35. ;   0035  1    !
  36. ;   0036  1    ! 1.2.000    By: Robert C. McQueen            On: 29-August-1983
  37. ;   0037  1    !        Create this module.
  38. ;   0038  1    !
  39. ;   0039  1    ! 1.2.001    By: Robert C. McQueen        On: 9-Sept-1983
  40. ;   0040  1    !        Make the string passed to TERM_DUMP a counted ASCIZ string,
  41. ;   0041  1    !        not a counted ASCII string.
  42. ;   0042  1    !
  43. ;   0043  1    ! 1.2.002    By: Robert C. McQueen        On: 16-September-1983
  44. ;   0044  1    !        Make TT_OUTPUT a global routine, so we can force information
  45. ;   0045  1    !        output a various points in time.
  46. ;   0046  1    !
  47. ;   0047  1    ! 2.0.003    Release for TOPS-10 KERMIT-10 version 2.
  48. ;   0048  1    !        Release for VAX/VMS KERMIT-32 version 2.
  49. ;   0049  1    !
  50. ;   0050  1    ! 2.0.004    By: Nick Bush            On: 22-December-1983
  51. ;   0051  1    !        Add TT_HOLD to indicate that output should not be dumped
  52. ;   0052  1    !        when LF's are seen, only when buffer is full.
  53. ;   0053  1    !--
  54. ;   0054  1    
  55. ;   0055  1     %SBTTL 'Library files'
  56. ;   0056  1    !
  57. ;   0057  1    ! INCLUDE FILES:
  58. ;   0058  1    !
  59. ;   0059  1    !
  60. ;   0060  1    ! KERMIT common definitions
  61. ;   0061  1    !
  62. ;   0062  1    
  63. ;   0063  1    REQUIRE 'KERCOM';
  64. ;   0272  1    
  65. ;   0273  1     %SBTTL 'Symbol definitions'
  66. ;   0274  1    !
  67. ;   0275  1    ! EQUATED SYMBOLS:
  68. ;   0276  1    !
  69. ;   0277  1    
  70. ;   0278  1    LITERAL
  71. ;   0279  1        TEXT_BFR_LENGTH = 256;            ! Length of the text buffer
  72. ;   0280  1    
  73. ;   0281  1     %SBTTL 'Storage'
  74. ;   0282  1    !
  75. ;   0283  1    ! OWN STORAGE:
  76. ;   0284  1    !
  77. ;   0285  1    !
  78. ;   0286  1    ! TT_xxxxx routine storage
  79. ;   0287  1    !
  80. ;   0288  1    
  81. ;   0289  1    OWN
  82. ;   0290  1        HOLD_FLAG,                    ! Output should be held even if CRLF seen
  83. ;   0291  1        DUMP_ROUTINE,                ! Address of routine to dump text
  84. ;   0292  1        TEXT_COUNT,                    ! Count of the characters
  85. ;   0293  1        TEXT_POINTER,                ! Pointer to store characters
  86. ;   0294  1        TEXT_BUFFER : VECTOR [CH$ALLOCATION (TEXT_BFR_LENGTH)];    ! Buffer of characters
  87. ;   0295  1    
  88. ;   0296  1     %SBTTL 'External storage'
  89. ;   0297  1    
  90. ;   0298  1    !++
  91. ;   0299  1    ! The following is the various external storage locations that are
  92. ;   0300  1    ! referenced from this module.
  93. ;   0301  1    !--
  94. ;   0302  1    
  95. ;   0303  1    !
  96. ;   0304  1    ! KERMSG storage
  97. ;   0305  1    !
  98. ;   0306  1    
  99. ;   0307  1    EXTERNAL
  100. ;   0308  1        CONNECT_FLAG;                ! Flag if communications line is TT:
  101. ;   0309  1    
  102. ;   0310  1    !++
  103. ;   0311  1    ! The following is the only external routine used by this module.  This
  104. ;   0312  1    ! routine will cause the terminal buffer that we have been building to be
  105. ;   0313  1    ! output on the terminal
  106. ;   0314  1    !--
  107. ;   0315  1    
  108. ;   0316  1    EXTERNAL ROUTINE
  109. ;   0317  1        TERM_DUMP : NOVALUE;            ! Output the terminal buffer
  110. ;   0318  1    
  111. ;   0319  1     %SBTTL 'Terminal routines -- TT_INIT - Initialize this module'
  112. ;   0320  1    
  113. ;   0321  1    GLOBAL ROUTINE TT_INIT : NOVALUE =
  114. ;   0322  1    
  115. ;   0323  1    !++
  116. ;   0324  1    ! FUNCTIONAL DESCRIPTION:
  117. ;   0325  1    !
  118. ;   0326  1    !    This routine will initialize the terminal processing module.  It will
  119. ;   0327  1    !    initialize the various data locations in this module.
  120. ;   0328  1    !
  121. ;   0329  1    ! CALLING SEQUENCE:
  122. ;   0330  1    !
  123. ;   0331  1    !    TT_INIT();
  124. ;   0332  1    !
  125. ;   0333  1    ! INPUT PARAMETERS:
  126. ;   0334  1    !
  127. ;   0335  1    !    None.
  128. ;   0336  1    !
  129. ;   0337  1    ! IMPLICIT INPUTS:
  130. ;   0338  1    !
  131. ;   0339  1    !    None.
  132. ;   0340  1    !
  133. ;   0341  1    ! OUTPUT PARAMETERS:
  134. ;   0342  1    !
  135. ;   0343  1    !    None.
  136. ;   0344  1    !
  137. ;   0345  1    ! IMPLICIT OUTPUTS:
  138. ;   0346  1    !
  139. ;   0347  1    !    None.
  140. ;   0348  1    !
  141. ;   0349  1    ! COMPLETION CODES:
  142. ;   0350  1    !
  143. ;   0351  1    !    None.
  144. ;   0352  1    !
  145. ;   0353  1    ! SIDE EFFECTS:
  146. ;   0354  1    !
  147. ;   0355  1    !    None.
  148. ;   0356  1    !
  149. ;   0357  1    !--
  150. ;   0358  1    
  151. ;   0359  2        BEGIN
  152. ;   0360  2    !
  153. ;   0361  2    ! Now initialize the various pointers
  154. ;   0362  2    !
  155. ;   0363  2        TEXT_COUNT = 0;
  156. ;   0364  2        TEXT_POINTER = CH$PTR (TEXT_BUFFER);
  157. ;   0365  2        DUMP_ROUTINE = TERM_DUMP;            ! Initial output routine is to terminal
  158. ;   0366  2        HOLD_FLAG = FALSE;                ! Dump output on CRLF's
  159. ;   0367  1        END;                    ! End of TT_INIT
  160.  
  161.  
  162.     .TITLE  KERTT
  163.     .IDENT  \2.0.004\
  164.  
  165.     .PSECT  $OWN$,NOEXE,2
  166.  
  167. ;HOLD_FLAG
  168. U.1:    .BLKB   4                                       ;                      00000
  169. ;DUMP_ROUTINE
  170. U.2:    .BLKB   4                                       ;                      00004
  171. ;TEXT_COUNT
  172. U.3:    .BLKB   4                                       ;                      00008
  173. ;TEXT_POINTER
  174. U.4:    .BLKB   4                                       ;                      0000C
  175. ;TEXT_BUFFER
  176. U.5:    .BLKB   256                                       ;                      00010
  177.  
  178. FNM_NORMAL==        1
  179. FNM_FULL==        2
  180. FNM_UNTRAN==        4
  181. PR_MIN==        0
  182. PR_NONE==        0
  183. PR_MARK==        1
  184. PR_EVEN==        2
  185. PR_ODD==        3
  186. PR_SPACE==        4
  187. PR_MAX==        4
  188. GC_MIN==        1
  189. GC_EXIT==        1
  190. GC_DIRECTORY==        2
  191. GC_DISK_USAGE==     3
  192. GC_DELETE==        4
  193. GC_TYPE==        5
  194. GC_HELP==        6
  195. GC_LOGOUT==        7
  196. GC_LGN==        8
  197. GC_CONNECT==        9
  198. GC_RENAME==        10
  199. GC_COPY==        11
  200. GC_WHO==        12
  201. GC_SEND_MSG==        13
  202. GC_STATUS==        14
  203. GC_COMMAND==        15
  204. GC_KERMIT==        16
  205. GC_JOURNAL==        17
  206. GC_VARIABLE==        18
  207. GC_PROGRAM==        19
  208. GC_MAX==        19
  209. DP_FULL==        0
  210. DP_HALF==        1
  211. CHK_1CHAR==        49
  212. CHK_2CHAR==        50
  213. CHK_CRC==        51
  214. MAX_MSG==        1002
  215.     .EXTRN  CONNECT_FLAG, TERM_DUMP
  216.  
  217.     .PSECT  $CODE$,NOWRT,2
  218.  
  219.     .ENTRY  TT_INIT, ^M<R2>             ;TT_INIT, Save R2               0321                    0004   00000
  220.     MOVAB   W^U.3, R2             ;U.3, R2                                     52     0000'  CF  9E   00002
  221.     CLRL    (R2)                 ;TEXT_COUNT                   0363                  62  D4   00007
  222.     MOVAB   8(R2), 4(R2)             ;TEXT_BUFFER, TEXT_POINTER           0364       04   A2    08   A2  9E   00009
  223.     MOVAB   W^TERM_DUMP, -4(R2)         ;TERM_DUMP, DUMP_ROUTINE           0365       FC   A2     0000G  CF  9E   0000E
  224.     CLRL    -8(R2)                 ;HOLD_FLAG                   0366             F8   A2  D4   00014
  225.     RET                      ;                       0367                  04   00017
  226.  
  227. ; Routine Size:  24 bytes,    Routine Base:  $CODE$ + 0000
  228.  
  229.  
  230. ;   0368  1    
  231. ;   0369  1     %SBTTL 'TT_SET_OUTPUT - Set output routine to use'
  232. ;   0370  1    
  233. ;   0371  1    GLOBAL ROUTINE TT_SET_OUTPUT (OUT_RTN) =
  234. ;   0372  1    
  235. ;   0373  1    !++
  236. ;   0374  1    ! FUNCTIONAL DESCRIPTION:
  237. ;   0375  1    !
  238. ;   0376  1    ! This routine will set the output routine to use for the TT_xxx routines.
  239. ;   0377  1    !The argument is a routine address which will output a counted ASCIZ string.
  240. ;   0378  1    !It will return the address of the previous output routine.
  241. ;   0379  1    !
  242. ;   0380  1    ! CALLING SEQUENCE:
  243. ;   0381  1    !
  244. ;   0382  1    !    OLD_RTN = TT_SET_OUTPUT (OUT_RTN);
  245. ;   0383  1    !
  246. ;   0384  1    ! INPUT PARAMETERS:
  247. ;   0385  1    !
  248. ;   0386  1    !    OUT_RTN - Address of routine to output a counted ASCIZ string
  249. ;   0387  1    !        called as OUT_RTN (Address of string, length of string)
  250. ;   0388  1    !
  251. ;   0389  1    ! IMPLICIT INPUTS:
  252. ;   0390  1    !
  253. ;   0391  1    !    DUMP_ROUTINE - Previous output routine
  254. ;   0392  1    !
  255. ;   0393  1    ! OUPTUT PARAMETERS:
  256. ;   0394  1    !
  257. ;   0395  1    !    The value of the routine is the previous output routine address.
  258. ;   0396  1    !
  259. ;   0397  1    ! IMPLICIT OUTPUTS:
  260. ;   0398  1    !
  261. ;   0399  1    !    DUMP_ROUTINE - New output routine
  262. ;   0400  1    !
  263. ;   0401  1    ! COMPLETION CODES:
  264. ;   0402  1    !
  265. ;   0403  1    !    None.
  266. ;   0404  1    !
  267. ;   0405  1    ! SIDE EFFECTS:
  268. ;   0406  1    !
  269. ;   0407  1    !    None.
  270. ;   0408  1    !
  271. ;   0409  1    !--
  272. ;   0410  1    
  273. ;   0411  2        BEGIN
  274. ;   0412  2    
  275. ;   0413  2        LOCAL
  276. ;   0414  2        OLD_RTN;                ! Old routine address
  277. ;   0415  2    
  278. ;   0416  2        OLD_RTN = .DUMP_ROUTINE;            ! Remember the old address
  279. ;   0417  2        DUMP_ROUTINE = .OUT_RTN;            ! Save the new
  280. ;   0418  2        RETURN .OLD_RTN;                ! And return the old value
  281. ;   0419  1        END;                    ! End of TT_SET_OUTPUT
  282.  
  283.  
  284.  
  285.  
  286.  
  287.     .ENTRY  TT_SET_OUTPUT, ^M<>         ;TT_SET_OUTPUT, Save nothing           0371                    0000   00000
  288.     MOVL    W^U.2, R0             ;U.2, OLD_RTN                   0416            50     0000'  CF  D0   00002
  289.     MOVL    4(AP), W^U.2             ;OUT_RTN, U.2                   0417     0000'  CF    04   AC  D0   00007
  290.     RET                      ;                       0418                  04   0000D
  291.  
  292. ; Routine Size:  14 bytes,    Routine Base:  $CODE$ + 0018
  293.  
  294.  
  295. ;   0420  1    
  296. ;   0421  1     %SBTTL 'TT_HOLD - Start holding text until TT_OUTPUT call'
  297. ;   0422  1    
  298. ;   0423  1    GLOBAL ROUTINE TT_HOLD (FLAG) : NOVALUE =
  299. ;   0424  1    
  300. ;   0425  1    !++
  301. ;   0426  1    ! FUNCTIONAL DESCRIPTION:
  302. ;   0427  1    !
  303. ;   0428  1    !    This routine is called to start buffering an amount of data
  304. ;   0429  1    !    which should not be output until TT_OUTPUT is called.  It
  305. ;   0430  1    !    sets a flag to indicate that output should not be done on
  306. ;   0431  1    !    CRLF's.
  307. ;   0432  1    !
  308. ;   0433  1    ! CALLING SEQUENCE:
  309. ;   0434  1    !
  310. ;   0435  1    !    TT_HOLD (TRUE or FALSE);
  311. ;   0436  1    !
  312. ;   0437  1    ! INPUT PARAMETERS:
  313. ;   0438  1    !
  314. ;   0439  1    !    FLAG - True if output should be held past LF's.  False if output
  315. ;   0440  1    !           should be dumped on each LF.
  316. ;   0441  1    !
  317. ;   0442  1    ! IMPLICIT INPUTS:
  318. ;   0443  1    !
  319. ;   0444  1    !    None.
  320. ;   0445  1    !
  321. ;   0446  1    ! OUPTUT PARAMETERS:
  322. ;   0447  1    !
  323. ;   0448  1    !    None.
  324. ;   0449  1    !
  325. ;   0450  1    ! IMPLICIT OUTPUTS:
  326. ;   0451  1    !
  327. ;   0452  1    !    HOLD_FLAG is set to true.
  328. ;   0453  1    !
  329. ;   0454  1    ! COMPLETION CODES:
  330. ;   0455  1    !
  331. ;   0456  1    !    None.
  332. ;   0457  1    !
  333. ;   0458  1    ! SIDE EFFECTS:
  334. ;   0459  1    !
  335. ;   0460  1    !    None.
  336. ;   0461  1    !
  337. ;   0462  1    !--
  338. ;   0463  1    
  339. ;   0464  2        BEGIN
  340. ;   0465  2        HOLD_FLAG = .FLAG;
  341. ;   0466  1        END;                    ! End of TT_HOLD
  342.  
  343.  
  344.  
  345.  
  346.  
  347.     .ENTRY  TT_HOLD, ^M<>             ;TT_HOLD, Save nothing               0423                    0000   00000
  348.     MOVL    4(AP), W^U.1             ;FLAG, U.1                   0465     0000'  CF    04   AC  D0   00002
  349.     RET                      ;                       0466                  04   00008
  350.  
  351. ; Routine Size:  9 bytes,    Routine Base:  $CODE$ + 0026
  352.  
  353.  
  354. ;   0467  1    
  355. ;   0468  1     %SBTTL 'Terminal routines -- TT_OUTPUT - Output the buffer'
  356. ;   0469  1    
  357. ;   0470  1    GLOBAL ROUTINE TT_OUTPUT : NOVALUE =
  358. ;   0471  1    
  359. ;   0472  1    !++
  360. ;   0473  1    ! FUNCTIONAL DESCRIPTION:
  361. ;   0474  1    !
  362. ;   0475  1    !    This routine will dump the text buffer on the output device.
  363. ;   0476  1    !
  364. ;   0477  1    ! CALLING SEQUENCE:
  365. ;   0478  1    !
  366. ;   0479  1    !    TT_OUTPUT();
  367. ;   0480  1    !
  368. ;   0481  1    ! INPUT PARAMETERS:
  369. ;   0482  1    !
  370. ;   0483  1    !    None.
  371. ;   0484  1    !
  372. ;   0485  1    ! IMPLICIT INPUTS:
  373. ;   0486  1    !
  374. ;   0487  1    !    None.
  375. ;   0488  1    !
  376. ;   0489  1    ! OUTPUT PARAMETERS:
  377. ;   0490  1    !
  378. ;   0491  1    !    None.
  379. ;   0492  1    !
  380. ;   0493  1    ! IMPLICIT OUTPUTS:
  381. ;   0494  1    !
  382. ;   0495  1    !    None.
  383. ;   0496  1    !
  384. ;   0497  1    ! COMPLETION CODES:
  385. ;   0498  1    !
  386. ;   0499  1    !    None.
  387. ;   0500  1    !
  388. ;   0501  1    ! SIDE EFFECTS:
  389. ;   0502  1    !
  390. ;   0503  1    !    None.
  391. ;   0504  1    !
  392. ;   0505  1    !--
  393. ;   0506  1    
  394. ;   0507  2        BEGIN
  395. ;   0508  2    
  396. ;   0509  2        LOCAL
  397. ;   0510  2        STATUS;                    ! Status returned by the library routine
  398. ;   0511  2    
  399. ;   0512  2    !
  400. ;   0513  2    ! Output the text
  401. ;   0514  2    !
  402. ;   0515  2        CH$WCHAR_A (CHR_NUL, TEXT_POINTER);
  403. ;   0516  2        (.DUMP_ROUTINE) (TEXT_BUFFER, .TEXT_COUNT);    ! Output the buffer to the correct place
  404. ;   0517  2    !
  405. ;   0518  2    ! Now reset the descriptor and the pointer to a virgin state
  406. ;   0519  2    !
  407. ;   0520  2        TEXT_COUNT = 0;
  408. ;   0521  2        TEXT_POINTER = CH$PTR (TEXT_BUFFER);
  409. ;   0522  2    !
  410. ;   0523  1        END;                    ! End of TT_OUTPUT
  411.  
  412.  
  413.  
  414.  
  415.  
  416.     .ENTRY  TT_OUTPUT, ^M<R2>         ;TT_OUTPUT, Save R2               0470                    0004   00000
  417.     MOVAB   W^U.4, R2             ;U.4, R2                                     52     0000'  CF  9E   00002
  418.     CLRB    @0(R2)                 ;@TEXT_POINTER                   0515             00   B2  94   00007
  419.     INCL    (R2)                 ;TEXT_POINTER                                           62  D6   0000A
  420.     PUSHL   -4(R2)                 ;TEXT_COUNT                   0516             FC   A2  DD   0000C
  421.     PUSHAB  4(R2)                 ;TEXT_BUFFER                                      04   A2  9F   0000F
  422.     CALLS   #2, @-8(R2)             ;#2, @DUMP_ROUTINE                            F8   B2         02  FB   00012
  423.     CLRL    -4(R2)                 ;TEXT_COUNT                   0520             FC   A2  D4   00016
  424.     MOVAB   4(R2), (R2)             ;TEXT_BUFFER, TEXT_POINTER           0521            62    04   A2  9E   00019
  425.     RET                      ;                       0523                  04   0001D
  426.  
  427. ; Routine Size:  30 bytes,    Routine Base:  $CODE$ + 002F
  428.  
  429.  
  430. ;   0524  1    
  431. ;   0525  1     %SBTTL 'Terminal routines -- TT_CHAR - Output a single character'
  432. ;   0526  1    
  433. ;   0527  1    GLOBAL ROUTINE TT_CHAR (CHARACTER) : NOVALUE =
  434. ;   0528  1    
  435. ;   0529  1    !++
  436. ;   0530  1    ! FUNCTIONAL DESCRIPTION:
  437. ;   0531  1    !
  438. ;   0532  1    !    This routine will store a character into the text buffer.  It will
  439. ;   0533  1    !    cause the text to be output if the character is a line terminator.
  440. ;   0534  1    !
  441. ;   0535  1    ! CALLING SEQUENCE:
  442. ;   0536  1    !
  443. ;   0537  1    !    TT_CHAR(Character);
  444. ;   0538  1    !
  445. ;   0539  1    ! INPUT PARAMETERS:
  446. ;   0540  1    !
  447. ;   0541  1    !    Character - Character to store into the text buffer.
  448. ;   0542  1    !
  449. ;   0543  1    ! IMPLICIT INPUTS:
  450. ;   0544  1    !
  451. ;   0545  1    !    None.
  452. ;   0546  1    !
  453. ;   0547  1    ! OUTPUT PARAMETERS:
  454. ;   0548  1    !
  455. ;   0549  1    !    None.
  456. ;   0550  1    !
  457. ;   0551  1    ! IMPLICIT OUTPUTS:
  458. ;   0552  1    !
  459. ;   0553  1    !    None.
  460. ;   0554  1    !
  461. ;   0555  1    ! COMPLETION CODES:
  462. ;   0556  1    !
  463. ;   0557  1    !    None.
  464. ;   0558  1    !
  465. ;   0559  1    ! SIDE EFFECTS:
  466. ;   0560  1    !
  467. ;   0561  1    !    None.
  468. ;   0562  1    !
  469. ;   0563  1    !--
  470. ;   0564  1    
  471. ;   0565  2        BEGIN
  472. ;   0566  2    !
  473. ;   0567  2    ! Increment the count of the characters
  474. ;   0568  2    !
  475. ;   0569  2        TEXT_COUNT = .TEXT_COUNT + 1;
  476. ;   0570  2    !
  477. ;   0571  2    ! And store the character
  478. ;   0572  2    !
  479. ;   0573  2        CH$WCHAR_A (.CHARACTER, TEXT_POINTER);
  480. ;   0574  2    !
  481. ;   0575  2    ! If this is a line feed then just output the text string
  482. ;   0576  2    !
  483. ;   0577  2    
  484. ;   0578  2        IF (.CHARACTER EQL CHR_LFD) AND NOT .HOLD_FLAG THEN TT_OUTPUT ();
  485. ;   0579  2    
  486. ;   0580  2    !
  487. ;   0581  2    ! Check to make sure we are not exceeding the limit of the buffer
  488. ;   0582  2    !
  489. ;   0583  2    
  490. ;   0584  2        IF .TEXT_COUNT EQL TEXT_BFR_LENGTH - 1 THEN TT_OUTPUT ();
  491. ;   0585  2    
  492. ;   0586  2    !
  493. ;   0587  1        END;                    ! End of TT_CHAR
  494.  
  495.  
  496.  
  497.  
  498.  
  499.     .ENTRY  TT_CHAR, ^M<R2>             ;TT_CHAR, Save R2               0527                    0004   00000
  500.     MOVAB   W^U.3, R2             ;U.3, R2                                     52     0000'  CF  9E   00002
  501.     INCL    (R2)                 ;TEXT_COUNT                   0569                  62  D6   00007
  502.     MOVB    4(AP), @4(R2)             ;CHARACTER, @TEXT_POINTER           0573       04   B2    04   AC  90   00009
  503.     INCL    4(R2)                 ;TEXT_POINTER                                      04   A2  D6   0000E
  504.     CMPL    4(AP), #10             ;CHARACTER, #10               0578            0A    04   AC  D1   00011
  505.     BNEQ    1$                 ;1$                                               08  12   00015
  506.     BLBS    -8(R2), 1$             ;HOLD_FLAG, 1$                                     04    F8   A2  E8   00017
  507.     CALLS   #0, B^TT_OUTPUT             ;#0, TT_OUTPUT                                C3   AF         00  FB   0001B
  508. 1$:    CMPL    (R2), #255             ;TEXT_COUNT, #255               0584 000000FF   8F         62  D1   0001F
  509.     BNEQ    2$                 ;2$                                               04  12   00026
  510.     CALLS   #0, B^TT_OUTPUT             ;#0, TT_OUTPUT                                B6   AF         00  FB   00028
  511. 2$:    RET                      ;                       0587                  04   0002C
  512.  
  513. ; Routine Size:  45 bytes,    Routine Base:  $CODE$ + 004D
  514.  
  515.  
  516. ;   0588  1    
  517. ;   0589  1     %SBTTL 'Terminal routines -- TT_TEXT - Output a text string'
  518. ;   0590  1    
  519. ;   0591  1    GLOBAL ROUTINE TT_TEXT (ADDRESS) : NOVALUE =
  520. ;   0592  1    
  521. ;   0593  1    !++
  522. ;   0594  1    ! FUNCTIONAL DESCRIPTION:
  523. ;   0595  1    !
  524. ;   0596  1    !    This routine will output text on the user's terminal.  It will
  525. ;   0597  1    !    assume that it must check to determine if it can output the text
  526. ;   0598  1    !    or not.
  527. ;   0599  1    !
  528. ;   0600  1    ! CALLING SEQUENCE:
  529. ;   0601  1    !
  530. ;   0602  1    !    TT_TEXT(TEXT_ADDRESS);
  531. ;   0603  1    !
  532. ;   0604  1    ! INPUT PARAMETERS:
  533. ;   0605  1    !
  534. ;   0606  1    !    None.
  535. ;   0607  1    !
  536. ;   0608  1    ! IMPLICIT INPUTS:
  537. ;   0609  1    !
  538. ;   0610  1    !    None.
  539. ;   0611  1    !
  540. ;   0612  1    ! OUTPUT PARAMETERS:
  541. ;   0613  1    !
  542. ;   0614  1    !    None.
  543. ;   0615  1    !
  544. ;   0616  1    ! IMPLICIT OUTPUTS:
  545. ;   0617  1    !
  546. ;   0618  1    !    None.
  547. ;   0619  1    !
  548. ;   0620  1    ! COMPLETION CODES:
  549. ;   0621  1    !
  550. ;   0622  1    !    None.
  551. ;   0623  1    !
  552. ;   0624  1    ! SIDE EFFECTS:
  553. ;   0625  1    !
  554. ;   0626  1    !    None.
  555. ;   0627  1    !
  556. ;   0628  1    !--
  557. ;   0629  1    
  558. ;   0630  2        BEGIN
  559. ;   0631  2    
  560. ;   0632  2        LOCAL
  561. ;   0633  2        CHARACTER,                ! Character being processed
  562. ;   0634  2        ARG_POINTER;                ! Pointer to the argument's text
  563. ;   0635  2    
  564. ;   0636  2    !
  565. ;   0637  2    ! Construct a pointer to the argument.
  566. ;   0638  2    !
  567. ;   0639  2        ARG_POINTER = CH$PTR (.ADDRESS);
  568. ;   0640  2    !
  569. ;   0641  2    ! Get the first character that was passed.
  570. ;   0642  2    !
  571. ;   0643  2        CHARACTER = CH$RCHAR_A (ARG_POINTER);
  572. ;   0644  2    !
  573. ;   0645  2    ! Loop reading characters and calling the output routine to process
  574. ;   0646  2    ! them
  575. ;   0647  2    !
  576. ;   0648  2    
  577. ;   0649  2        WHILE .CHARACTER NEQ CHR_NUL DO
  578. ;   0650  3        BEGIN
  579. ;   0651  3        TT_CHAR (.CHARACTER);
  580. ;   0652  3        CHARACTER = CH$RCHAR_A (ARG_POINTER);
  581. ;   0653  2        END;
  582. ;   0654  2    
  583. ;   0655  1        END;                    ! End of TT_TEXT
  584.  
  585.  
  586.  
  587.  
  588.  
  589.     .ENTRY  TT_TEXT, ^M<R2,R3>         ;TT_TEXT, Save R2,R3               0591                    000C   00000
  590.     MOVL    4(AP), R2             ;ADDRESS, ARG_POINTER               0639            52    04   AC  D0   00002
  591. 1$:    MOVZBL  (R2)+, R3             ;(ARG_POINTER)+, CHARACTER           0643            53         82  9A   00006
  592.     BEQL    2$                 ;2$                       0649                  08  13   00009
  593.     PUSHL   R3                 ;CHARACTER                   0651                  53  DD   0000B
  594.     CALLS   #1, B^TT_CHAR             ;#1, TT_CHAR                                C2   AF         01  FB   0000D
  595.     BRB     1$                 ;1$                       0652                  F3  11   00011
  596. 2$:    RET                      ;                       0655                  04   00013
  597.  
  598. ; Routine Size:  20 bytes,    Routine Base:  $CODE$ + 007A
  599.  
  600.  
  601. ;   0656  1    
  602. ;   0657  1     %SBTTL 'Terminal routines -- TT_NUMBER - Output a three digit number'
  603. ;   0658  1    
  604. ;   0659  1    GLOBAL ROUTINE TT_NUMBER (NUMBER) : NOVALUE =
  605. ;   0660  1    
  606. ;   0661  1    !++
  607. ;   0662  1    ! FUNCTIONAL DESCRIPTION:
  608. ;   0663  1    !
  609. ;   0664  1    !    This routine will store a three digit number into the text buffer.
  610. ;   0665  1    !    It will just return if the number is greater than 999.
  611. ;   0666  1    !
  612. ;   0667  1    ! CALLING SEQUENCE:
  613. ;   0668  1    !
  614. ;   0669  1    !    TT_NUMBER(Value);
  615. ;   0670  1    !
  616. ;   0671  1    ! INPUT PARAMETERS:
  617. ;   0672  1    !
  618. ;   0673  1    !    Value - Value to output.
  619. ;   0674  1    !
  620. ;   0675  1    ! IMPLICIT INPUTS:
  621. ;   0676  1    !
  622. ;   0677  1    !    None.
  623. ;   0678  1    !
  624. ;   0679  1    ! OUTPUT PARAMETERS:
  625. ;   0680  1    !
  626. ;   0681  1    !    None.
  627. ;   0682  1    !
  628. ;   0683  1    ! IMPLICIT OUTPUTS:
  629. ;   0684  1    !
  630. ;   0685  1    !    None.
  631. ;   0686  1    !
  632. ;   0687  1    ! COMPLETION CODES:
  633. ;   0688  1    !
  634. ;   0689  1    !    None.
  635. ;   0690  1    !
  636. ;   0691  1    ! SIDE EFFECTS:
  637. ;   0692  1    !
  638. ;   0693  1    !    None.
  639. ;   0694  1    !
  640. ;   0695  1    !--
  641. ;   0696  1    
  642. ;   0697  2        BEGIN
  643. ;   0698  2        ROUTINE TT_NUM_WORKER (VALUE) : NOVALUE =
  644. ;   0699  3        BEGIN
  645. ;   0700  3    
  646. ;   0701  3        IF .VALUE LEQ 9
  647. ;   0702  3        THEN
  648. ;   0703  3            TT_CHAR (.VALUE + %C'0')
  649. ;   0704  3        ELSE
  650. ;   0705  4            BEGIN
  651. ;   0706  4            TT_NUM_WORKER (.VALUE/10);
  652. ;   0707  4            TT_CHAR ((.VALUE MOD 10) + %C'0');
  653. ;   0708  3            END;
  654. ;   0709  3    
  655. ;   0710  2        END;
  656.  
  657.  
  658.  
  659.  
  660.  
  661. ;TT_NUM_WORKER
  662. U.13:    .WORD   ^M<>                 ;Save nothing                   0698                    0000   00000
  663.     CMPL    4(AP), #9             ;VALUE, #9                   0701            09    04   AC  D1   00002
  664.     BGTR    1$                 ;1$                                               07  14   00006
  665.     ADDL3   #48, 4(AP), -(SP)         ;#48, VALUE, -(SP)               0703       04   AC         30  C1   00008
  666.                          ;                                         7E       0000C
  667.     BRB     2$                 ;2$                                               17  11   0000D
  668. 1$:    DIVL3   #10, 4(AP), -(SP)         ;#10, VALUE, -(SP)               0706       04   AC         0A  C7   0000F
  669.                          ;                                         7E       00013
  670.     CALLS   #1, B^U.13             ;#1, U.13                                E8   AF         01  FB   00014
  671.     EMUL    #1, 4(AP), #0, -(SP)         ;#1, VALUE, #0, -(SP)               0707       04   AC         01  7A   00018
  672.                          ;                                   7E         00       0001C
  673.     EDIV    #10, (SP)+, R0, R0         ;#10, (SP)+, R0, R0                                 8E         0A  7B   0001E
  674.                          ;                                   50         50       00021
  675.     PUSHAB  48(R0)                 ;48(R0)                                      30   A0  9F   00023
  676. 2$:    CALLS   #1, B^TT_CHAR             ;#1, TT_CHAR                                95   AF         01  FB   00026
  677.     RET                      ;                       0710                  04   0002A
  678.  
  679. ; Routine Size:  43 bytes,    Routine Base:  $CODE$ + 008E
  680.  
  681.  
  682. ;   0711  2    
  683. ;   0712  2        IF .NUMBER LSS 0
  684. ;   0713  2        THEN
  685. ;   0714  3        BEGIN
  686. ;   0715  3        TT_CHAR (%C'-');
  687. ;   0716  3        NUMBER = -.NUMBER;
  688. ;   0717  2        END;
  689. ;   0718  2    
  690. ;   0719  2        TT_NUM_WORKER (.NUMBER);
  691. ;   0720  1        END;                    ! End of TT_NUMBER
  692.  
  693.  
  694.  
  695.  
  696.  
  697.     .ENTRY  TT_NUMBER, ^M<>             ;TT_NUMBER, Save nothing           0659                    0000   00000
  698.     TSTL    4(AP)                 ;NUMBER                   0712             04   AC  D5   00002
  699.     BGEQ    1$                 ;1$                                               0B  18   00005
  700.     PUSHL   #45                 ;#45                       0715                  2D  DD   00007
  701.     CALLS   #1, B^TT_CHAR             ;#1, TT_CHAR                                87   AF         01  FB   00009
  702.     MNEGL   4(AP), 4(AP)             ;NUMBER, NUMBER               0716       04   AC    04   AC  CE   0000D
  703. 1$:    PUSHL   4(AP)                 ;NUMBER                   0719             04   AC  DD   00012
  704.     CALLS   #1, B^U.13             ;#1, U.13                                BC   AF         01  FB   00015
  705.     RET                      ;                       0720                  04   00019
  706.  
  707. ; Routine Size:  26 bytes,    Routine Base:  $CODE$ + 00B9
  708.  
  709.  
  710. ;   0721  1    
  711. ;   0722  1     %SBTTL 'Terminal routines -- TT_CRLF - Output a CRLF'
  712. ;   0723  1    
  713. ;   0724  1    GLOBAL ROUTINE TT_CRLF : NOVALUE =
  714. ;   0725  1    
  715. ;   0726  1    !++
  716. ;   0727  1    ! FUNCTIONAL DESCRIPTION:
  717. ;   0728  1    !
  718. ;   0729  1    !    This routine will cause the contents of the terminal buffer to be
  719. ;   0730  1    !    output to SYS$OUTPUT:.
  720. ;   0731  1    !
  721. ;   0732  1    ! CALLING SEQUENCE:
  722. ;   0733  1    !
  723. ;   0734  1    !    TT_CRLF();
  724. ;   0735  1    !
  725. ;   0736  1    ! INPUT PARAMETERS:
  726. ;   0737  1    !
  727. ;   0738  1    !    None.
  728. ;   0739  1    !
  729. ;   0740  1    ! IMPLICIT INPUTS:
  730. ;   0741  1    !
  731. ;   0742  1    !    None.
  732. ;   0743  1    !
  733. ;   0744  1    ! OUTPUT PARAMETERS:
  734. ;   0745  1    !
  735. ;   0746  1    !    None.
  736. ;   0747  1    !
  737. ;   0748  1    ! IMPLICIT OUTPUTS:
  738. ;   0749  1    !
  739. ;   0750  1    !    None.
  740. ;   0751  1    !
  741. ;   0752  1    ! COMPLETION CODES:
  742. ;   0753  1    !
  743. ;   0754  1    !    None.
  744. ;   0755  1    !
  745. ;   0756  1    ! SIDE EFFECTS:
  746. ;   0757  1    !
  747. ;   0758  1    !    None.
  748. ;   0759  1    !
  749. ;   0760  1    !--
  750. ;   0761  1    
  751. ;   0762  2        BEGIN
  752. ;   0763  2        TT_CHAR (CHR_CRT);
  753. ;   0764  2        TT_CHAR (CHR_LFD);
  754. ;   0765  1        END;                    ! End of TT_CRLF
  755.  
  756.  
  757.  
  758.  
  759.  
  760.     .ENTRY  TT_CRLF, ^M<>             ;TT_CRLF, Save nothing               0724                    0000   00000
  761.     PUSHL   #13                 ;#13                       0763                  0D  DD   00002
  762.     CALLS   #1, W^TT_CHAR             ;#1, TT_CHAR                              FF71   CF         01  FB   00004
  763.     PUSHL   #10                 ;#10                       0764                  0A  DD   00009
  764.     CALLS   #1, W^TT_CHAR             ;#1, TT_CHAR                              FF6A   CF         01  FB   0000B
  765.     RET                      ;                       0765                  04   00010
  766.  
  767. ; Routine Size:  17 bytes,    Routine Base:  $CODE$ + 00D3
  768.  
  769.  
  770. ;   0766  1    
  771. ;   0767  1     %SBTTL 'End of KERTRM'
  772. ;   0768  1    END                        ! End of module
  773. ;   0769  1    
  774. ;   0770  0    ELUDOM
  775.  
  776.  
  777.  
  778.  
  779.  
  780.  
  781. ;                       PSECT SUMMARY
  782. ;
  783. ;    Name             Bytes                   Attributes
  784. ;
  785. ;  $OWN$                  272  NOVEC,  WRT,  RD ,NOEXE,NOSHR,  LCL,  REL,  CON,NOPIC,ALIGN(2)
  786. ;  $CODE$                  228  NOVEC,NOWRT,  RD ,  EXE,NOSHR,  LCL,  REL,  CON,NOPIC,ALIGN(2)
  787. ;  .  ABS  .                    0  NOVEC,NOWRT,NORD ,NOEXE,NOSHR,  LCL,  ABS,  CON,NOPIC,ALIGN(0)
  788.  
  789.  
  790.  
  791.  
  792.  
  793.  
  794.  
  795. ;                    COMMAND QUALIFIERS
  796.  
  797. ;    BLI/LIS/MAC=(ASSEM,UNIQ)/SOUR:NOHEAD VMSTT
  798.  
  799. ; Compilation Complete
  800.  
  801.     .END
  802.