home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / decpro300 / profil.mac < prev    next >
Text File  |  2020-01-01  |  47KB  |  1,641 lines
  1.     .TITLE    KERFIL - KERMIT - FILE PROCESSING
  2.     .SBTTL    David Stevens, Stuart Hecht, Robert McQueen
  3.  
  4. ;
  5. ; Kerfil is the file processing routine for Pro/Kermit
  6. ;
  7. ;   Created on July 14,1983
  8. ;
  9. ;   Written by Stuart Hecht and David Stevens
  10. ;
  11. ; Version 1
  12. ;
  13.  
  14.     .IDENT    /1.0.09/
  15.  
  16. ; Directives
  17.  
  18.     .LIBRARY /KERMLB/
  19.     .LIBRARY /LB:[1,5]RMSMAC/
  20.     .ENABLE    LC
  21.     .NLIST    BEX
  22.  
  23.     .SBTTL    Revision History
  24.  
  25. ;++
  26. ; 1.0.00    By: Many            On: Long time
  27. ;        Create this module.
  28. ;
  29. ; 1.0.01    By: Nick Bush            On: 15-Feb-1984
  30. ;        Fix FILE.OPEN to make sure it always returns an
  31. ;        error when NEXT.FILE fails.  KERMSG is not expecting
  32. ;        a "no more files" return from FILE.OPEN.
  33. ;
  34. ; 1.0.02    By: Robert C. McQueen        On: 16-Feb-1984
  35. ;        Add checks for exceeding the size of the output buffer
  36. ;        for ASCII mode files.
  37. ; 
  38. ; 1.0.03    By: David Stevens        On: 21-Feb-1984
  39. ;        Make FILE.OPEN (send) usable in server mode,and have 
  40. ;        file.name contain the first file name before entering 
  41. ;        KERMSG.
  42. ;
  43. ; 1.0.04    By: Stuart Hecht        On: 06-Mar-1984
  44. ;        Change default device from 'LB:' to 'SY:' so that
  45. ;        PRO/Kermit can use a device other than the Library
  46. ;        default.  'SY:' uses the device from the default directory.
  47. ;
  48. ; 1.0.05    By: Robert C. McQueen        On: 6-March-1984
  49. ;        Restructure the sending of multiple files and use PJMPs when
  50. ;        possible.
  51. ;
  52. ; 1.0.06    By: Robert C. McQueen        On: 6-March-1984
  53. ;        Sending LSA files to the -10 do not work correctly.  The
  54. ;        problem is MOVBs extend the sign.  Rework some code to
  55. ;        not set the sign bit.
  56. ;
  57. ; 1.0.07    By: Robert C. McQueen        On: 14-March-1984
  58. ;        Redo the inter task communication between KERMIT and KERFIL.
  59. ;
  60. ; 1.0.08    By: Robert C. McQueen        On: 20-March-1984
  61. ;        Make M$RES global, so that we can use it from KERXFR.
  62. ;
  63. ; 1.0.09    By: Nick Bush            On: 21-May-1984
  64. ;        Initialize FILSTA when file is opened for reading.
  65. ;--
  66.  
  67.     .SBTTL    Kermit symbol definitions
  68. ;
  69. ; THe following will cause the Pro/Kermit symbol definitions to be include
  70. ; in this module.
  71. ;
  72.  
  73.     .MCALL    KERDEF            ; Get the macro
  74.     KERDEF                ; Cause the symbols to be defined
  75.  
  76.     .MCALL    CHRDEF            ; Character definition macro
  77.     CHRDEF                ; Define the special characters
  78.  
  79.     .MCALL    BITS            ; Bit definitions
  80.     BITS                ; Define bit definitions
  81.  
  82.     .MCALL    BLSRTN            ; Allow use of BLISS macros from
  83.     .MCALL    BLSCAL            ;   library
  84.     .MCALL    PJMP            ; Jump to subroutine that returns
  85.  
  86.     .SBTTL    RMS-11 Directives and macros
  87.  
  88. ;++
  89. ; RMS-11 directives and macros
  90. ;++
  91.  
  92. ;+
  93. ; RMS data strcutures
  94. ;-
  95.  
  96.     .MCALL    FAB$B            ; File attributes block
  97.     .MCALL    ORG$            ; Allowed organizations
  98.     .MCALL    NAM$B            ; Name block
  99.     .MCALL    RAB$B            ; Record attributes block
  100.  
  101. ;+
  102. ; RMS routines
  103. ;-
  104.  
  105.     .MCALL    $CLOSE            ; RMS routine to close a file
  106.     .MCALL    $CONNECT        ; RMS routine to connect RAB/FAB
  107.     .MCALL    $CREATE            ; Create a file
  108.     .MCALL    $DISCONNECT        ; RMS routine to disconnect RAB/FAB
  109.     .MCALL    $ERASE            ; RMS routine to delete a file
  110.     .MCALL    $GET            ; RMS routine to get a record
  111.     .MCALL    $OPEN            ; RMS routine to open a file
  112.     .MCALL    $PARSE            ; RMS routine to parse wildcards
  113.     .MCALL    $PUT            ; RMS routine to put a record
  114.     .MCALL    $READ            ; RMS routine to read a block
  115.     .MCALL    $SEARCH            ; RMS routine to search for a wild file
  116.     .MCALL    $WRITE            ; RMS routine to write a block
  117.  
  118. ;+
  119. ; RMS data structure access macros
  120. ;-
  121.  
  122.     .MCALL    $COMPARE
  123.     .MCALL    $FETCH
  124.     .MCALL    $OFF
  125.     .MCALL    $SET
  126.     .MCALL    $STORE
  127.     .MCALL    $TESTBITS
  128. ;
  129. ; RMS 11 data structure
  130. ;
  131.     ORG$    SEQ            ; $Open a sequential file
  132.  
  133.     .SBTTL    Symbol definitions -- File types
  134.  
  135. ;++
  136. ; The following are the various file types that are supported by
  137. ; Pro/Kermit.  These formats are used as offsets into tables to jump
  138. ; directly to the input routines associated with the various types.
  139. ;--
  140.  
  141. $TYCR    =0*2                ; Carriage return RAT
  142. $TYFTN    =1*2                ; Fortran RAT
  143. $TYPRN    =2*2                ; Printer file RAT
  144. $TYNONE    =3*2                ; No attribute file RAT
  145.  
  146.  
  147.  
  148.  
  149.     .SBTTL    Symbol definitions -- File reader states
  150.  
  151. ;++
  152. ; The file reader is a finite state machine.  It will dispatch to various
  153. ; states depending on the type of record attributes (RAT) are dealing with
  154. ; and what the position is in the record we are dealing with.
  155. ;--
  156.  
  157. $REPR1    =0*2                ; Record pre processing state 1
  158. $REPR2    =1*2                ; Record pre precessing state 2
  159. $RERD    =2*2                ; Record reading
  160. $REPS1    =3*2                ; Record post processing state 1
  161. $REPS2    =4*2                ; Record post prrocessing state 2
  162.  
  163. ; NOTE: *2 so that we can use directly into a dispatch table.
  164.  
  165.     .SBTTL    Data
  166.  
  167.     .PSECT    $OWN$,  D  
  168.  
  169. ;
  170. ; Data for Fab, Nam, & Rab blocks
  171. ;
  172.  
  173. RESSTR:    .BLKB    50.            ; Block for the resultant string.
  174. STRBUF:    .BLKB    128.            ; Expanded string buffer for search.
  175. DEFALT:    .ASCIZ    'SY:'            ;[04] System default.
  176. DEFALN    =.-DEFALT            ; Size of the default device.
  177.     .EVEN
  178.  
  179. ;++
  180. ; The following are used for reading character from the input file.
  181. ; These locations may be used by the print file, FORTRAN, or CRLF
  182. ; file record attribute routines.
  183. ;--
  184.  
  185. BYTCNT:    .BLKW    1            ; Holds the byte counter for send.
  186. BYTOFS:    .BLKW    1            ; Byte offset we are reading
  187. PRNCNT:    .BLKW    1            ; Count of the number of LFs to output
  188. PSTPRN:    .BLKW    1            ; Post print file byte
  189. CRFLG:    .BLKW    1            ; Must put CR on at end of record
  190. FILSTA:    .BLKW    1            ; Current state file reader is in
  191.  
  192. ;
  193. ; Locations needed for sending of the next file
  194. ;
  195.  
  196. SIZPOI:    .blkw    1            ; Pointer to size of next filename.
  197. FILPOI:    .blkw    1            ; Pointer to next filename.
  198.  
  199. ;
  200. ; Flag for Send/Receive
  201. ;
  202.  
  203. LSTFG:    .BLKW    1            ; Last file flag.
  204. FORMAT:    .BLKW    1            ; Format type for opened file.
  205. CRLF.FLG:
  206.     .BLKW    1            ; Carriage return line feed flag.
  207. M$POS:    .ASCIZ    <.CHCSI>/23;1H/<.CHLF><.CHLF><.CHCSI>/23;1H/
  208. M$RES::    .BYTE    .CHLF,.CHCR
  209.     .ASCII    'Please press RESUME to continue'
  210.     .BYTE    .CHCR,.CHNUL
  211.     .EVEN
  212.  
  213.     .SBTTL    FAB, NAM, and RAB blocks for send
  214.  
  215.     .PSECT    $PLIT$, RO, D
  216.  
  217. ; Pure copies of RMS blocks to be copied to impure data when needed
  218.  
  219. PURFAB:    FAB$B                ; Beginning of FAB block.
  220.     F$DNA    DEFALT            ; Address of default device.
  221.     F$DNS    DEFALN            ; Default length field.
  222.     F$NAM    NAMBLK            ; Chain to the NAM block
  223.     F$LCH    1            ; Use the logical channel 1.
  224.     FAB$E                ; End of FAB block.
  225. FABLEN=.-PURFAB
  226.     .EVEN
  227.  
  228. PURNAM:    NAM$B                ; Beginning of NAM block.
  229.     N$ESA    STRBUF            ; Address of the expanded string
  230.     N$ESS    128.            ;   buffer and its length.
  231.     N$RSA    RESSTR            ; Address of the resultant string
  232.     N$RSS    50.            ;   buffer and its length.
  233.     NAM$E                ; End of NAM block.
  234. NAMLEN=.-PURNAM
  235.     .EVEN
  236.  
  237. PURRAB:    RAB$B                ; Beginning of RAB block.
  238.     R$FAB    FILFAB            ; Chain to FAB block.
  239.     R$MBC    2            ; Size of the multiblock count.
  240.     R$RAC    RB$SEQ            ; Set the sequential access flag.
  241.     RAB$E                ; End RAB block.
  242. RABLEN=.-PURRAB
  243.  
  244.  
  245.     .PSECT    $OWN$, RW, D
  246. FILFAB::
  247.     FAB$B                ; Beginning of FAB block.
  248.     F$DNA    DEFALT            ; Address of default device.
  249.     F$DNS    DEFALN            ; Default length field.
  250.     F$NAM    NAMBLK            ; Chain to the NAM block
  251.     F$LCH    1            ; Use the logical channel 1.
  252.     FAB$E                ; End of FAB block.
  253.     .EVEN
  254.  
  255. NAMBLK::
  256.     NAM$B                ; Beginning of NAM block.
  257.     N$ESA    STRBUF            ; Address of the expanded string
  258.     N$ESS    128.            ;   buffer and its length.
  259.     N$RSA    RESSTR            ; Address of the resultant string
  260.     N$RSS    50.            ;   buffer and its length.
  261.     NAM$E                ; End of NAM block.
  262.     .EVEN
  263.  
  264. RABBLK::
  265.     RAB$B                ; Beginning of RAB block.
  266.     R$FAB    FILFAB            ; Chain to FAB block.
  267.     R$MBC    2            ; Size of the multiblock count.
  268.     R$RAC    RB$SEQ            ; Set the sequential access flag.
  269.     RAB$E                ; End RAB block.
  270.  
  271.  
  272.     .SBTTL    Send Routine
  273.  
  274. ;
  275. ; The send routine takes a file from your directory and sends
  276. ;   a copy of it to the host computer.
  277. ;
  278. ;        SUBROUTINES:
  279. ;            Open:    Routine to open up a file.
  280. ;
  281. ;    Send also updates the status board, by moving in information
  282. ;       relative to the transfer.
  283. ;
  284.  
  285.     .PSECT    $CODE$,  RO 
  286.  
  287. X$SEND::CLR    LSTFG            ; Initialize the pointer
  288.     CLR    SIZPOI            ; Reset size pointer.
  289.     CLR    FILPOI            ; Reset filename pointer.
  290.     JSR    PC,SETNUL        ; Call setnul subroutine.
  291.     JSR    PC,STARTRANS        ; Set initial parameters. . .
  292.  
  293. ;
  294. ; Put first file name into file.name.
  295. ;
  296. 4$:    JSR    PC,INFLNM        ; Copy the first file name
  297. ;
  298. ; Enter KERMSG.
  299. ;
  300.     JSR    PC,SEND.SWITCH        ; Go into Kermsg.
  301.     PJMP    DONETRANS        ; Finished with transaction and return
  302.  
  303.     .SBTTL    Receive
  304.  
  305. ;
  306. ; This routine receives a file from the host kermit.
  307. ;
  308. ;
  309.  
  310.     .PSECT    $CODE$,  RO 
  311.  
  312. X$RECV::JSR    PC,SWAPNM        ; Put input file into File.name.
  313.     JSR    PC,STARTRANS        ; Set initial parameters. . .
  314.     BLSCAL    REC.SWITCH        ; Call the message processing
  315.     JSR    PC,DONETRANS        ; Jump to trannsfer complete routine.
  316.     RTS    PC
  317.  
  318.     .sbttl    File Open Routine:  Send
  319.  
  320.  
  321. ; This routine Opens up a file for sending.
  322. ;    The register R1 is used as a general purpose register for the 
  323. ;    system calls.  A status check is made after opening to confirm a 
  324. ;    successful file opening.
  325. ; 
  326. ;    INPUT:    The file name and the length of the filename.
  327. ;
  328. ;    OUTPUT:    The buffer containing the record.
  329. ;
  330. ;    REGISTERS:
  331. ;        R0 =>    Takes back a true or false value to Kermsg
  332. ;        R1 =>    Pointer to the currently used control block.
  333. ;        R2 =>    Register to carry value to clear buffer routine.
  334. ;
  335.  
  336.     .PSECT    $CODE$,  RO 
  337.  
  338. BLSRTN    FILE.OPEN,2,SNRCFG        ; Open a file routine.
  339. ;[03]
  340. ;[03] Initialize the RAV/FAB/NAM blocks for RMS from the prototypes
  341. ;[03]
  342.     BLSCAL    BL$MOV,<#FABLEN,#PURFAB,#FILFAB>,+ ;[03] Initialize the FAB
  343.     BLSCAL    BL$MOV,<#NAMLEN,#PURNAM,#NAMBLK>,+ ;[03] And the name block
  344.     BLSCAL    BL$MOV,<#RABLEN,#PURRAB,#RABBLK>,- ;[03] And the RAB
  345.  
  346.     CLR    BYTCNT            ; Clear the count of bytes read/writen
  347.     TST    SNRCFG(SP)        ; Are we sending?
  348.     BNE    RCVOPN            ; No, open for receiving
  349. ;
  350. ; Go to next.file routine and put parsed file name into file.name.
  351. ;
  352.     JSR    PC,PARSE        ; Parse the file specification
  353.     CMP    #KNORMAL,R0        ; Get a good return?
  354.     BNE    99$            ; Branch if not and return
  355. ;
  356. ; Now attempt to search for the first of the files
  357. ;
  358.     MOV    #FILFAB,R0        ; Get the FAB address
  359.     $SET    #FB$FID,FOP,R0        ; Set the wildcard flag
  360.     $SEARCH    #FILFAB            ; Search for this file
  361.     JSR    PC,SENCHK        ; Check for errors
  362.     CMP    #KNORMAL,R0        ; Get a good return?
  363.     BNE    99$            ; Branch if an error and return
  364.     CMP    #NOMORFILES,R0        ; No more files?
  365.     BNE    OP1            ; No, skip this
  366.     MOV    #ER$FNF,R0        ; Get the error code back
  367.     JSR    PC,RMSERR        ; Issue an RMS error
  368.     MOV    #RMS11,R0        ;[01] No, some type of error
  369. 99$:    RTS    PC            ; Return to caller, with error.
  370. ;
  371. ; Here if we can really open the file for processing
  372. ;
  373. OP1:    MOV    #$REPR1,FILSTA        ;[09] Start out in first prefix state
  374.     MOV    #FILFAB,R1        ; Put address of FAB into R1.
  375.     CMP    FILFLG,#MODBLK        ; Are we in block transfer mode.
  376.     BNE    5$            ; No, skip
  377. ;
  378. ; Set up for block reads
  379. ;
  380.     $SET    #FB$REA,FAC,R1        ; Otherwise set the block read in FAB.
  381. ;
  382. ; Now prepare to open the file.
  383. ;
  384. 5$:    $SET    #FB$FID,FOP,R1        ; Set up for wild card transfer.
  385.     $STORE    FILE.SIZE,FNS,R1    ; Store filename size in the FAB.
  386.     $STORE    #FILE.NAME,FNA,R1    ; Store filename in the FAB.
  387.     $OPEN    #FILFAB            ; Open up file specified in the FAB.
  388.     JSR    PC,SENCHK        ; Jump to status check routine.
  389.     CMP    #KNORMAL,R0        ; Did we get a good returned value ?
  390.     BEQ    6$            ; Yes, branch to continue.
  391.     RTS    PC            ; Return with error.
  392. ;
  393. ; If here we wish to have the file name cut up as determined by the
  394. ;  fil.narmal.form field.
  395. ;
  396. 6$:    JSR    PC,FIXNAM        ; Fix name to desired fashion.
  397.     CMP    #KNORMAL,R0        ; Did we get a good returned value ?
  398.     BEQ    7$            ; Yes, branch to continue.
  399.     RTS    PC            ; Return to caller with error.
  400. ;
  401. ; If here then we didn't get any screwy error in fixnam.
  402. ;
  403. 7$:    CMP    FILFLG,#MODBLK        ; Are we in block mode ?
  404.     BEQ    30$            ; Yes, branch.
  405.     CMP    FILFLG,#MODFIX        ; Are we in fixed mode ?
  406.     BEQ    30$            ; Yes, branch.
  407. ;
  408. ; Here if we have an ASCII or BINARY file.  Determine which of the file 
  409. ;  processing routines are to be used.  Store the converted RAT into FORMAT
  410. ;
  411.     MOV    #$TYNONE,FORMAT        ; Assume NO ATTRIBUTE file
  412.     MOV    #FILFAB,R1        ; Store address of FAB in R1.
  413.     $FETCH    R0,RAT,R1        ; Get the record attributes
  414.     BIC    R0,#FB$BLK        ; Clear the block bit
  415. ;
  416. ; Assume we have a NO ATTRIBUTE file, and check to see if right
  417. ;
  418.     CMP    R0,#FB$PRN        ; Print file?
  419.     BNE    10$            ; No, skip this
  420.     MOV    #$TYPRN,FORMAT        ; Yes, set the print file format
  421.     BR    30$            ; And skip other code
  422. ;
  423. ; Wasn't a PRINT file, so check FORTRAN
  424. ;
  425. 10$:    CMP    R0,#FB$FTN        ; Fortran file?
  426.     BNE    20$            ; No, skip this
  427.     MOV    #$TYFTN,FORMAT        ; Yes, store the new format
  428.     BR    30$            ; Branch.
  429. ;
  430. ; Wasn't a fortran file, so check CRLF
  431. ;
  432. 20$:    CMP    R0,#FB$CR        ; Carriage return line feed file ?
  433.     BNE    30$            ; No, branch.
  434.     MOV    #$TYCR,FORMAT        ; Yes, set offset into FORMAT.
  435. ;
  436. ; We now have the format type, display the file name, and connect to the
  437. ;  file.
  438. ;
  439. 30$:    PJMP    CONOPN            ; Connect to the file and return
  440.  
  441.     .SBTTL File Open Routine:  Receive
  442.  
  443. ;
  444. ; Receive open creates the file that the remote Kermit is sending.
  445. ; If it can not create the file or connect to it it returns a false 
  446. ;    value to Kermsg.  Before creating the file though it makes sure 
  447. ;    that the file name and type is compatible with the P/OS system
  448. ;    by fixing the name to nine characters at most, and the type being
  449. ;    three characters long.
  450.  
  451.     .PSECT    $CODE$,  RO 
  452.  
  453. RCVOPN:    MOV    #FILFAB,R1        ; Put address of Filfab into R1.
  454.     $STORE    #FILE.NAME,FNA,R1    ; Store the file name in the Fab.
  455.     $STORE    FILE.SIZE,FNS,R1    ; Store the name length in the Fab.
  456.  
  457.     $STORE    #FB$VAR,RFM,R1        ; Variable length records
  458.  
  459. ;
  460. ; Check to see if we are receiving an ascii file
  461. ;
  462.     CMP    FILFLG,#MODASC        ; Are we receiving an ascii file.
  463.     BNE    21$            ; No, then skip.
  464.     $SET    #FB$CR,RAT,R1        ; Set the record handling mask.
  465. ;
  466. ; Check to see if we are receiving a block file
  467. ;
  468.  
  469. 21$:    CMP    FILFLG,#MODBLK        ; Are we recieving a block file.
  470.     BNE    22$            ; No, skip.
  471.     $SET    #FB$WRT,FAC,R1        ; Otherwise set the block write in FAB.
  472.     $STORE    #FB$VAR,RFM,R1        ; Fixed size records
  473.     $STORE    #8192.,MRS,R1        ; 8192 bytes per record
  474. ;
  475. ; See if we are doing a fixed length file.
  476. ;
  477.  
  478. 22$:    CMP    FILFLG,#MODFIX        ; Are we receiving in fixed mode ?
  479.     BNE    25$            ; No, branch.
  480.     $STORE    #FB$FIX,RFM,R1        ; Set for fixed length records.
  481.     $STORE    #512.,MRS,R1        ; 512 bytes per record
  482. ;
  483. ; Create the file by the specifications given in the FAB
  484. ;
  485.  
  486. 25$:    $CREATE    #FILFAB            ; Create the new file.
  487.     JSR    PC,SENCHK        ; Check the status return.
  488.     CMP    #KNORMAL,R0        ; Did we get a true return ?
  489.     BEQ    30$            ; Yes, branch to connect to the file.
  490.     RTS    PC            ; Return with error.
  491. ;
  492. ; If here then we must connect to the file
  493. ;
  494. 30$:    PJMP    CONOPN            ; Connect to the file and return
  495.  
  496.     .SBTTL File Open Routine:  Connect
  497.  
  498. ;
  499. ; Conect connects to the open file, it does not care whether it was
  500. ;    opened by send open or receive open.  Conect will return a false
  501. ;    value if it was unable to open the file.
  502.  
  503.     .PSECT    $CODE$,  RO 
  504.  
  505. CONOPN:    MOV    #RABBLK,R1        ; Put address of RAB into R1.
  506.     $STORE    #DSKBUF,UBF,R1        ; Put address of user buffer in RAB.
  507.     $STORE    #1400.,USZ,R1        ; Put size of user buffer into RAB.
  508.     $SET    #RB$SEQ,RAC,R1        ; Load RAC field of RAB.
  509.     $CONNECT #RABBLK        ; Connect to record.
  510.     PJMP    SENCHK            ; Check status and return
  511.  
  512.     .SBTTL    Next file routine
  513.  
  514. ;
  515. ; This routine sets you up for the next file to be sent.
  516. ;
  517. ;    INPUT:    The block containing the file names, or a
  518. ;           string to search for.
  519. ;
  520. ;    OUTPUT:    The next file to transfer or a return 
  521. ;           indicating no more files.
  522. ;
  523. ;    REGISTERS: { The old values in the registers are saved }
  524. ;        R0 =>    Takes back a true or false value to Kermsg
  525. ;        R1 =>    Holds the address of the Rab.
  526. ;
  527.  
  528.     .PSECT    $CODE$,  RO 
  529.  
  530. BLSRTN    NEXT.FILE,2,
  531.     MOV    #KNORMAL,R0        ; Assume this will work
  532.  
  533. ; Search for parsed string
  534.  
  535. 10$:    MOV    #FILFAB,R1        ; Put address of FAB into R1.
  536.     $SET    #FB$FID,FOP,R1        ; Set wildcard flag in FAB.
  537.     $SEARCH    #FILFAB            ; Search for the file specified.
  538.     JSR    PC,SENCHK        ; Check for an error in the parsing.
  539.     CMP    #KNORMAL,R0        ; Did we get a true return ?
  540.     BEQ    20$            ; Yes, then branch.
  541.     CMP    #NOMORFILES,R0        ; No more files for this wild card?
  542.     BNE    99$            ; Return if another type of error
  543. ;
  544. ; See if there is another file on the list of files to process.
  545. ;
  546.     CMP    LSTFG,NOCHOS        ; See if it matches the number 
  547.     BNE    15$            ;   chosen, if so then branch.
  548.     MOV    #NOMORFILES,R0        ; Put error message into R0.
  549.     RTS    PC            ; Return to calling routine.
  550. ;
  551. ; Move the file specification to FILE.NAME and set up to process it
  552. ;
  553.  
  554. 15$:    JSR    PC,INFLNM        ; Go to increment file, & size routine.
  555. ;
  556. ; When we get here we may have an unparsed string.  If we do then
  557. ;  parse it.  Then search for the file until we have no more then 
  558. ;  return the error NOMORFILES to kermsg.
  559. ;
  560.  
  561.     JSR    PC,PARSE        ; Parse for the search.
  562.     CMP    #KNORMAL,R0        ; Did we get a successful return.
  563.     BNE    99$            ; No, return to caller with error.
  564.     BR    10$            ; Loop for all files
  565. ;
  566. ; If here then we still have files.
  567. ;
  568. 20$:    MOV    #NAMBLK,R1        ; Put address of block into R1
  569.     $FETCH    FILE.SIZE,RSL,R1    ; Get the length of the name.
  570. ;
  571. ; Open the file for reading now and then return to the caller
  572. ;
  573.     JSR    PC,OP1            ; Open the file.
  574. 99$:    RTS    PC            ; Return to caller.
  575.  
  576.     .SBTTL Get File Routine
  577.  
  578. ;
  579. ; This routine gets a record out of the open file, and then gets 
  580. ;   characters out of the record.
  581. ;
  582. ;    INPUT:    The currently open file,
  583. ;        flag indicating an empty record,
  584. ;        and where to put the character.
  585. ;
  586. ;    OUTPUT:    A character stored in the location 
  587. ;        specified by Kermsg.
  588. ;
  589. ;    REGISTERS:    { The old values are saved }
  590. ;        R0 =>    Takes back a true or false value to Kermsg
  591. ;        R1 =>    Holds the address of the Rab
  592. ;
  593.  
  594.     .PSECT    $CODE$,  RO 
  595.  
  596. BLSRTN    GET.FILE,3,<CHRADR>
  597.  
  598.     CMP    FILFLG,#MODBLK        ; Are we transfering a block file ?
  599.     BEQ    5$            ; Yes we are, branch.
  600.     CMP    FILFLG,#MODFIX        ; Are we transfering in fixed mode ?
  601.     BNE    20$            ; No, branch
  602.  
  603. ; If we get here then we are transfering in block or fixed mode.
  604.  
  605. 5$:    TST    BYTCNT            ; Do we need to get a buffer ?
  606.     BNE    10$            ; No we do not, branch.
  607.     JSR    PC,GETBUF        ; Jump to the get-buffer routine.
  608.     CMP    #KNORMAL,R0        ; Did we successfully get the buffer ?
  609.     BNE    99$            ; No, return with the error
  610.  
  611. ; We successfully got a buffer of data.
  612.  
  613. 10$:    JSR    PC,GETCHR        ; Get a character from the buffer.
  614.     MOVB    R1,@CHRADR(SP)        ; Put that char. into the address 
  615.     MOV    #KNORMAL,R0        ;  specified, set up for a normal
  616.     RTS    PC            ;   return, and return to caller.
  617. ;
  618. ; If we get here then we are transfering in either ascii or binary mode.
  619. ;
  620. 20$:    MOV    FORMAT,R0        ; Put offset into R0.
  621.     JSR    PC,@RATDSP(R0)        ; Jump to the specified routine.
  622.     CMP    #KNORMAL,R0        ; Did we get a successfull return ?
  623.     BNE    99$            ; No, branch.
  624.     MOVB    R1,@CHRADR(SP)        ; Put that char. into the address 
  625. 99$:    RTS    PC            ;   return, and return to caller.
  626.  
  627. ;
  628. ; Record attributes dispatch table.
  629. ;
  630.  
  631.     .PSECT    $PLIT$,    RO,  D
  632.  
  633. RATDSP:    .WORD    CRLF            ; Dispatch to the input
  634.     .WORD    FORTRAN            ; Dispatch to the FORTRAN input
  635.     .WORD    PRINT            ; Dispatch to the print file input
  636.     .WORD    NONE            ; Dispatch to no attribute routine.
  637.  
  638.     .sbttl Suport routines - GET.FILE - GETBUF - Get a buffer
  639. ;++
  640. ; This routine will read the next buffer from the input file.  It will
  641. ; return with the status in R0 to determine if it failed or succeeded.
  642. ;
  643. ; Usage:
  644. ;    JSR    PC,GETBUF
  645. ;    (Return)
  646. ;
  647. ; On return:
  648. ;    R0/ Kermit error code
  649. ;
  650. ;--
  651.  
  652.  
  653.     .PSECT    $CODE$,  RO 
  654.  
  655. GETBUF:    MOV    #RABBLK,R1        ; Put address of RAB into R1.
  656.     CMP    FILFLG,#MODBLK        ; Are we transfering in block ?
  657.     BEQ    10$            ; Yes we are, branch.
  658.  
  659. ; If we are here then we want to do a $get.
  660.  
  661.     $GET    #RABBLK            ; Get the buffer of data.
  662.     BR    20$            ; Branch to common code.
  663.  
  664. ; If we are here then we want to do a $read.
  665.  
  666. 10$:    $STORE    #512.,USZ,R1        ; Put size of user buffer into RAB.
  667.     $READ    #RABBLK            ; Read in the buffer of data.
  668.  
  669. ; The following code is used for both types of files.
  670.  
  671. 20$:    JSR    PC,SENCHK        ; Check for RMS-11 error.
  672.     $FETCH    BYTCNT,RSZ,R1        ; Get the byte-count from the RSZ field
  673.     CLR    BYTOFS            ; Reset the byte-offset
  674.     RTS    PC            ; Return to caller.
  675.  
  676.     .sbttl    Support routine - GET.FILE - Getchr
  677. ;++
  678. ; Getchr will return a value in R1. If there are no more words in
  679. ;  the buffer it will return a -1, if there are still bytes to be
  680. ;  transfered then it will put the next byte into R1.  The bytcnt
  681. ;  is a counter that is zero when all the bytes of the current record 
  682. ;  have been transfered.  The bytofs points to the byte to be
  683. ;  transfered and is incramented before returning to the caller.
  684. ;--
  685.  
  686.     .PSECT    $CODE$,  RO 
  687.  
  688. GETCHR:    TST    BYTCNT            ; Is the byte-count zero ?
  689.     BNE    10$            ; No, we still have characters, branch.
  690.     MOV    #-1,R1            ; Put a -1 into R1.
  691.     RTS    PC            ; Return to caller.
  692. ;
  693. ; If here then we still have characters to get.
  694. ;
  695. 10$:    MOV    BYTOFS,R0        ; Put byte-pointer into R0.
  696.     CLR    R1            ; Clear the register
  697.     BISB    DSKBUF(R0),R1        ; Mov the character into R1.
  698.     DEC    BYTCNT            ; Decrament the byte-count.
  699.     INC    BYTOFS            ; Move forward the byte-pointer.
  700.     RTS    PC            ; Return to caller.
  701.  
  702.  
  703.  
  704.  
  705.  
  706.  
  707. ;++
  708. ; This routine is called whenever one of the routines called by get.file
  709. ;  return an error that is not RMS related.
  710. ;  It returns to the message processor an internal error code that will
  711. ;  shut down the file transfer.
  712. ;--
  713.  
  714. INTERR:    MOV    #INTERNALERR,R0        ; Put code for an internal error into
  715.     RTS    PC            ;   R0, and return to caller.
  716.  
  717.     .SBTTL    Support routine - GET.FILE - CRLF file
  718.  
  719. ;++
  720. ; This routine is called to read a character from a normal file.
  721. ; This will return the character to be sent in R1 and the status of
  722. ; the fetch in R0.
  723. ;
  724. ; Usage:
  725. ;    JSR    PC,CRLF
  726. ;    (Return)
  727. ;
  728. ; On return:
  729. ;    R0/ Status (Kermit error status)
  730. ;    R1/ Character
  731. ;
  732. ;--
  733.  
  734.     .PSECT    $CODE$,    RO
  735.  
  736. CRLF:    MOV    FILSTA,R0        ; Get the file reader state
  737.     JMP    @CRDSP(R0)        ; Dispatch to the correct routine
  738.  
  739. ;++
  740. ; Pre processing state one
  741. ;--
  742. CRPR1:    JSR    PC,GETBUF        ; Get a record.
  743.     CMP    #KNORMAL,R0        ; Get it ok?
  744.     BEQ    10$            ; Yes, branch.
  745.     RTS    PC            ; Return to caller.
  746. ;
  747. ; Now just change state to record reading.
  748. ;
  749. 10$:    MOV    #$RERD,FILSTA        ; Change file state to read.
  750.     BR    CRLF            ; Branch back.
  751.  
  752. ;++
  753. ; Pre processing state two -- Internal error
  754. ;--
  755. CRPR2=    INTERR                ; Internal error
  756.  
  757. ;++
  758. ; Record processing state - Return the record character to the caller
  759. ;--
  760. CRREC:    JSR    PC,GETCHR        ; Get a character
  761.     TST    R1            ; Fail?
  762.     BGE    310$            ; No, got a character - branch
  763.     MOV    #$REPS1,FILSTA        ; Change to post processing state->1.
  764.     BR    CRLF            ; Try again from the top
  765.  
  766. 310$:    MOV    #KNORMAL,R0        ; Return a good error code
  767.     RTS    PC            ; Return to the caller
  768.  
  769.  
  770. ;++
  771. ; First post processing state - Just append the CR to the information sent
  772. ;--
  773. CRPS1:    MOVB    #.CHCR,R1        ; Store the carriage return
  774.     MOV    #$REPS2,FILSTA        ; Change to the preprocessing routine
  775.     MOV    #KNORMAL,R0        ; Return normal
  776.     RTS    PC            ; And return
  777.  
  778. ;++
  779. ; Post processing state 2 return a line-feed.
  780. ;--
  781. CRPS2:    MOVB    #.CHLF,R1        ; Store a line feed in R1.
  782.     MOV    #$REPR1,FILSTA        ; Change state to pre pros 1.
  783.     MOV    #KNORMAL,R0        ; Set up normal return.
  784.     RTS    PC            ; Return to caller.
  785. ;++
  786. ; The following is the dispatch table for the various states that we can be
  787. ; in reading the records.
  788. ;--
  789.  
  790.     .PSECT    $PLIT$,    RO, D
  791. CRDSP:    .WORD    CRPR1            ; Preprocessing state one
  792.     .WORD    CRPR2            ; Preprocessing state two
  793.     .WORD    CRREC            ; Record processing
  794.     .WORD    CRPS1            ; Postprocessing state one
  795.     .WORD    CRPS2            ; Postprocessing satte two
  796.  
  797.     .SBTTL    Support routine - GET.FILE - PRINT file
  798.  
  799. ;++
  800. ; This routine will read character for a file with the PRN record attributes.
  801. ; It will return the characters to the caller in R1 and the status in R0.
  802. ;
  803. ; Usage:
  804. ;    JSR    PC,PRINT
  805. ;    (Return)
  806. ;
  807. ; On return:
  808. ;    R0/ Kermit status
  809. ;    R1/ Character
  810. ;
  811. ;--
  812.  
  813.     .PSECT    $CODE$,    RO
  814.  
  815. PRINT:    MOV    FILSTA,R0        ; Get the file state
  816.     JMP    @PRNDSP(R0)        ; Dispatch to the correct routine
  817.  
  818. ;++
  819. ; Preprocessing state one.  This will read the print file carriage control
  820. ; information and change to state two to return the characters
  821. ;--
  822. PRNPR1:    JSR    PC,GETBUF        ; Get the next record
  823.     CMP    #KNORMAL,R0        ; Did we get it ok?
  824.     BEQ    110$            ; Branch if we did
  825.     RTS    PC            ; No, just pass back the error
  826. ;
  827. ;  If here then we got no rms error.
  828. ;
  829. 110$:    JSR    PC,GETCHR        ; Get the first character of the record
  830.     TST    R1            ; Did we get anything?
  831.     BLT    PRINT            ; Try again if not
  832.     MOV    R1,R2            ; Move to a safer place
  833.     JSR    PC,GETCHR        ; Get the second byte
  834.     TST    R1            ; Is this one really here?
  835.     BLT    PRINT            ; No, try again, broken file
  836.     MOV    R1,PSTPRN        ; Store for later
  837.     BIC    #B7,R2            ; Is this clear
  838.     BEQ    120$            ; No, must be a character to output
  839.     MOV    R2,PRNCNT        ; Store as the count
  840.     MOV    #$REPR2,FILSTA        ; Set the new state
  841.     BR    PRINT            ; Try again
  842.  
  843. ;
  844. ; Here if we have a character that must be output.
  845. ; First try for a control character to be output
  846. ;
  847. 120$:    MOV    #$RERD,FILSTA        ; Change state
  848.     BIC    #B6,R2            ; Is bit six on?
  849.     BNE    130$            ; Branch if it was off
  850.     BIC    #B5,R2            ; Was bit 5 on?
  851.     BEQ    PRINT            ; Yes, reserved code try again
  852.     ADD    #128.,R2        ; Offset to the correct place
  853. 130$:    MOV    R2,R1            ; Copy to the right place
  854.     MOV    #KNORMAL,R0        ; Give a good return
  855.     RTS    PC            ; Return to the caller
  856.  
  857. ;++
  858. ; Preprocessing state two.  This will return the lead in characters for the
  859. ; record.  After this state is finished it will change to the record processing
  860. ; state.
  861. ;--
  862. PRNPR2:    TST    PRNCNT            ; Finished with the LFs?
  863.     BEQ    210$            ; Branch if so
  864.     MOVB    #.CHLF,R1        ; Return a LF
  865.     MOV    #KNORMAL,R0        ; And a good return
  866.     RTS    PC            ; Return to the caller
  867. ;
  868. ; Here if finished with the LFs.  Just return a CR now and change the state
  869. ; reading the record
  870. ;
  871. 210$:    MOV    #$RERD,FILSTA        ; Now reading the record
  872.     MOVB    #.CHCR,R1        ; Return the CR
  873.     MOV    #KNORMAL,R0        ; Return the code
  874.     RTS    PC            ; Return to the caller
  875.  
  876. ;++
  877. ; Record processing state - This will return characters to the calling routine.
  878. ; from the record.  When the characters are finished it will change to first
  879. ; post processing state.
  880. ;--
  881. PRNREC:    JSR    PC,GETCHR        ; Get a byte from the record
  882.     TST    R1            ; End of record?
  883.     BGE    310$            ; Branch if not
  884.     MOV    #$REPS1,FILSTA        ; Yes, set the post processing state
  885.     BR    PRINT            ; And try from the top
  886. ;
  887. ; If here then we want to return the character.
  888. ;
  889. 310$:    MOV    #KNORMAL,R0        ; Give a normal return
  890.     RTS    PC            ; And return to the caller
  891.  
  892.  
  893. ;++
  894. ; Postprocessing state one.  This will determine what type of carriage control
  895. ; must be placed on the end of the record.  After it has determined the
  896. ; type it will dispatch to either the preprocessing or the other postprocessing
  897. ; routine.
  898. ;--
  899. PRNPS1:    MOV    PSTPRN,R2        ; Get the postfix character
  900.     BIC    #B7,R2            ; Is this clear
  901.     BEQ    410$            ; No, must be a character to output
  902.     MOV    R2,PRNCNT        ; Store as the count
  903.     MOV    #$REPR2,FILSTA        ; Set the new state
  904.     BR    PRINT            ; Try again
  905. ;
  906. ; Here if we have a character that must be output.
  907. ; First try for a control character to be output
  908. ;
  909. 410$:    MOV    #$RERD,FILSTA        ; Change state
  910.     BIC    #B6,R2            ; Is bit six on?
  911.     BNE    420$            ; Branch if it was off
  912.     BIC    #B5,R2            ; Was bit 5 on?
  913.     BEQ    PRINT            ; Yes, reserved code try again
  914.     ADD    #128.,R2        ; Offset to the correct place
  915. 420$:    MOV    R2,R1            ; Copy to the right place
  916.     MOV    #KNORMAL,R0        ; Give a good return
  917.     RTS    PC            ; Return to the caller
  918.  
  919. ;++
  920. ; Postprocessing state two.  This routine will return the characters that are
  921. ; to be output after the record.  It will change to the first preprocessing 
  922. ; routine after it has finished the returning of the characters.
  923. ;--
  924. PRNPS2:    TST    PRNCNT            ; Finished with the LFs?
  925.     BEQ    510$            ; Branch if so
  926.     MOVB    #.CHLF,R1        ; Return a LF
  927.     MOV    #KNORMAL,R0        ; And a good return
  928.     RTS    PC            ; Return to the caller
  929. ;
  930. ; Here if finished with the LFs.  Just return a CR now and change the state
  931. ; reading the record
  932. ;
  933. 510$:    MOV    #$REPR1,FILSTA        ; Now reading the record
  934.     MOVB    #.CHCR,R1        ; Return the CR
  935.     MOV    #KNORMAL,R0        ; Return the code
  936.     RTS    PC            ; Return to the caller
  937.  
  938. ;++
  939. ; Print file dispatch table.
  940. ;--
  941.  
  942.     .PSECT    $PLIT$,    RO, D
  943.  
  944. PRNDSP:    .WORD    PRNPR1            ; First preprocessing routine
  945.     .WORD    PRNPR2            ; Second preprocessing routine
  946.     .WORD    PRNREC            ; Record processing routine
  947.     .WORD    PRNPS1            ; First postprocessing routine
  948.     .WORD    PRNPS2            ; Second postprocessing rouine
  949.  
  950.     .sbttl    Support routine - GET.FILE - FORTRAN file
  951.  
  952. ;++
  953. ; This routine is called to read a character from a FORTRAN file.  The 
  954. ; file contains the leading character followed by the record.  The leading
  955. ; character must be converted to a normal ASCII character for processing.
  956. ;
  957. ; Usage:
  958. ;    JSR    PC,FORTRAN
  959. ;    (Return)
  960. ;
  961. ; On return:
  962. ;    R0/ Status
  963. ;    R1/ Character if any
  964. ;--
  965.  
  966.     .PSECT    $CODE$,  RO 
  967.  
  968. FORTRAN:MOV    FILSTA,R0        ; Get the current state
  969.     JMP    @FTNDSP(R0)        ; Dispatch to the correct routine
  970.  
  971. ;++
  972. ; Pre processing routine 1.
  973. ;--
  974. FTNPR1:    MOV    #TRUE,CRFLG        ; Set the flag
  975.     JSR    PC,GETBUF        ; Get the next record
  976.     CMP    #KNORMAL,R0        ; Did we get it ok?
  977.     BEQ    110$            ; Branch if we did
  978.     RTS    PC            ; No, just pass back the error
  979. ;
  980. ;  If here then we got no rms error.
  981. ;
  982. 110$:    JSR    PC,GETCHR        ; Get the first character of the record
  983.     TST    R1            ; Is this the end of line already?
  984.     BGE    120$            ; No, Check the first character
  985.     BR    FORTRAN            ; Try again from the top
  986. ;
  987. ;  If we get here then we want to check the first byte.
  988. ;
  989. ;
  990. ; Check for "null" format type.
  991. ;
  992. 120$:    TST    R1            ; Is this a null byte?
  993.     BNE    130$            ; No, check for other characters
  994.     CLR    CRFLG            ; Yes, clear output a CR flag.
  995. 125$:    MOV    #$RERD,FILSTA        ; Set new state to read the record
  996.     BR    FORTRAN            ; And try again from the top
  997. ;
  998. ; Check for "0" format type.
  999. ;
  1000. 130$:    CMPB    DSKBUF,#'0        ; Is this a "0"?
  1001.     BNE    140$            ; Branch if not
  1002.     MOV    #$REPR2,FILSTA        ; Set to preprocessing state-> 2.
  1003.     BR    170$            ; Join common code to return LF
  1004.  
  1005. ;
  1006. ; Check for  "1" format type.
  1007. ;
  1008. 140$:    CMPB    DSKBUF,#'1        ; Is this a "1"?
  1009.     BNE    150$            ; Branch if not
  1010.     MOVB    #.CHFF,R1        ; It is, so return FF <record> CR
  1011.     MOV    #$RERD,FILSTA        ; Set state to read the record next
  1012.     RTS    PC            ; Return to the caller
  1013. ;
  1014. ; Check for "+" format type.
  1015. ;
  1016. 150$:    CMPB    DSKBUF,#'+        ; Is this a "+"?
  1017.     BNE    160$            ; Branch if not
  1018.     BR    125$            ; Join the common code
  1019. ;
  1020. ; Check for "$" format type.
  1021. ;
  1022. 160$:    CMPB    DSKBUF,#'$        ; Is this a "$"?
  1023.     BNE    170$            ; Branch if not
  1024.     CLR    CRFLG            ; Clear flag noting CR needed
  1025. ;
  1026. ; All other characters default to this.
  1027. ;
  1028. 170$:    MOVB    #.CHLF,R1        ; Return a LF
  1029.     MOV    #$RERD,FILSTA        ; Set the new state
  1030.     RTS    PC            ; Return to the caller
  1031.  
  1032. ;++
  1033. ; Pre-processing routine 2.
  1034. ;__
  1035. FTNPR2=    170$                ; Same, just return LF and change
  1036.                     ; states
  1037.  
  1038. ;++
  1039. ; Record reading routine.
  1040. ;--
  1041. FTNREC:    JSR    PC,GETCHR        ; Get a byte from the record
  1042.     TST    R1            ; End of record?
  1043.     BGE    310$            ; Branch if not
  1044.     MOV    #$REPS1,FILSTA        ; Yes, set the post processing state
  1045.     BR    FORTRAN            ; And try from the top
  1046. ;
  1047. ; If here then we want to return the character.
  1048. ;
  1049. 310$:    MOV    #KNORMAL,R0        ; Give a normal return
  1050.     RTS    PC            ; And return to the caller
  1051.  
  1052.  
  1053. ;++
  1054. ; Post processing routine 1.
  1055. ;--
  1056. FTNPS1:    MOV    #$REPR1,FILSTA        ; Set the to preprocessing routine
  1057.     TST    CRFLG            ; Need to output the CR?
  1058.     BEQ    FORTRAN            ; Branch if not
  1059.     MOVB    #.CHCR,R1        ; Return the CR
  1060.     MOV    #KNORMAL,R0        ; Give a normal return
  1061.     RTS    PC            ; Return to the caller
  1062.  
  1063. ;++
  1064. ; Post processing routine 2.  INTERNAL ERROR if we get here
  1065. ;--
  1066. FTNPS2=    INTERR
  1067.  
  1068.  
  1069. ;++
  1070. ; The following is the FORTRAN dispatch table.  This table is used to
  1071. ; dispatch to the correct routine depending on the state of the character
  1072. ; reader.
  1073. ;--
  1074.  
  1075.     .PSECT    $PLIT$,    RO,  D
  1076.  
  1077. FTNDSP:    .WORD    FTNPR1            ; Pre processing state 1
  1078.     .WORD    FTNPR2            ; Pre processing state 2
  1079.     .WORD    FTNREC            ; Record processing state
  1080.     .WORD    FTNPS1            ; Post processing state 1
  1081.     .WORD    FTNPS2            ; Post processing state 2
  1082.  
  1083.     .SBTTL    Support routine - GET.FILE - No attribute file
  1084. ;++
  1085. ; This file processing mode is used when the file to be sent has no
  1086. ;  record attributes.  It will get a buffer when the bytecount is zero
  1087. ;  and transfer over every byte in the record.
  1088. ;
  1089. ;
  1090. ; Usage:
  1091. ;    JSR    PC,@RATDSP(R0)
  1092. ;        (return) 
  1093. ;        (R0 must have the offset value)
  1094. ;
  1095. ;--
  1096.  
  1097.     .PSECT    $CODE$,  RO 
  1098.  
  1099. NONE:    TST    BYTCNT            ; Is the byte-count zero ?
  1100.     BNE    10$            ; No, go get characters.
  1101.     JSR    PC,GETBUF        ; Yes, go get a buffer.
  1102.     CMP    #KNORMAL,R0        ; Did we get a normal return ?
  1103.     BNE    99$            ; No, return with error.
  1104. ;
  1105. ; If here then we want to get characters.
  1106. ;
  1107. 10$:    JSR    PC,GETCHR        ; Go get a character.
  1108.     MOV    #KNORMAL,R0        ; Set up normal return.
  1109. 99$:    RTS    PC            ; Return to caller.
  1110.  
  1111.     .SBTTL    Bliss interface -- PUT.FILE - Write a character
  1112.  
  1113. ;++
  1114. ; This routine will write a character into the output file.  It will then
  1115. ; return to the calling routine.
  1116. ;
  1117. ; Usage:
  1118. ; BLISS:
  1119. ;    Status = PUT.FILE(.CHARACTER);
  1120. ;
  1121. ;--
  1122.  
  1123.     .PSECT    $CODE$,  RO 
  1124.  
  1125. BLSRTN    PUT.FILE,2,<CHARACTER>
  1126.     MOV    CHARACTER(SP),R1    ; Get the character
  1127. ;
  1128. ; First determine the type of output we are doing.
  1129. ;
  1130.     CMP    FILFLG,#MODBLK        ; Are we doing block mode?
  1131.     BNE    10$            ; No, skip this
  1132.     JSR    PC,PUTCHR        ; Output the character
  1133.     CMP    #512.,BYTCNT        ; Buffer full now?
  1134.     BNE    30$            ; No, just give a good return
  1135.     BR    40$            ; Yes, dump the buffer and get out
  1136. ;
  1137. ; Here if we are not processing a Block file.
  1138. ;
  1139. 10$:    CMP    FILFLG,#MODASC        ; Doing an ASCII file?
  1140.     BNE    35$            ; No, just output the byte
  1141. ;
  1142. ; Here if we are doing an ASCII file, must check for end of record
  1143. ; characters
  1144. ;
  1145.     CMPB    #.CHCRT,R1        ; Is this a carriage return.
  1146.     BNE    15$            ; No, branch.
  1147.     MOV    #TRUE,CRLF.FLG        ; Set on the flag.
  1148.     BR    30$            ; Branch.
  1149. ;
  1150. ; Here if it wasn't a <CR>.
  1151. ;
  1152. 15$:    TST    CRLF.FLG        ; Is the carraige return flag set ?
  1153.     BEQ    20$            ; No, branch.
  1154. ;
  1155. ; Here if a carriage return was the previous character.
  1156. ;
  1157.     CMPB    #.CHLFD,R1        ; Is this a line feed?
  1158.     BEQ    40$            ; Yes, branch.
  1159. ;
  1160. ; Here if we got a carriage return and no line feed.
  1161. ;
  1162.     CMP    #512.,BYTCNT        ;[02] Buffer full now?
  1163.     BEQ    98$            ;[02] Return record too big error
  1164.     MOV    R1,-(SP)        ; Save the current byte.
  1165.     MOVB    #.CHCRT,R1        ; Put a <CR> in R1.
  1166.     JSR    PC,PUTCHR        ; Put it into the buffer.
  1167.     MOV    (SP)+,R1        ; Restore the current byte
  1168.     CLR    CRLF.FLG        ; Reset the flag.
  1169.  
  1170. ;
  1171. ; Here to just store the byte and return to the caller
  1172. ;
  1173. 20$:    CMP    #512.,BYTCNT        ;[02] Buffer full now?
  1174.     BEQ    98$            ;[02] Return record too bit
  1175.     JSR    PC,PUTCHR        ; Output the character
  1176. 30$:    MOV    #KNORMAL,R0        ; Give a normal return
  1177.     RTS    PC            ; Return to the caller
  1178. ;
  1179. ; Here if you are playing with a BINARY or FIXED file.  Put in the character
  1180. ;   if your buffer has 512. bytes in it dump it else return.
  1181. ;
  1182. 35$:    JSR    PC,PUTCHR        ; Output the character.
  1183.     CMP    #512.,BYTCNT        ; Do we have 510 characters ?
  1184.     BEQ    40$            ; Yes, branch to dump the file.
  1185.     MOV    #KNORMAL,R0        ; Give a normal return.
  1186.     RTS    PC            ; Return to caller.
  1187. ;
  1188. ; Here to dump the buffer and return to the caller
  1189. ;
  1190. 40$:    JSR    PC,BUFDMP        ; Output the buffer
  1191.     CLR    CRLF.FLG        ; Reset the flag.
  1192.     RTS    PC            ; Return to the caller
  1193. ;[02]
  1194. ;[02] Here when the record is filled and we must dump the buffer.
  1195. ;[02]
  1196. 98$:    MOV    #REC.TOO.BIG,R0        ;[02] Store the error code
  1197.     RTS    PC            ;[02] Return to the caller
  1198.  
  1199.     .SBTTL    Support -- BUFDMP - Dump the current buffers
  1200.  
  1201. ;++
  1202. ; This routine will dump what is in the current buffers.  It will then return
  1203. ; to the caller.  First checks will be done to determine if there is anything
  1204. ; to dump in the first place.
  1205. ;
  1206. ; Usage:
  1207. ;
  1208. ;    JSR    PC,BUFDMP        ; Output the buffer
  1209. ;    (Return)
  1210. ;
  1211. ; Returns with:
  1212. ;    R0/ Error code if any
  1213. ;--
  1214.  
  1215.     .PSECT    $CODE$,  RO 
  1216.  
  1217. BUFDMP:    MOV    #RABBLK,R1        ; Put address of RAB into R1.
  1218.     $STORE    #DSKBUF,RBF,R1        ; Store address of record buffer.
  1219.     CMP    FILFLG,#MODBLK        ; Block mode?
  1220.     BEQ    10$            ; Yes, output the full block
  1221. ;
  1222. ; Here to write a record for an ASCII file or a block mode file
  1223. ;
  1224.     MOV    BYTCNT,R0        ; Get byte count
  1225.     CMP    FILFLG,#MODFIX        ; Fixed length records?
  1226.     BNE    5$            ; No, go store length
  1227.     MOV    #512.,R0        ; Yes, get length
  1228. 5$:    $STORE    R0,RSZ,R1        ; Put its size into the RAB.
  1229.     $PUT    #RABBLK            ; Output the record
  1230.     BR    20$            ; Finish up
  1231. ;
  1232. ; Here to write a dump mode block to the disk
  1233. ;
  1234. 10$:    $STORE    #512.,RSZ,R1        ; Store the block size
  1235.     $WRITE    #RABBLK            ; Write out the buffer into the file.
  1236. ;
  1237. ; Determine if we got any errors.  If so pass them back to the calling routine
  1238. ; Also inform the remote if it is something bad.
  1239. ;
  1240. 20$:    JSR    PC,SENCHK        ; Check for any errors.
  1241.     CLR    BYTCNT            ; Clear the byte count
  1242.     RTS    PC            ; Return to caller.
  1243.  
  1244.     .SBTTL    Support -- PUTCHR - Put a character into the output buffer
  1245.  
  1246. ;++
  1247. ; This routine will store a byte into the output buffer that is being built.
  1248. ; It will then return to the caller after the byte count and the character
  1249. ; has been stored.
  1250. ;
  1251. ; Usage:
  1252. ;    MOV    #Character,R1
  1253. ;    JSR    PC,PUTCHR
  1254. ;    (Return)
  1255. ;
  1256. ; On return:
  1257. ;    Character stored.
  1258. ;
  1259. ;--
  1260.  
  1261.     .PSECT    $CODE$,  RO 
  1262.  
  1263. PUTCHR:    MOV    BYTCNT,R0        ; Put byte count into R2.
  1264.     MOVB    R1,DSKBUF(R0)        ; Move the character into the byte at 
  1265.     INC    BYTCNT            ;    R2, and increment the byte pointer
  1266.     RTS    PC
  1267.  
  1268.     .SBTTL File closing routine
  1269.  
  1270. ;++
  1271. ; This routine will close the file for KERMSG.  It assumes that the file has
  1272. ; been opened (KERMSG will insure this).  The routine may or may not delete
  1273. ; the file depending on the value of the argument.
  1274. ;
  1275. ; Usage BLISS:
  1276. ;
  1277. ;    Status = FILE_CLOSE (Flag);
  1278. ;
  1279. ;--
  1280.  
  1281.     .PSECT    $CODE$,  RO 
  1282.  
  1283. BLSRTN    FILE.CLOSE,2,<DELFLG>        ; Close file routine.
  1284.     TST    BYTCNT            ; Get the byte count
  1285.     BEQ    10$            ; Skip if nothing in the buffer
  1286.     JSR    PC,BUFDMP        ; Dump anything in the buffers
  1287. ;
  1288. ; Disconnect the file from processing
  1289. ;
  1290.  
  1291. 10$:    MOV    #RABBLK,R1        ; Put address of RAB into R1.
  1292.     $DISCONNECT #RABBLK        ; Disconnect from file.
  1293. ;
  1294. ; Close the open file
  1295. ;
  1296.     MOV    #FILFAB,R1        ; Put address of FAB into R1
  1297.     $OFF    #FB$REA,FAC,R1        ; Turn off fac field in FAB.
  1298.     $OFF    #FB$WRT,FAC,R1        ; Turn off fac field in FAB.
  1299.     $CLOSE    #FILFAB            ; Close the file specified in the FAB.
  1300. ;
  1301. ; See if we wish to close with delete
  1302. ;
  1303.     BIT    DELFLG(SP),#TRUE    ; Do we want to close with delete ?
  1304.     BEQ    90$            ; No, we do not so branch.
  1305.     MOV    #FILFAB,R1        ; Put address of FAB into R1.
  1306.     $TESTBITS #FB$FID,FOP,R1    ; Open by file-id?
  1307.     BNE    90$            ; Yes, we don't really want to delete it
  1308.     $ERASE    R1            ; Delete the file
  1309. 90$:    MOV    #KNORMAL,R0        ; Set up success code in R0.
  1310.     RTS    PC            ; Return to Kermsg.
  1311.  
  1312.     .sbttl    Parser for File.open
  1313.  
  1314. ;
  1315. ; Parse the filename for wildcard searches
  1316. ;
  1317. ;    INPUT:    The name string located in file.n
  1318. ;          and its length in file.s.
  1319. ;
  1320. ;    OUTPUT:    The fields required by $Search are initialized
  1321. ;           and a match string is build.
  1322. ;
  1323. ;    REGISTERS:
  1324. ;        R1 =>    Pointer to the FAB block.
  1325. ;
  1326.  
  1327.     .PSECT    $CODE$,  RO 
  1328.  
  1329. PARSE:    BLSCAL    BL$MOV,<#FABLEN,#PURFAB,#FILFAB> ; Initialize the FAB
  1330.     BLSCAL    BL$MOV,<#NAMLEN,#PURNAM,#NAMBLK> ; And the name block
  1331.     BLSCAL    BL$MOV,<#RABLEN,#PURRAB,#RABBLK> ; And the RAB
  1332.  
  1333.     MOV    #FILFAB,R1        ; Put address of FAB into R1.
  1334.     $STORE    FILE.SIZE,FNS,R1    ; Store filename size in the FAB.
  1335.     $STORE    #FILE.NAME,FNA,R1    ; Store filename in the FAB.
  1336.     $SET    #FB$FID,FOP,R1        ; Set flag in Fop field of FILFAB.
  1337.     $PARSE    #FILFAB            ; Parse the file string.
  1338.     PJMP    SENCHK            ; Check for errors and return to caller
  1339.  
  1340.     .SBTTL    Startup routine for file transfers
  1341.  
  1342.     .PSECT    $CODE$,  RO 
  1343.  
  1344. STARTRANS::
  1345.     JSR    PC,INIKEY        ; Initialize key routines
  1346.     JSR    PC,XK.INT        ; Initialize the XK port
  1347. ;** PUT ERROR CHECK IN HERE **
  1348.     RTS    PC            ; Return to sender
  1349.  
  1350.     .sbttl    Reset routine when file transfer is complete
  1351.  
  1352.     .PSECT    $CODE$,  RO 
  1353.  
  1354. DONETRANS:
  1355.     BLSCAL    TT.TEXT,#M$POS,+    ; Position the cursor
  1356.     MOV    #SUCC$L,R1        ; Get the successful message and length
  1357.     MOV    #M$SUCC,R2        ;
  1358.     BIT    #TRUE,R0        ; See if transfer was successful
  1359.     BNE    DONEOK            ; If OK then branch
  1360.     MOV    #ABOR$L,R1        ; Bad transfer so get the aborted
  1361.     MOV    #M$ABOR,R2        ;  message and length
  1362. DONEOK:    JSR    PC,KILKEY        ; Kill off any pending QIO
  1363.  
  1364.     BLSCAL    TT.TEXT,R2,+        ; Ouput the correct transfer done
  1365.     BLSCAL    TT.TEXT,#M$RES,+    ;  messages
  1366.     BLSCAL    TT.OUTPUT,,-        ;
  1367.  
  1368.     BIT    #TRUE,NOSCRN        ; Check to see if we are watching
  1369.     BNE    99$            ;   transfer, If not then branch
  1370.     CALL    WTRES            ; Do a regular wait for resume
  1371. 20$:    JSR    PC,S$RXFR        ; Reset screen transfer info
  1372. 99$:    JSR    PC,XK.SHT        ; Close the XK port and reset parms
  1373.     RTS    PC            ; Return to caller
  1374.  
  1375.     .sbttl    Name Fixing Routine for $Search
  1376.  
  1377. ;
  1378. ; This routine fixes the name string built by search by removing old
  1379. ;   characters that were left from the previous file name.
  1380. ;
  1381. ;    INPUT:    The size of the new file name
  1382. ;          and pointer to the bytes of the name.
  1383. ;
  1384. ;    OUTPUT:    The file name written as specified by the
  1385. ;           fil.normal.form flag.
  1386. ;
  1387. ;    REGISTERS:    { No registers are permanently smashed }
  1388. ;
  1389. ;        R0 =>    Holds the address of the file.name block.
  1390. ;        R1 =>    Holds the address of the resultant string block.
  1391. ;        R2 =>    Holds the counter for the length of the new
  1392. ;               file name.
  1393. ;
  1394.  
  1395.     .PSECT    $CODE$,  RO 
  1396.  
  1397. FIXNAM:    JSR    R1,$SAVE3        ; Save registers one thru three.
  1398. ;
  1399. ; Set up R2 as the counter, put the address of the file name into R3,
  1400. ;  put the address of the resultant string into R1.  
  1401. ; Decide if we wish to remove any thing off the dame build by the resultant
  1402. ;  string.
  1403. ;
  1404.     MOV    FILE.SIZE,R2        ; Set up R2 to contain the max length.
  1405.     MOV    #FILE.NAME,R3        ; Put the destination into R3.
  1406.     MOV    #RESSTR,R1        ; Put address of source into R1.
  1407.     CMP    FIL.NORMAL.FORM,#FNM.FULL  ; Do we want anything cut off ?
  1408.     BNE    10$            ; Yes we do, branch.
  1409. ;
  1410. ; If here then we want the entire name used.
  1411. ;
  1412. 5$:    MOVB    (R1)+,(R3)+        ; Move the string.
  1413.     BEQ    99$            ; Branch if the moved byte was a null.
  1414.     SOB    R2,5$            ; Subtract one and branch if not zero.
  1415.     BR    30$            ; Branch due to error.
  1416. ;
  1417. ; If here then we want only the " NAME.EXT", or "NAME.EXT;ver"
  1418. ;
  1419. 10$:    CMPB    (R1)+,#']        ; Incrament the pointer until the byte
  1420.     BNE    10$            ;   pointed to is a "]".
  1421.  
  1422. ;
  1423. ; When here it means we are at the beginning of the name.
  1424. ;
  1425. 20$:    CMP    FIL.NORMAL.FORM,#FNM.UNTRAN ; Want to keep version number?
  1426.     BEQ    25$            ; Yes, skip check
  1427.  
  1428.     CMPB    (R1),#';        ; Is the next byte a ";".
  1429.     BEQ    99$            ; Yes, branch we don't want version #'s
  1430.  
  1431. 25$:    MOVB    (R1)+,(R3)+        ; Move in the file-name and extension.
  1432.     BEQ    99$            ; Return if done
  1433.     SOB    R2,20$            ; Sub one and branch if result isn't 0.
  1434. ;
  1435. ; If we are here then there is a problem, return an internal error code 
  1436. ;  to the calling routine.
  1437. ;
  1438. 30$:    MOV    #INTERR,R0        ; Return error code in R0.
  1439.     RTS    PC            ; Return to caller.
  1440. ;
  1441. ; When here it means  the name is moved into the file.name field, put its
  1442. ; length into file.size.  Then restore the smashed registers.
  1443. ;
  1444. 99$:    SUB    R2,FILE.SIZE        ; Find size of string, put it in file.s
  1445.     MOV    #KNORMAL,R0        ; Set up normal return.
  1446.     RTS    PC            ; Return to caller.
  1447.  
  1448.     .sbttl    Set Null Routines
  1449.  
  1450.  
  1451. ; Sets a null after the end of each file name in file.n.
  1452. ;
  1453. ;    INPUT:
  1454. ;        The only input required is the buffer address,
  1455. ;          and the offset.
  1456. ;
  1457. ;    OUTPUT:
  1458. ;        The output is the old buffer with the nulls inserted.
  1459. ;
  1460. ;    REGISTERS:
  1461. ;        R2 =>    Carries down the offset value.
  1462. ;        R3 =>    Brings down the address of the buffer.
  1463.  
  1464.     .PSECT    $CODE$,  RO 
  1465.  
  1466. SETNUL:
  1467.     JSR    R1,$SAVE3        ; Save registers one thru three.
  1468.     MOV    NOCHOS,R1        ; Get the number choosen
  1469.     MOV    #FSIZE,R2        ; Put the address of the lengths in R2.
  1470.     MOV    #FILES,R3        ; Put address of buffer into R3.
  1471. ;
  1472. ; At this point you wish to move to the end of the file name pointed to 
  1473. ;  by R3 and set a null byte after it.
  1474. ;
  1475. 10$:    ADD    (R2),R3            ; Add contents of R2 to the address
  1476.                     ;   located in R3.
  1477.     MOVB    #.CHNUL,(R3)        ; Set a null byte.
  1478. ;
  1479. ; At this point you want to move on to the next file name.  To do that you
  1480. ;  must go back to the beginning of the current file name, and then incrament
  1481. ;  to the next file name. Then you incrament the pointer in R2 to point to 
  1482. ;  the length of this new file name.
  1483. ;
  1484.     SUB    (R2),R3            ; Subtract the value at R2 from R5.
  1485.     ADD    #50.,R3            ; Add 50 to whats at R3.
  1486.     ADD    #2,R2            ; Increment to the next size.
  1487.     SOB    R1,10$            ; Loop for all files choosen
  1488. ;
  1489. ; When we get here we have set a null byte after each file name
  1490. ;
  1491.     RTS    PC            ; Return to caller.
  1492.  
  1493.     .SBTTL     Increment to Next File Routine
  1494.  
  1495. ;++
  1496. ; This routine sets up for the next file to be transfered by
  1497. ;  moving the file name to front of the buffer, and the length
  1498. ;  of the name to the beginning of its block.
  1499. ;
  1500. ;    INPUT:    File.n contains the filename to be moved, filpoi
  1501. ;          contains the pointer to the file name.
  1502. ;        File.s contains the file name length to be moved,
  1503. ;          sizpoi contains the pointer to that length.
  1504. ;
  1505. ;    OUTPUT:    Name of the next file is at beginning of File.n, and
  1506. ;          the corresponding length is in the beginning of its
  1507. ;          block.
  1508. ;
  1509. ;    REGISTERS:
  1510. ;        R2 =>    Holds address of old locations.
  1511. ;        R1 =>    Holds address of target location.
  1512. ;
  1513.  
  1514.     .PSECT    $CODE$,  RO 
  1515.  
  1516. INFLNM:    JSR    R1,$SAVE2        ; Save R1 to R2.
  1517. ;
  1518. ; This part will move the file size of the current file from fsize to
  1519. ;  file.size.
  1520. ;
  1521.     MOV    #FSIZE,R2        ; Put address of size into R2.
  1522.     ADD    SIZPOI,R2        ; Move pointer in R2
  1523.     MOV    (R2),FILE.SIZE        ; Move size of current filname into 
  1524.                     ;   file.s location.
  1525. ;
  1526. ; Here we initialize the pointer to point at the current file.
  1527. ;
  1528.     MOV    #FILES,R2        ; Put address of source into R2.
  1529.     ADD    FILPOI,R2        ; Move pointer in R2.
  1530.     MOV    #FILE.NAME,R1        ; Put address of destination into R1.
  1531. ;
  1532. ; This loop will move the file from files to file.name, exiting the loop 
  1533. ;  when it moves over a null byte.
  1534. ;
  1535. 80$:    MOVB    (R2),(R1)+        ; Move the byte in R2 into R1.
  1536.     TSTB    (R2)+            ; Was the source byte a "null" ?
  1537.     BNE    80$            ; No , continue the loop.
  1538. ;
  1539. ; When we get here we want to set the pointers for the next file, then
  1540. ;  return to the calling routine.
  1541. ;
  1542.     ADD    #2,SIZPOI        ; Add 2 to filename size pointer.
  1543.     ADD    #50.,FILPOI        ; Add 50 to filename pointer.
  1544.     INC    LSTFG            ; Increment the last file flag.
  1545.     RTS    PC            ; Yes, return to caller.
  1546.  
  1547.     .SBTTL    Swap Name Routine
  1548.  
  1549. ; This routine moves the name from a source buffer to
  1550. ;    a destination buffer
  1551. ;
  1552. ;    INPUT:    The file name in the source buffer.
  1553. ;
  1554. ;    OUTPUT:    The file name in the destination buffer.
  1555. ;
  1556. ;    REGISTERS:
  1557. ;        R1 =>    Counter of the length of the name
  1558. ;        R2 =>    Holds address of source buffer
  1559. ;        R3 =>    holds address of destination buffer
  1560. ;
  1561. ;    SWAPNM - Requires no input, moves data from rcvbuf to file.name.
  1562. ;
  1563.  
  1564.     .PSECT    $CODE$,  RO 
  1565.  
  1566. SWAPNM:    MOV    #RCVBUF,R2        ; Put address of source buffer into R2.
  1567.     MOV    #FILE.NAME,R3        ; Put address of destination into R5.
  1568.     CLR    FILE.SIZE        ; Clear the counter.
  1569. ;
  1570. ; This loop does the file movement.  It will exit the loop if it moves 
  1571. ;  either an escape or a null.  Until then it moves the contents of the
  1572. ;  source file in R2 into file.name.
  1573. ;
  1574. 10$:    CMPB    (R2),#.CHESC        ; Is the byte an escape ?
  1575.     BEQ    99$            ; Yes then we are done.
  1576.     MOVB    (R2)+,(R3)+        ; Move byte from source to destination.
  1577.     BEQ    99$            ; Leave the routine if null
  1578.     INC    FILE.SIZE        ; Increment R1.
  1579.     BR    10$            ; Branch back.
  1580. ;
  1581. ; Return to the caller
  1582. ;
  1583. 99$:    RTS    PC            ; Return to caller.
  1584.  
  1585.     .SBTTL    Status Error Check
  1586.  
  1587. ;
  1588. ; Senchk checks the status return of the RMS calls.
  1589. ;
  1590. ;  It first checks to see if it was successful,and
  1591. ;    then if unsuccessful it sees if the error was
  1592. ;    due to an EOF.
  1593. ;
  1594. ;    REGISTERS:
  1595. ;        R1 =>    pointer to either RAB block or FAB block.
  1596. ;
  1597.  
  1598.     .PSECT    $CODE$,  RO 
  1599.  
  1600. SENCHK:    $FETCH    R0,STS,R1        ; Get the status and put it in R0.
  1601.     TST    R0            ; Test the status code for success.
  1602.     BMI    20$            ; If negative then branch.
  1603.     MOV    #KNORMAL,R0        ; Set up a successful return code.
  1604.     RTS    PC            ; Return to caller
  1605.  
  1606. ;++
  1607. ; If here the we are checking for errors
  1608. ;--
  1609.  
  1610. ;
  1611. ; Check for end of file
  1612. ;
  1613. 20$:    CMP    #ER$EOF,R0        ; Check for EOF
  1614.     BNE    40$            ; If no then skip.
  1615.     MOV    #EOF,R0            ; Set up false return flag
  1616.     RTS    PC            ; Return to caller
  1617. ;
  1618. ; If here check for no more files
  1619. ;
  1620. 40$:    CMP    #ER$NMF,R0        ; Is error due to no more files.
  1621.     BNE    50$            ; If no then branch.
  1622.     MOV    #NOMORFILES,R0        ; Set up false return flag.
  1623.     RTS    PC            ; Return to caller
  1624. ;
  1625. ; If here check for record to big
  1626. ;
  1627. 50$:    CMP    #ER$RTB,R0        ; Was the record too big ?
  1628.     BNE    60$            ; No branch.
  1629.     MOV    #REC.TOO.BIG.,R0    ; Set up false return
  1630.     RTS    PC            ; Return to the caller
  1631. ;
  1632. ; If here call error routine and return an RMS error
  1633. ;
  1634. 60$:    JSR    PC,RMSERR        ; Jump to error output routine.
  1635.     MOV    #RMS11,R0        ; Set up false retrn flag.
  1636.     RTS    PC            ; Return to calling routine.
  1637.  
  1638.     .SBTTL    End of KERFIL.MAC
  1639.  
  1640.     .END
  1641.