.TITLE TRD - RJE TAPE READ UTILITY ;----------------------------------------------------------------------; ; MODULE: TRD ; ; LANGUAGE: DEC PDP-11 MACRO ASSEMBLY LANGUAGE (V3.2) ; ; SYSTEM: DEC PDP-11 RUNNING UNDER RSX-11M V3.2 ; ; MOSTEK CORPORATION ; ; COMPUTER AIDS TO DESIGN DIVISION ; ; 1215 WEST CROSBY ROAD ; ; CARROLLTON, TEXAS 75006 ; ; (214) 323-8813 ; ;----------------------------------------------------------------------; ; PROGRAMMER: KEVIN KLUGHART ; ;----------------------------------------------------------------------; ; DATE: 04-26-82 @ 06:00 CDST ; ;----------------------------------------------------------------------; ; PURPOSE: THIS UTILITY PROGRAM ALLOWS A USER TO READ ; ; A MAGNETIC TAPE AND/OR DISK FILE AND COPY IT ; ; TO DISK WITH A GIVEN FILENAME. ; ; THIS IS DONE IN PREPARATION FOR SUBMISSION ; ; TO A REMOTE HOST VIA THE RJE/HASP SUBSYSTEM. ; ; THIS PROGRAM IS THE COUNTERPART OF TWT, THE ; ; RJE/HASP TAPE WRITE UTILITY. THE FORMAT ; ; FOR THIS COMMAND IS AS FOLLOWS: ; ; ; ; >TRD [outfile]=[infile],[infile][/switch] ; ; ; ; VALID SWITCHES ARE: ; ; ; ; /AS - /A /AS /ASC /ASCI /ASCII ; ; CONVERT DATA FROM EBCDIC TO ASCII ; ; USED TO VIEW EBCDIC FILES ; ; ; ; /BI - /B /BI /BIN /BINA /BINAR /BINARY ; ; BINARY DATA TRANSFER. DO NOT ; ; CONVERT DATA BEFORE TRANSFER ; ; ; ; /BR - /BR /BOR ; ; PRECEED THE OUTPUT WITH A /*EOR CARD; ; ; ; /CH - /C /CH /CHE /CHECK /CHECKSUM ; ; PERFORM CHECKSUM CALCULATIONS ON ; ; INPUT DATA AND APPEND THE FOLLOWING ; ; TWO EBCDIC CARD IMAGES AT END OF ; ; CARD DECK: ; ; /*EOR ; ; OCTAL CHECKSUM: SXXXXXX ; ; ; ; /ER - /ER /EOR ; ; APPEND AN ADDITONAL "/*EOR" CARD ; ; TO THE END OF THE OUTPUT DATA FILE. ; ; ; ; /EV - /EV /EOV ; ; IGNORE END-OF-FILE MARKS ON TAPE ; ; AND PROCESS DATA UNTIL END OF ; ; LOGICAL VOLUME (DOUBLE EOF) ; ; ; ; /HX - /H /HE /HX /HEX ; ; HEXADECIMAL EBCDIC TRANSLATION. ; ; CONVERT EACH BYTE TO 2 EBCDIC ; ; HEXADECIMAL CHARACTERS ; ; ; ; /LO - /L /LO /LOG ; ; LOG STATISTICS ON SYSTEM CONSOLE ; ; ; ; /RE - /R /RE /RW /REW /REWIND ; ; REWIND TAPE AFTER COPY IS COMPLETE ; ; ; ; /TR - /T /TR /TRANS /TRANSPARENT ; ; PRECEED THE OUTPUT WITH A /*EOR ; ; CARD WITH "TR" IN COLUMNS 79 AND 80 ; ; ; ; /UN - /U /UN /UNL /UNLABELED ; ; OVERRIDE ANSI LABEL PROCESSING ; ;----------------------------------------------------------------------; ; NOTE: NO SWITCHES INDICATES ASCII TO ; ; EBCDIC CONVERSION!!! ; ; ; ; IN ADDITION, IF THE INPUT DEVICE ; ; IS A MAGNETIC TAPE, A CHECK IS ; ; PERFORMED TO SEE IF THE TAPE IS A ; ; STANDARD ANSI LABELED MAG TAPE. ; ; IF THIS IS SO, THE LABEL IS SKIPPED ; ; AND PROCESSING BEGINS AFTERTHE ; ; FIRST END-OF-FILE ON THE TAPE. ; ; THIS MAY BE OVERRIDDEN WITH THE ; ; /UNLABELED SWITCH. ; ;----------------------------------------------------------------------; ; EXAMPLES: ; ; ; ; >TRD READAPL.RJE=JOB.DAT,MT:/HX ; ; READ JOB.DAT, CONVERT FROM ASCII TO ; ; EBCDIC, AND APPEND MAG TAPE FILE, AFTER ; ; CONVERTING FILE FROM BINARY TO HEX EBCDIC.; ; ; ; >TRD TI:=READAPL.RJE/AS ; ; VIEW READAPL.RJE, CONVERT EBCDIC TO ASCII ; ; ; ; >TRD READAPL.RJE=JOB.DAT,MT:/BI ; ; SAME AS FIRST EXAMPLE, EXCEPT THAT NO ; ; DATA CONVERSION IS PERFORMED ON TAPE DATA.; ; ; ; >TRD READAPL.RJE=MT:/UNLABELED ; ; READ THE FIRST FILE FROM THE MAGNETIC ; ; TAPE, AND DO NOT PERFORM ANSI MAG TAPE ; ; LABEL PROCESSING. IF THE TAPE WERE AN ; ; ANSI LABELED TAPE, THEN THE OUTPUT FILE ; ; WOULD CONTAIN THE EBCDIC TRANSLATION OF ; ; THE TAPE LABEL. ; ;----------------------------------------------------------------------; ; REVISION LIST: V01.00 - INITIAL RELEASE ; ; V01.01 - INCORPORATE OVERLAPPED TAPE READ CODE ; ; V01.02 - ALLOW APPENDING OF TAPE AND DISK FILES; ; V01.03 - ADD /REWIND SWITCH TO REWIND TAPE ; ; V01.04 - ADD ANSI TAPE LABEL PROCESSING AND ; ; THE /UNLABELED SWITCH TO DISABLE THE ; ; AUTOMATIC PROCESSING OF LABELED TAPES.; ; V01.05 - ADD /EOR SWITCH TO APPEND /EOF CARDS ; ; V01.06 - ADD /VOL SWITCH TO READ ENTIRE TAPE. ; ; ADD INITIALIZATION MESSAGE. ; ; V01.07 - ADD "EXACT" QUALIFIER FOR CSI PARSE. ; ; RENAME /VOL SPECIFIER TO /EOV. ; ; ADD /BOF SWITCH TO PRECEED WITH /*EOR.; ; ADD /TRANSPARENT SWITCH TO PRECEED ; ; DECK WITH TRANSPARENT /*EOR CARD. ; ; V01.08 - CORRECTLY DETECT END OF COMMAND LINE ; ;----------------------------------------------------------------------; .IDENT /V01.08/ ; CURRENT RELEASE .PSECT $DATA .ENABLE LC .SBTTL PROGRAM PARAMETERS ;----------------------------------------------------------------------; ; ; ; ; ; PROGRAM PARAMETERS ; ; ; ; ; ;----------------------------------------------------------------------; ; LOGICAL UNIT ASSIGNMENTS (LUN) ; ;----------------------------------------------------------------------; TILUN = 1 ; LOGICAL UNIT FOR TERMINAL I/O TTLUN = TILUN+1 ; LOGICAL UNIT FOR LOG TERMINAL I/O MTLUN = TTLUN+1 ; LOGICAL UNIT FOR MAG TAPE INPUT RDLUN = MTLUN+1 ; LOGICAL UNIT FOR INPUT FILE(S) WTLUN = RDLUN+1 ; LOGICAL UNIT FOR OUTPUT FILE ;----------------------------------------------------------------------; ; EVENT FLAG ASSIGNMENTS ; ;----------------------------------------------------------------------; TIFLAG= TILUN ; EVENT FLAG FOR TERMINAL I/O TTFLAG= TTLUN ; EVENT FLAG FOR LOG TERMINAL I/O MTFLAG= MTLUN ; EVENT FLAG FOR MAG TAPE I/O ;----------------------------------------------------------------------; ; BUFFER DEFINITION PARAMETERS ; ;----------------------------------------------------------------------; CRDSIZ= 80. ; MAXIMUM RECORD SIZE - OUTPUT RECORD RECSIZ= 4096. ; MAXIMUM RECORD SIZE - INPUT RECORD ;----------------------------------------------------------------------; ; CHARACTER DEFINITION PARAMETERS ; ;----------------------------------------------------------------------; ASCPAD= 000040 ; ASCII PAD CHARACTER FOR LAST CARD IMAGE BINPAD= 000100 ; EBCDIC PAD CHARACTER FOR LAST CARD IMAGE ; EBCDIC BLANK (SPACE) ;----------------------------------------------------------------------; ; ANSI MAGNETIC TAPE LABEL PARAMETERS ; ;----------------------------------------------------------------------; AN.LEN= 80. ; LENGTH OF ANSI TAPE LABEL RECORDS AN.LI0= 'V ; ANSI TAPE LABEL IDENTIFIER AN.LI1= 'O ; AN.LI2= 'L ; AN.LI3= '1 ; ANSI TAPE LABEL NUMBER .SBTTL EXTERNAL MACROS ;----------------------------------------------------------------------; ; ; ; ; ; EXTERNAL MACROS ; ; ; ; ; ;----------------------------------------------------------------------; ; EXECUTIVE DIRECTIVE MACROS ; ;----------------------------------------------------------------------; .MCALL ALUN$ ; ASSIGN LUN .MCALL CALL ; CALL SUBROUTINE .MCALL DIR$ ; EXECUTE EXECUTIVE DIRECTIVE .MCALL EXIT$S ; EXIT TASK .MCALL GTIM$S ; GET TIME PARAMETERS .MCALL QIO$S ; QUEUE I/O REQUEST .MCALL QIOW$S ; QUEUE I/O REQUEST AND WAIT .MCALL RETURN ; RETURN FROM SUBROUTINE .MCALL SETF$S ; SET SINGLE EVENT FLAG .MCALL WTSE$S ; WAIT ON SINGLE EVENT FLAG ;----------------------------------------------------------------------; ; FILE PROCESSING MACROS ; ;----------------------------------------------------------------------; .MCALL CLOSE$ ; CLOSE FILE .MCALL FDAT$R ; INITIALIZE FILE ATTRIBUTES SECTION OF FDB .MCALL FDBDF$ ; DEFINE FDB .MCALL FINIT$ ; INITIALIZE FILE PROCESSING .MCALL FSRSZ$ ; ALLOCATE FSR REGION .MCALL GET$ ; GET (READ) A RECORD .MCALL OPEN$R ; OPEN A FILE FOR READ-ONLY ACCESS .MCALL OPEN$W ; OPEN A FILE FOR WRITE-ONLY ACCESS .MCALL PUT$ ; PUT (WRITE) A SINGLE RECORD ;----------------------------------------------------------------------; ; COMMAND LINE PROCESSING MACROS ; ;----------------------------------------------------------------------; .MCALL CSI$ ; COMMAND STRING INTERPRETER .MCALL CSI$1 ; COMMAND SYNTAX ANALYZER .MCALL CSI$2 ; COMMAND SYNTAX PARSER .MCALL CSI$SW ; CREATE SWITCH DESCRIPTOR TABLE ENTRY .MCALL CSI$SV ; CREATE SWITCH-VALUE DESCRIPTOR TABLE ENTRY .MCALL CSI$ND ; DEFINE END OF DESCRIPTOR TABLE .MCALL GCML$ ; GET MCR COMMAND LINE .MCALL GCMLB$ ; GET MCR COMMAND LINE BUFFER DEFINITION .MCALL GCMLD$ ; DEFINE OFFSETS FOR GCMLB$ .SBTTL LOCAL MACRO DEFINITIONS ;----------------------------------------------------------------------; ; ; ; ; ; LOCAL MACRO DEFINITIONS ; ; ; ; ; ;----------------------------------------------------------------------; ; ERROR REPORTING MACRO ; ;----------------------------------------------------------------------; ; THIS MACRO ALLOWS THE PROGRAMMER TO SPECIFY AN ERROR VALUE OR ; ; ALLOW THE ERROR MACRO TO SPECIFY AN ERROR INDEX WHICH IS PUT ; ; IN REGISTER R5 PRIOR TO TRAPPING BY AN ODD ADDRESS TRAP. ; ;----------------------------------------------------------------------; .MACRO ERROR ERR,ERRBYT .IF NDF $$$ERR ; DEFINE ERROR COUNT IF FIRST INVOCATION $$$ERR= 0 ; INITIALIZE ERROR COUNT .ENDC .NARG $$$ERC ; COMPUTE NUMBER OF ERROR ARGUMENTS $$$ERR= $$$ERR+1 ; *********** ERROR INDEX *********** .PRINT $$$ERR ; *********** ERROR INDEX *********** MOVB #$$$ERR,R5 ; GET ERROR INDEX POINTER ASL R5 ; SHIFT ERROR TO UPPER 3 OCTAL DIGITS (XXX.000) ASL R5 ; ASL R5 ; ASL R5 ; ASL R5 ; ASL R5 ; ASL R5 ; ASL R5 ; ASL R5 ; RESULT IS CNT.ERR (000.000) .IF NE $$$ERC ; IF NUMBER OF ARGUMENTS IS NOT ZERO, SHOW ERROR BISB ERR,R5 ; GET ERROR NUMBER .ENDC .IF EQ $$$ERC-2 ; IF 2 ARGUMENTS, LOAD R4 WITH ERROR BYTE MOVB ERRBYT,R4 ; GET ERROR BYTE .ENDC TST .+1 ; EXIT WITH FATAL ODD ADDRESS TRAP .ENDM ;----------------------------------------------------------------------; ; ; ; PRINT MESSAGE TO CONSOLE MACRO ; ; ; ;----------------------------------------------------------------------; ; THIS MACRO ALLOWS THE USER TO QUEUE A MESSAGE TO THE USER ; ; TERMINAL, AND LOGS THE MESSAGE TO THE OPERATOR CONSOLE ; ;----------------------------------------------------------------------; .MACRO PRINT MSG,LEN,SPC .NARG $$$CNT ; GET NUMBER OF ARGUMENTS MOV MSG,MS.PTR ; GET ADDRESS OF MESSAGE TO PRINT MOV LEN,MS.LEN ; GET LENGTH OF MESSAGE .IF EQ $$$CNT-2 ; FOR 2 ARGUMENTS MOV #40,MS.SPC ; SINGLE SPACE OUTPUT .ENDC .IF EQ $$$CNT-3 ; FOR 3 ARGUMENTS MOV SPC,MS.SPC ; SELECT CARRIAGE CONTROL .ENDC CALL $MSG ; PRINT THE MESSAGE .ENDM ;----------------------------------------------------------------------; ; ; ; STACK MANIPULATION MACROS ; ; ; ;----------------------------------------------------------------------; ; PUSH: PUSH ARGUMENT ON STACK ; ;----------------------------------------------------------------------; .MACRO PUSH ARG MOV ARG,-(SP) .ENDM ;----------------------------------------------------------------------; ; POP: POP ARGUMENT OFF STACK ; ;----------------------------------------------------------------------; .MACRO POP ARG MOV (SP)+,ARG .ENDM ;----------------------------------------------------------------------; ; SAVREG: SAVE REGISTERS R0,R1,R2,R3,R4,R5 ON STACK ; ;----------------------------------------------------------------------; .MACRO SAVREG PUSH R0 PUSH R1 PUSH R2 PUSH R3 PUSH R4 PUSH R5 .ENDM ;----------------------------------------------------------------------; ; RSTREG: RESTORE REGISTERS R0,R1,R2,R3,R4,R5 FROM STACK ; ;----------------------------------------------------------------------; .MACRO RSTREG POP R5 POP R4 POP R3 POP R2 POP R1 POP R0 .ENDM .SBTTL DOUBLE PRECISION INTEGER MACROS ;----------------------------------------------------------------------; ; ; ; ; ; DOUBLE PRECISION INTEGER MACROS ; ; ; ; ; ;----------------------------------------------------------------------; ; ; ; ADDL - ADD TO DOUBLE PRECISION LONGWORD ; ; ; ;----------------------------------------------------------------------; .MACRO ADDL VAL,LOC ADD VAL,LOC+2 ; ADD WORD QUANTITY TO SECOND WORD ADC LOC ; ADD CARRY BIT TO FIRST WORD .ENDM ; END OF ADDL MACRO ;----------------------------------------------------------------------; ; ; ; CLRL - CLEAR DOUBLE PRECISION LONGWORD ; ; ; ;----------------------------------------------------------------------; .MACRO CLRL LOC ; CLEAR LONGWORD QUANTITY CLR LOC ; CLEAR FIRST WORD CLR LOC+2 ; CLEAR SECOND WORD .ENDM ; END OF CLRL MACRO ;----------------------------------------------------------------------; ; ; ; INCL - INCREMENT DOUBLE PRECISION LONGWORD ; ; ; ;----------------------------------------------------------------------; .MACRO INCL LOC,?SKIP ; INCREMENT LONGWORD QUANTITY INC LOC+2 ; INCREMENT SECOND WORD BVC SKIP ; IF NO OVERFLOW, THEN SKIP SECOND INCREMENT INC LOC ; OVERFLOW - INCREMENT FIRST WORD SKIP: ; SKIP PAST SECOND INCREMENT .ENDM ; END OF INCL MACRO ;----------------------------------------------------------------------; ; ; ; CBDMG - CONVERT BINARY WORD TO ASCII DECIMAL ; ; ; ;----------------------------------------------------------------------; .MACRO CBDMG OUTPUT,INPUT,ZERO,?CLR MOV OUTPUT,R0 ; GET OUTPUT ADDRESS MOV #5,R1 ; ZERO OUT 5 DECIMAL DIGITS CLR: CLRB (R0)+ ; CLEAR OUT OUTPUT AREA BYTE DEC R1 ; DECREMENT BYTE COUNTER BNE CLR ; CLEAR AGAIN IF NECESSARY MOV OUTPUT,R0 ; R0 - STARTING ADDRESS OF OUTPUT AREA MOV INPUT,R1 ; R1 - WORD VALUE TO BE CONVERTED MOV ZERO,R2 ; R2 - 0 FOR ZERO SUPPRESSION, ? FOR LEAD ZEROS CALL $CBDMG ; CONVERT WORD TO ASCII DECIMAL .ENDM ; END OF CBDMG MACRO ;----------------------------------------------------------------------; ; ; ; CBOMG - CONVERT BINARY WORD TO ASCII OCTAL ; ; ; ;----------------------------------------------------------------------; .MACRO CBOMG OUTPUT,INPUT,ZERO,?CLR MOV OUTPUT,R0 ; GET OUTPUT ADDRESS MOV #6,R1 ; ZERO OUT 6 OCTAL DIGITS CLR: CLRB (R0)+ ; CLEAR OUT OUTPUT AREA BYTE DEC R1 ; DECREMENT BYTE COUNTER BNE CLR ; CLEAR AGAIN IF NECESSARY MOV OUTPUT,R0 ; R0 - STARTING ADDRESS OF OUTPUT AREA MOV INPUT,R1 ; R1 - WORD VALUE TO BE CONVERTED MOV ZERO,R2 ; R2 - 0 FOR ZERO SUPPRESSION, ? FOR LEAD ZEROS CALL $CBOMG ; CONVERT WORD TO ASCII OCTAL .ENDM ; END OF CBOMG MACRO ;----------------------------------------------------------------------; ; ; ; CDDMG - CONVERT DOUBLE PRECISION INTEGER TO ASCII ; ; ; ;----------------------------------------------------------------------; .MACRO CDDMG OUTPUT,INPUT,ZERO,?CLR MOV OUTPUT,R0 ; GET OUTPUT ADDRESS MOV #9.,R1 ; ZERO OUT 9 DECIMAL DIGITS CLR: CLRB (R0)+ ; CLEAR OUT OUTPUT AREA BYTE DEC R1 ; DECREMENT BYTE COUNTER BNE CLR ; CLEAR AGAIN IF NECESSARY MOV OUTPUT,R0 ; R0 - STARTING ADDRESS OF OUTPUT AREA MOV INPUT,R1 ; R1 - ADDRESS OF LONGWORD TO BE CONVERTED MOV ZERO,R2 ; R2 - 0 FOR ZERO SUPPRESSION, ? FOR LEAD ZEROS CALL $CDDMG ; CONVERT LONGWORD TO ASCII DECIMAL .ENDM ; END OF CDDMG MACRO .SBTTL DIRECTIVE PARAMETER BLOCKS (DPB'S) ;----------------------------------------------------------------------; ; ; ; ; ; DIRECTIVE PARAMETER BLOCKS ; ; ; ; ; ;----------------------------------------------------------------------; ; SET UP GET COMMAND LINE BUFFERS FOR USER INPUT ; ;----------------------------------------------------------------------; ; FORMAT FOR GCML MACRO: GCMLB$ MAXD,PRMPT,UBUF,LUN,PDL,SIZE ; ;----------------------------------------------------------------------; .EVEN GETMCR: GCMLB$ 1,TRD ;----------------------------------------------------------------------; ; ALLOCATE SPACE FOR CSI PARSING ; ;----------------------------------------------------------------------; CSI$ CSIBLK: .BLKB C.SIZE ; ALLOCATE CSI SPACE CSIMKW: .BLKW 1 ; CSI MASK WORD ;----------------------------------------------------------------------; ; ; ; CSI SWITCH DESCRIPTOR TABLE DEFINITION ; ; ; ;----------------------------------------------------------------------; ; DEFINE SWITCH MASKS ; ;----------------------------------------------------------------------; ASCFLG= 000001 ; EBCDIC TO ASCII CONVERSION BINFLG= 000002 ; BINARY DATA STREAM - NO CONVERSION BORFLG= 000004 ; PRECEED OUTPUT WITH /*EOR CARD CHKFLG= 000010 ; PERFORM CHECKSUM REPORTING AT EOF EORFLG= 000020 ; APPEND "/*EOR" CARD TO END OF OUTPUT FILE EOVFLG= 000040 ; IGNORE END-OF-FILES FOR TAPE FILES HEXFLG= 000100 ; EBCDIC HEXADECIMAL CONVERSION LOGFLG= 000200 ; LOG STATISTICS ON SYSTEM CONSOLE REWFLG= 000400 ; REWIND TAPE AND UNLOAD AFTER COMPLETION TRPFLG= 001000 ; PRECEED OUTPUT WITH TRANSPARENT /*EOR CARD UNLFLG= 002000 ; FORCE UNLABELED TAPE PROCESSING (NO ANSI) EOFFLG= 100000 ; SET ON TAPE END-OF-FILE ;----------------------------------------------------------------------; ; DEFINE SWITCH DESCRIPTOR TABLE ; ;----------------------------------------------------------------------; CSISWD: CSI$SW A,ASCFLG,CSIMKW,SET,NEG,,EXACT CSI$SW AS,ASCFLG,CSIMKW,SET,NEG,,EXACT CSI$SW ASC,ASCFLG,CSIMKW,SET,NEG,,EXACT CSI$SW ASCI,ASCFLG,CSIMKW,SET,NEG,,EXACT CSI$SW ASCII,ASCFLG,CSIMKW,SET,NEG,,EXACT CSI$SW B,BINFLG,CSIMKW,SET,NEG,,EXACT CSI$SW BI,BINFLG,CSIMKW,SET,NEG,,EXACT CSI$SW BIN,BINFLG,CSIMKW,SET,NEG,,EXACT CSI$SW BINA,BINFLG,CSIMKW,SET,NEG,,EXACT CSI$SW BINAR,BINFLG,CSIMKW,SET,NEG,,EXACT CSI$SW BINARY,BINFLG,CSIMKW,SET,NEG,,EXACT CSI$SW BR,BORFLG,CSIMKW,SET,NEG,,EXACT CSI$SW BOR,BORFLG,CSIMKW,SET,NEG,,EXACT CSI$SW C,CHKFLG,CSIMKW,SET,NEG,,EXACT CSI$SW CH,CHKFLG,CSIMKW,SET,NEG,,EXACT CSI$SW CHE,CHKFLG,CSIMKW,SET,NEG,,EXACT CSI$SW CHK,CHKFLG,CSIMKW,SET,NEG,,EXACT CSI$SW CHEC,CHKFLG,CSIMKW,SET,NEG,,EXACT CSI$SW CHECK,CHKFLG,CSIMKW,SET,NEG,,EXACT CSI$SW CHECKS,CHKFLG,CSIMKW,SET,NEG,,EXACT CSI$SW CHECKSU,CHKFLG,CSIMKW,SET,NEG,,EXACT CSI$SW CHECKSUM,CHKFLG,CSIMKW,SET,NEG,,EXACT CSI$SW ER,EORFLG,CSIMKW,SET,NEG,,EXACT CSI$SW EOR,EORFLG,CSIMKW,SET,NEG,,EXACT CSI$SW EV,EOVFLG,CSIMKW,SET,NEG,,EXACT CSI$SW EOV,EOVFLG,CSIMKW,SET,NEG,,EXACT CSI$SW H,HEXFLG,CSIMKW,SET,NEG,,EXACT CSI$SW HE,HEXFLG,CSIMKW,SET,NEG,,EXACT CSI$SW HX,HEXFLG,CSIMKW,SET,NEG,,EXACT CSI$SW HEX,HEXFLG,CSIMKW,SET,NEG,,EXACT CSI$SW L,LOGFLG,CSIMKW,SET,NEG,,EXACT CSI$SW LO,LOGFLG,CSIMKW,SET,NEG,,EXACT CSI$SW LOG,LOGFLG,CSIMKW,SET,NEG,,EXACT CSI$SW R,REWFLG,CSIMKW,SET,NEG,,EXACT CSI$SW RE,REWFLG,CSIMKW,SET,NEG,,EXACT CSI$SW RW,REWFLG,CSIMKW,SET,NEG,,EXACT CSI$SW REW,REWFLG,CSIMKW,SET,NEG,,EXACT CSI$SW REWI,REWFLG,CSIMKW,SET,NEG,,EXACT CSI$SW REWIN,REWFLG,CSIMKW,SET,NEG,,EXACT CSI$SW REWIND,REWFLG,CSIMKW,SET,NEG,,EXACT CSI$SW T,TRPFLG,CSIMKW,SET,NEG,,EXACT CSI$SW TR,TRPFLG,CSIMKW,SET,NEG,,EXACT CSI$SW TRA,TRPFLG,CSIMKW,SET,NEG,,EXACT CSI$SW TRAN,TRPFLG,CSIMKW,SET,NEG,,EXACT CSI$SW TRANS,TRPFLG,CSIMKW,SET,NEG,,EXACT CSI$SW TRANSP,TRPFLG,CSIMKW,SET,NEG,,EXACT CSI$SW TRANSPA,TRPFLG,CSIMKW,SET,NEG,,EXACT CSI$SW TRANSPAR,TRPFLG,CSIMKW,SET,NEG,,EXACT CSI$SW TRANSPARE,TRPFLG,CSIMKW,SET,NEG,,EXACT CSI$SW TRANSPAREN,TRPFLG,CSIMKW,SET,NEG,,EXACT CSI$SW TRANSPARENT,TRPFLG,CSIMKW,SET,NEG,,EXACT CSI$SW U,UNLFLG,CSIMKW,SET,NEG,,EXACT CSI$SW UN,UNLFLG,CSIMKW,SET,NEG,,EXACT CSI$SW UNL,UNLFLG,CSIMKW,SET,NEG,,EXACT CSI$SW UNLA,UNLFLG,CSIMKW,SET,NEG,,EXACT CSI$SW UNLAB,UNLFLG,CSIMKW,SET,NEG,,EXACT CSI$SW UNLABE,UNLFLG,CSIMKW,SET,NEG,,EXACT CSI$SW UNLABEL,UNLFLG,CSIMKW,SET,NEG,,EXACT CSI$SW UNLABELE,UNLFLG,CSIMKW,SET,NEG,,EXACT CSI$SW UNLABELED,UNLFLG,CSIMKW,SET,NEG,,EXACT CSI$ND ; END OF SWITCH DESCRIPTOR TABLE ;----------------------------------------------------------------------; ; QIO LOGICAL FLAG - SET "TRUE" TO BYPASS FCS INPUT PROCESSING ; ;----------------------------------------------------------------------; QIOFLG: .BLKW 1 ; QIO FLAG SET "TRUE" FOR MT, CR, ETC. ;----------------------------------------------------------------------; ; ALLOCATE QIO STATUS BLOCK FOR I/O RETURN STATUS ; ;----------------------------------------------------------------------; IOSTAT: .BLKW 1 ; I/O STATUS & DEVICE DATA BYTCNT: .BLKW 1 ; TRANSFER COUNT IN BYTES ;----------------------------------------------------------------------; ; ALLOCATE DPB FOR ASSIGN LUN DIRECTIVE ; ;----------------------------------------------------------------------; ALUN: ALUN$ MTLUN,MT,0 ; ASSIGN LUN FOR MAG TAPE (OR OTHER) ;----------------------------------------------------------------------; ; ALLOCATE QIO STATUS BLOCK FOR TERMINAL I/O RETURN STATUS ; ;----------------------------------------------------------------------; TTSTAT: .BLKW 2 ; I/O STATUS & DEVICE DATA FOR TERMINAL .SBTTL DATA BUFFERS ;----------------------------------------------------------------------; ; ; ; ; ; DATA BUFFERS ; ; ; ; ; ;----------------------------------------------------------------------; ; FILE STORAGE REGION ; ;----------------------------------------------------------------------; .EVEN FSRSZ$ 3,,$DATA ; ONLY THREE FILES HERE: INPUT/OUTPUT/MCR ;----------------------------------------------------------------------; ; EBCDIC HEXADECIMAL CONVERSION DATA TABLE ; ;----------------------------------------------------------------------; HEX: .BYTE 360,361,362,363,364,365,366,367 ; "01234567" .BYTE 370,371,301,302,303,304,305,306 ; "89ABCDEF" ;----------------------------------------------------------------------; ; END-OF-RECORD CARD BUFFERS ; ;----------------------------------------------------------------------; EORBUF: .BYTE 141,134,305,326,331 ; EBCDIC "/*EOR" .REPT CRDSIZ-<.-EORBUF> ; PAD REMAINDER WITH BLANKS .BYTE BINPAD ; EBCDIC BLANK PAD .ENDR ;----------------------------------------------------------------------; ; TRANSPARENT END-OF-RECORD CARD BUFFER ; ;----------------------------------------------------------------------; TRPEOR: .BYTE 141,134,305,326,331 ; EBCDIC "/*EOR" .REPT CRDSIZ-<.-TRPEOR>-2 ; PAD TO COLUMN 78 WITH BLANKS .BYTE BINPAD ; EBCDIC BLANK PAD .ENDR .BYTE 343,331 ; EBCDIC "TR" ;----------------------------------------------------------------------; ; OCTAL FILE CHECKSUM RECORD - Sxxxxxx ; ;----------------------------------------------------------------------; CHKBUF: .BYTE 342 ; 'S' TO INDICATE CHECKSUM CHKNUM: .REPT CRDSIZ-1 ; DEFINE OCTAL CHECKSUM RECORD .BYTE BINPAD .ENDR ;----------------------------------------------------------------------; ; OUTPUT RECORD BUFFER ; ;----------------------------------------------------------------------; .EVEN CRDBUF: .BLKB CRDSIZ ; OUTPUT RECORD SINGLE BUFFER CRDEND= CRDBUF+CRDSIZ ; DEFINE BUFFER LIMIT + 1 ;----------------------------------------------------------------------; ; INPUT RECORD BUFFERS ; ;----------------------------------------------------------------------; .EVEN RECADR: .BLKW 1 ; INPUT RECORD BUFFER ADDRESS RECBF0: .BLKB RECSIZ ; INPUT SINGLE RECORD BUFFER - PRIMARY RECBF1: .BLKB RECSIZ ; INPUT SINGLE RECORD BUFFER - SECONDARY .SBTTL EBCDIC TO ASCII TRANSLATE TABLE ;----------------------------------------------------------------------; ; ; ; ; ; EBCDIC TO ASCII TRANSLATE TABLE ; ; ; ; ; ;----------------------------------------------------------------------; ASCII: .BYTE 000,001,002,003,040,011,040,177,040,040 .BYTE 040,013,014,015,016,017,020,021,022,023 .BYTE 040,040,010,040,030,031,040,040,034,035 .BYTE 036,037,040,040,040,040,040,012,027,033 .BYTE 040,040,040,040,040,005,006,007,040,040 .BYTE 026,040,040,040,040,004,040,040,040,040 ; 50. .BYTE 024,025,040,032,040,040,040,040,040,040 .BYTE 040,040,040,040,133,056,074,050,053,041 .BYTE 046,040,040,040,040,040,040,040,040,040 .BYTE 135,044,052,051,073,136,055,057,040,040 .BYTE 040,040,040,040,040,040,174,054,045,137 ; 100. .BYTE 076,077,137,040,040,040,040,040,040,040 .BYTE 040,140,072,043,100,047,075,042,040,141 .BYTE 142,143,144,145,146,147,150,151,040,040 .BYTE 040,040,040,040,040,152,153,154,155,156 .BYTE 157,160,161,162,040,040,040,040,040,040 ; 150. .BYTE 040,176,163,164,165,166,167,170,171,172 .BYTE 040,040,040,040,040,040,040,040,040,040 .BYTE 040,040,040,040,040,040,040,040,040,040 .BYTE 040,040,173,101,102,103,104,105,106,107 .BYTE 110,111,040,040,040,040,040,040,175,112 ; 200. .BYTE 113,114,115,116,117,120,121,122,040,040 .BYTE 040,040,040,040,134,040,123,124,125,126 .BYTE 127,130,131,132,040,040,040,040,040,040 .BYTE 060,061,062,063,064,065,066,067,070,071 .BYTE 040,040,040,040,040,040 ; 250. .SBTTL ASCII TO EBCDIC TRANSLATE TABLE ;----------------------------------------------------------------------; ; ; ; ; ; ASCII TO EBCDIC TRANSLATE TABLE ; ; ; ; ; ;----------------------------------------------------------------------; EBCDIC: .BYTE 000,001,002,003,004,005,006,007 .BYTE 010,011,012,013,014,015,016,017 .BYTE 020,021,022,023,024,025,026,027 .BYTE 030,031,032,033,034,035,036,037 .BYTE 100,117,177,173,133,154,120,175 ; 40 .BYTE 115,135,134,116,153,140,113,141 .BYTE 360,361,362,363,364,365,366,367 .BYTE 370,371,172,136,114,176,156,157 .BYTE 174,301,302,303,304,305,306,307 ; 100 .BYTE 310,311,321,322,323,324,325,326 .BYTE 327,330,331,342,343,344,345,346 .BYTE 347,350,351,112,340,132,137,155 .BYTE 171,201,202,203,204,205,206,207 ; 140 .BYTE 210,211,221,222,223,224,225,226 .BYTE 227,230,231,242,243,244,245,246 .BYTE 247,250,251,300,152,320,241,377 .SBTTL STATISTICS COUNTERS ;----------------------------------------------------------------------; ; ; ; ; ; STATISTICS COUNTERS ; ; ; ; ; ;----------------------------------------------------------------------; ; THE FOLLOWING COUNTERS MAINTAIN STATISTICS ON THE NUMBER OF ; ; DATA BLOCKS READ FROM TAPE OR DISK, THE NUMBER OF BYTES ; ; TRANSFERRED TO DISK, AND THE NUMBER OF CARD IMAGES CREATED. ; ;----------------------------------------------------------------------; .EVEN FT.NUM: .BLKW 2 ; INPUT FILE COUNTER FT.BLK: .BLKW 2 ; NUMBER OF BLOCKS READ (TOTAL) FT.BYT: .BLKW 2 ; NUMBER OF BYTES WRITTEN (TOTAL) FT.REC: .BLKW 2 ; NUMBER OF CARD IMAGES CREATED (TOTAL) FI.BLK: .BLKW 2 ; NUMBER OF BLOCKS READ FI.BYT: .BLKW 2 ; NUMBER OF BYTES READ FI.REC: .BLKW 2 ; NUMBER OF CARD IMAGES CREATED FI.RSZ: .BLKW 2 ; SIZE OF LARGEST BLOCK READ FI.RSS: .BLKW 2 ; SIZE OF SHORTEST BLOCK READ FI.RSL: .BLKW 2 ; SIZE OF LAST BLOCK READ FI.SUM: .BLKW 2 ; OUTPUT TRANSFER CHECKSUM (PER EOF WRITTEN) .SBTTL OPERATOR MESSAGES ;----------------------------------------------------------------------; ; ; ; ; ; OPERATOR MESSAGES ; ; ; ; ; ;----------------------------------------------------------------------; ; DEFINE DESCRIPTOR BLOCK FOR ALL OPERATOR MESSAGES ; ;----------------------------------------------------------------------; .EVEN MS.PTR: .BLKW 1 ; DEFINE MESSAGE POINTER MS.LEN: .BLKW 1 ; DEFINE MESSAGE LENGTH MS.SPC: .BLKW 1 ; DEFINE CARRIAGE CONTROL ;----------------------------------------------------------------------; ; OPERATOR MESSAGE TEXT ; ;----------------------------------------------------------------------; ; INITIALIZATION AND VERSION INFORMATION MESSAGE ; ;----------------------------------------------------------------------; ID.MSG: .ASCII / *** RJE Tape Read Utility - / .ASCII /V01.08 (26-APR-82) ***/ .BYTE CR,LF,LF ID.LEN= .-ID.MSG ;----------------------------------------------------------------------; ; ANSI TAPE LABEL INFORMATIVE MESSAGE ; ;----------------------------------------------------------------------; MA.MSG: .ASCII /*** ANSI tape detected - skipping tape label ***/ MA.LEN= .-MA.MSG ;----------------------------------------------------------------------; ; INPUT FILE STATISTICS ; ;----------------------------------------------------------------------; MI.MSG: .ASCII /*** File / MI.NUM: .ASCII /XXXXX has / MI.BLK: .ASCII /XXXXXXXXX blocks (/ MI.RSZ: .ASCII \XXXXX/\ MI.RSS: .ASCII \XXXXX/\ MI.LST: .ASCII /XXXXX), / MI.BYT: .ASCII /XXXXXXXXX bytes, / MI.REC: .ASCII /XXXXXXXXX cards ***/ MI.LEN= .-MI.MSG ;----------------------------------------------------------------------; ; TOTAL FILE STATISTICS ; ;----------------------------------------------------------------------; MT.MSG: .ASCII /*** File Totals: / MT.BLK: .ASCII /XXXXXXXXX blocks, / MT.BYT: .ASCII /XXXXXXXXX bytes, / MT.REC: .ASCII /XXXXXXXXX cards ***/ MT.LEN= .-MT.MSG .SBTTL FCS INPUT AND OUTPUT FILE SPECIFICATIONS ;----------------------------------------------------------------------; ; ; ; ; ; FCS INPUT AND OUTPUT FILE SPECIFICATIONS ; ; ; ; ; ;----------------------------------------------------------------------; ; DEFINE DATA STRUCTURES NECESSARY FOR INPUT FILE(S) ; ;----------------------------------------------------------------------; .EVEN FDBRD: FDBDF$ ; DEFINE FILE DESCRIPTOR BLOCK ;----------------------------------------------------------------------; ; DEFINE DATA STRUCTURES NECESSARY FOR OUTPUT FILE ; ;----------------------------------------------------------------------; FDBWT: FDBDF$ ; DEFINE FILE DESCRIPTOR BLOCK .SBTTL TRD - MAIN PROGRAM INITIALIZATION ;----------------------------------------------------------------------; ; ; ; ; ; ; ; TRD - MAIN PROGRAM INITIALIZATION ; ; ; ; ; ; ; ;----------------------------------------------------------------------; ; INITIALIZE FILE SYSTEM PROCESSING ; ;----------------------------------------------------------------------; .PSECT TRD .EVEN START: FINIT$ ; INITIALIZE FILE SYSTEM PROCESSING PRINT #ID.MSG,#ID.LEN,#60 ; PRINT INITIALIZATION MESSAGE .SBTTL GET A COMMAND LINE FROM THE USER ;----------------------------------------------------------------------; ; ; ; ; ; GET A COMMAND LINE FROM THE USER ; ; ; ; ; ;----------------------------------------------------------------------; ; ZERO OUT STATISTICS COUNTERS (TOTALS) ; ;----------------------------------------------------------------------; GETCMD: CLRL FT.NUM ; ZERO TOTAL FILE COUNT CLRL FT.BLK ; ZERO NUMBER OF BLOCKS READ CLRL FT.BYT ; ZERO NUMBER OF BYTES READ/WRITTEN CLRL FT.REC ; ZERO NUMBER OF RECORDS WRITTEN ;----------------------------------------------------------------------; ; USE MCR INTERFACE TO GET USER COMMAND ; ;----------------------------------------------------------------------; GCML$ #GETMCR ; GET MCR COMMAND LINE TSTB GETMCR+G.ERR ; ANY ERROR? BEQ PARSE ; NO, PARSE COMMAND LINE ;----------------------------------------------------------------------; ; ERROR IN GETTING COMMAND: EITHER EOF OR SOME FATAL ERROR ; ;----------------------------------------------------------------------; CMPB GETMCR+G.ERR,#GE.EOF ; END-OF-FILE IN INPUT? BNE 10$ ; NO, SOME FATAL GCML ERROR JMP EXIT ; YES, EXIT TASK 10$: ERROR GETMCR+G.ERR ; INFORM USER OF FATAL ERROR .SBTTL PARSE USER COMMAND STRING ;----------------------------------------------------------------------; ; ; ; ; ; PARSE USER COMMAND STRING ; ; ; ; ; ;----------------------------------------------------------------------; ; USE COMMAND SYNTAX ANALYZER TO ANALYZE USER COMMAND STRING ; ;----------------------------------------------------------------------; PARSE: CSI$1 #CSIBLK,GETMCR+G.CMLD+2,GETMCR+G.CMLD BCC PRSOUT ; IF NO ERROR, THEN OPEN OUTPUT FILE ERROR ; INFORM USER OF ERROR .SBTTL PARSE AND OPEN OUTPUT FILE ;----------------------------------------------------------------------; ; ; ; ; ; PARSE AND OPEN OUTPUT FILE ; ; ; ; ; ;----------------------------------------------------------------------; ; PARSE FIRST (ONLY) OUTPUT FILE SPECIFICATION ; ;----------------------------------------------------------------------; PRSOUT: CSI$2 #CSIBLK,OUTPUT ; GET NAME OF OUTPUT FILE BCC 10$ ; BRANCH ON NO ERROR ERROR ; INFORM USER OF COMMAND ERROR ;----------------------------------------------------------------------; ; OPEN OUTPUT FILE ON DISK ; ;----------------------------------------------------------------------; ; INITIALIZE FILE ATTRIBUTES SECTION OF FDB ; ; ; ; FDAT$R FDB,RTYP,RATT,RSIZ,CNTG,ALOC ; ;----------------------------------------------------------------------; 10$: FDAT$R #FDBWT,#R.VAR,#FD.CR ; SPECIFY VARIABLE LENGTH RECORDS + CRLF OPEN$W #FDBWT,#WTLUN,#CSIBLK+C.DSDS BCC 20$ ; BRANCH ON NO OPEN ERROR ERROR FDBWT+F.ERR ; INFORM USER OF OUTPUT FILE ERROR ;----------------------------------------------------------------------; ; INITIALIZE THE CSI STATUS FLAG TO INDICATE MORE INPUT FILES ; ;----------------------------------------------------------------------; 20$: BISB #CS.MOR,CSIBLK+C.STAT ; INDICATE "MORE" INPUT FILES .SBTTL PARSE NEXT INPUT FILE SPECIFICATION ;----------------------------------------------------------------------; ; ; ; ; ; PARSE NEXT INPUT FILE SPECIFICATION ; ; ; ; ; ;----------------------------------------------------------------------; ; DETERMINE IF THERE ARE MORE INPUT FILES TO PROCESS ; ;----------------------------------------------------------------------; NXTFIL: BITB #CS.MOR,CSIBLK+C.STAT ; MORE INPUT FILES? BNE 20$ ; YES, CONTINUE PROCESSING ;----------------------------------------------------------------------; ; NO MORE FILES TO PROCESS - CLOSE OUTPUT FILE AND RESTART ; ;----------------------------------------------------------------------; CLOSE$ #FDBWT ; CLOSE OUTPUT FILE BCC 10$ ; BRANCH ON NO FILE CLOSE ERROR ERROR F.ERR(R0) ; INFORM USER OF FILE CLOSE ERROR ;----------------------------------------------------------------------; ; REPORT TOTAL FILE STATISTICS AND GET NEXT COMMAND ; ;----------------------------------------------------------------------; 10$: CALL RPTALL ; NO, REPORT TOTAL FILE STATISTICS JMP GETCMD ; AND GET NEXT USER COMMAND ;----------------------------------------------------------------------; ; ; ; INCREMENT FILE COUNTER AND ZERO INPUT FILE STATISTICS COUNTERS ; ; ; ;----------------------------------------------------------------------; 20$: INC FT.NUM ; INCREMENT FILE COUNTER (TOTAL) CLRL FI.BLK ; ZERO INPUT FILE BLOCK COUNTER CLRL FI.BYT ; ZERO INPUT FILE BYTE COUNTER CLRL FI.REC ; ZERO INPUT FILE RECORD (CARD) COUNTER CLRL FI.RSZ ; ZERO LARGEST RECORD READ COUNTER MOV #077777,FI.RSS ; ZERO SMALLEST RECORD READ COUNTER CLRL FI.RSL ; ZERO LAST RECORD SIZE COUNTER CLRL FI.SUM ; ZERO FILE CHECKSUM ;----------------------------------------------------------------------; ; INITIALIZE I/O EVENT FLAGS AND INPUT BUFFER ADDRESS POINTERS ; ;----------------------------------------------------------------------; SETF$S #MTFLAG ; RESET INPUT I/O EVENT FLAG MOV #RECBF1,R3 ; RESET INPUT BUFFER ADDRESS POINTER MOV R3,RECADR ; RESET INPUT BUFFER ADDRESS ;----------------------------------------------------------------------; ; PARSE NEXT INPUT FILE SPECIFICATION ; ;----------------------------------------------------------------------; ; CLEAR CSI DESCRIPTOR TABLE ENTRIES FOR DEVICE, UIC, FILENAME ; ;----------------------------------------------------------------------; CLR CSIBLK+C.DEVD ; CLEAR LENGTH OF DEVICE NAME CLR CSIBLK+C.DEVD+2 ; CLEAR ADDRESS OF DEVICE NAME CLR CSIBLK+C.DIRD ; CLEAR LENGTH OF DIRECTORY NAME CLR CSIBLK+C.DIRD+2 ; CLEAR ADDRESS OF DIRECTORY NAME CLR CSIBLK+C.FILD ; CLEAR LENGTH OF FILENAME CLR CSIBLK+C.FILD+2 ; CLEAR ADDRESS OF FILENAME ;----------------------------------------------------------------------; ; RESET READ ACCESS MODE AND GET NEXT INPUT TOKEN FROM CMD LINE ; ;----------------------------------------------------------------------; CLR QIOFLG ; CLEAR QIO FLAG - USE FCS SYSTEM MOV #CRDBUF,R4 ; RESET OUTPUT CARD POINTER CSI$2 #CSIBLK,INPUT,#CSISWD ; GET NAME OF NEXT INPUT FILE BCC 30$ ; IF NO ERROR THEN OPEN FILE CLOSE$ #FDBWT ; CLOSE OUTPUT FILE ERROR ; INFORM USER OF PARSE ERROR ;----------------------------------------------------------------------; ; ; ; OUTPUT END-OF-RECORD CARDS IF THE USER HAS REQUESTED THEM ; ; ; ;----------------------------------------------------------------------; ; PROCESS THE PRECEEDING END-OF-RECORD CARD ; ;----------------------------------------------------------------------; 30$: BIT #BORFLG,CSIMKW ; BEGINNING-OF-RECORD SPECIFIED? BEQ 40$ ; NO, CHECK FOR TRANSPARENCY PUT$ #FDBWT,#EORBUF,#CRDSIZ ; YES, OUTPUT END-OF-RECORD CARD BCC OPNFIL ; BRANCH ON NO WRITE ERROR ERROR FDBWT+F.ERR ; INFORM USER OF FILE WRITE ERROR ;----------------------------------------------------------------------; ; PROCESS THE PRECEEDING TRANSPARENT END-OF-RECORD CARD ; ;----------------------------------------------------------------------; 40$: BIT #TRPFLG,CSIMKW ; TRANSPARENT BEGINNING-OF-RECORD SPECIFIED? BEQ OPNFIL ; NO, OPEN INPUT FILE PUT$ #FDBWT,#TRPEOR,#CRDSIZ ; YES, OUTPUT END-OF-RECORD CARD (TR) BCC OPNFIL ; BRANCH ON NO WRITE ERROR ERROR FDBWT+F.ERR ; INFORM USER OF FILE WRITE ERROR .SBTTL OPEN NEXT INPUT FILE ;----------------------------------------------------------------------; ; ; ; ; ; OPEN NEXT INPUT FILE ; ; ; ; ; ;----------------------------------------------------------------------; ; CHECK TO INSURE THAT AN INPUT FILENAME IS PRESENT ; ; IF FILENAME IS MISSING, TRY TO USE QIO INTERFACE TO PROCESS ; ;----------------------------------------------------------------------; OPNFIL: BITB #CS.NMF,CSIBLK+C.STAT ; IS FILENAME PRESENT? BEQ 30$ ; NO, CHECK FOR DEVICE NAME ;----------------------------------------------------------------------; ; OPEN INPUT FILE FOR READ-ONLY ACCESS ; ;----------------------------------------------------------------------; OPEN$R #FDBRD,#RDLUN,#CSIBLK+C.DSDS,,#RECBF0,#RECSIZ BCS 20$ ; IF ERROR, THEN SIGNAL USER JMP COPY ; NO ERROR. COPY INPUT TO OUTPUT 20$: ERROR FDBRD+F.ERR ; INFORM USER OF INPUT FILE OPEN ERROR .SBTTL OPEN INPUT FILE (QIO) ;----------------------------------------------------------------------; ; ; ; ; ; OPEN INPUT FILE (QIO) ; ; ; ; ; ;----------------------------------------------------------------------; ; FILENAME IS MISSING. IS DEVICE SPECIFICATION PRESENT? ; ;----------------------------------------------------------------------; 30$: BITB #CS.DVF,CSIBLK+C.STAT ; IS DEVICE SPEC PRESENT? BNE 50$ ; YES, PROCESS USING QIO ;----------------------------------------------------------------------; ; NO DEVICE OR FILE SPECIFICATION. CLOSE OUTPUT AND RESTART. ; ;----------------------------------------------------------------------; CLOSE$ #FDBWT ; NO, CLOSE OUTPUT FILE BCC 40$ ; BRANCH ON NO FILE CLOSE ERROR ERROR F.ERR(R0) ; INFORM USER OF FILE CLOSE ERROR ;----------------------------------------------------------------------; ; REPORT TOTAL FILE STATISTICS AND GET NEXT COMMAND ; ;----------------------------------------------------------------------; 40$: CALL RPTALL ; REPORT TOTAL FILE STATISTICS JMP GETCMD ; AND GET NEXT USER COMMAND ;----------------------------------------------------------------------; ; QIO PROCESSING: ASSIGN LUN AND ATTACH DEVICE ; ;----------------------------------------------------------------------; ; FETCH THE TWO CHARACTER DEVICE NAME AND SAVE IT TO ASSIGN LUN ; ;----------------------------------------------------------------------; 50$: MOV #-1,QIOFLG ; SET QIO PROCESSING "TRUE" MOV CSIBLK+C.DEVD+2,R0 ; GET ADDRESS OF DEVICE NAME STRING MOVB 0(R0),ALUN+A.LUNA+0 ; SET FIRST BYTE OF NAME MOVB 1(R0),ALUN+A.LUNA+1 ; SET SECOND BYTE OF NAME DIR$ #ALUN ; ASSIGN LUN BCC 60$ ; BRANCH ON NO ERROR ERROR $DSW ; SIGNAL DIRECTIVE ERROR TO USER ;----------------------------------------------------------------------; ; ATTACH DEVICE FOR EXCLUSIVE USE AND CHECK RETURN STATUS ; ;----------------------------------------------------------------------; 60$: QIOW$S #IO.ATT,#MTLUN,#MTFLAG,,#IOSTAT ; ATTACH DEVICE BCC 70$ ; CHECK I/O COMPLETION IF NO DIRECTIVE ERROR ERROR $DSW ; SIGNAL DIRECTIVE ERROR TO USER 70$: CMPB #IS.SUC,IOSTAT ; NORMAL SUCCESSFUL COMPLETION? BEQ 80$ ; YES, COPY INPUT FILE TO OUTPUT FILE ERROR IOSTAT ; NO, SIGNAL QIO ERROR TO USER ;----------------------------------------------------------------------; ; QUEUE FIRST INPUT BUFFER FROM DEVICE ; ;----------------------------------------------------------------------; ; THIS INITIAL QIO OPERATION IS USED TO "PRIME" THE INPUT PUMP ; ;----------------------------------------------------------------------; 80$: QIOW$S #IO.RLB,#MTLUN,#MTFLAG,,#IOSTAT,,<#RECBF0,#RECSIZ> BCC 90$ ; BRANCH ON NO DIRECTIVE ERROR ERROR $DSW ; SIGNAL DIRECTIVE ERROR TO USER ;----------------------------------------------------------------------; ; CHECK FOR SUCCESSFUL COMPLETION OF READ ; ;----------------------------------------------------------------------; 90$: CMPB #IS.SUC,IOSTAT ; NORMAL SUCCESSFUL COMPLETION? BEQ ANSI ; YES, PROCESS ANSI TAPE LABELS ERROR IOSTAT ; NO, INFORM USER OF FATAL READ ERROR .SBTTL ANSI TAPE LABEL PROCESSING ;----------------------------------------------------------------------; ; ; ; ; ; ANSI TAPE LABEL PROCESSING ; ; ; ; ; ;----------------------------------------------------------------------; ; IF THE USER HAS SPECIFIED UNLABELED TAPE PROCESSING, SKIP ANSI ; ;----------------------------------------------------------------------; ANSI: BIT #UNLFLG,CSIMKW ; UNLABELED TAPE PROCESSING? BNE 10$ ; YES, PROCESS ALL TAPE DATA INCLUDING LABEL ;----------------------------------------------------------------------; ; CHECK TO SEE IF FIRST TAPE RECORD IS OF PROPER LENGTH ; ;----------------------------------------------------------------------; CMP #AN.LEN,BYTCNT ; IS RECORD BYTE COUNT CORRECT FOR ANSI LABEL? BNE 10$ ; NO, TREAT TAPE AS IF IT WERE UNLABELED ;----------------------------------------------------------------------; ; INSURE THAT VOLUME LABEL RECORD IS OF THE PROPER FORMAT ; ;----------------------------------------------------------------------; MOV #RECBF0,R0 ; GET ADDRESS OF INPUT BUFFER CMPB #AN.LI0,(R0)+ ; IS THIS AN ANSI TAPE VOLUME LABEL? BNE 10$ ; CHARACTER STRING MISMATCH - ASSUME UNLABELED CMPB #AN.LI1,(R0)+ ; DOES SECOND CHARACTER MATCH? BNE 10$ ; CHARACTER STRING MISMATCH - ASSUME UNLABELED CMPB #AN.LI2,(R0)+ ; DOES THIRD CHARACTER MATCH? BNE 10$ ; CHARACTER STRING MISMATCH - ASSUME UNLABELED CMPB #AN.LI3,(R0)+ ; DOES LABEL NUMBER MATCH? BEQ 20$ ; YES, PERFORM ANSI TAPE LABEL PROCESSING ;----------------------------------------------------------------------; ; INVALID ANSI TAPE LABEL FORMAT - ASSUME TAPE IS UNLABELED ; ;----------------------------------------------------------------------; 10$: JMP COPY ; COPY INPUT BUFFER TO OUTPUT FILE ;----------------------------------------------------------------------; ; ; ; SKIP ANSI TAPE LABEL AND READ FIRST RECORD OF SECOND FILE ; ; ; ;----------------------------------------------------------------------; ; INFORM USER THAT THE ANSI MAGNETIC TAPE LABEL WILL BE SKIPPED ; ;----------------------------------------------------------------------; 20$: PRINT #MA.MSG,#MA.LEN,#60 ; INFORM USER OF ANSI TAPE LABEL ;----------------------------------------------------------------------; ; ISSUE TAPE SPACE FORWARD COMMAND TO SKIP TO NEXT FILE ON TAPE ; ;----------------------------------------------------------------------; QIOW$S #IO.SPF,#MTLUN,#MTFLAG,,#IOSTAT,,<#1> BCC 30$ ; BRANCH ON NO DIRECTIVE ERROR ERROR $DSW ; SIGNAL DIRECTIVE EXECUTION ERROR ;----------------------------------------------------------------------; ; CHECK FOR SUCCESSFUL COMPLETION OF THE TAPE POSITION COMMAND ; ;----------------------------------------------------------------------; 30$: CMPB #IS.SUC,IOSTAT ; NORMAL SUCCESSFUL COMPLETION? BEQ 40$ ; YES, CONTINUE PROCESSING ERROR IOSTAT ; NO, INFORM USER OF FATAL FILE POSITION ERROR ;----------------------------------------------------------------------; ; QUEUE FIRST INPUT BUFFER FROM DEVICE ; ;----------------------------------------------------------------------; ; THIS INITIAL QIO OPERATION IS USED TO "PRIME" THE INPUT PUMP ; ;----------------------------------------------------------------------; 40$: QIO$S #IO.RLB,#MTLUN,#MTFLAG,,#IOSTAT,,<#RECBF0,#RECSIZ> BCC COPY ; COPY INPUT BUFFER IF NO DIRECTIVE ERROR ERROR $DSW ; SIGNAL DIRECTIVE ERROR TO USER .SBTTL TRANSFER INPUT FILE TO OUTPUT FILE ;----------------------------------------------------------------------; ; ; ; ; ; TRANSFER INPUT FILE TO OUTPUT FILE ; ; ; ; ; ;----------------------------------------------------------------------; ; READ A RECORD FROM INPUT AND TRANSFER TO OUTPUT ; ;----------------------------------------------------------------------; ; NOTE THE FOLLOWING REGISTER CONVENTIONS: ; ; ; ; R2 = NUMBER OF BYTES READ IN INPUT BUFFER ; ; R3 = POINTER INTO THE INPUT BUFFER (RECBUF) ; ; R4 = POINTER INTO THE OUTPUT BUFFER (CRDBUF) ; ; R5 = CURRENT POINTER TO NEXT OUTPUT BUFFER ; ; R5 = ERROR INDEX + RETURN STATUS PRIOR TO TRAP 4 ABORT ; ;----------------------------------------------------------------------; ; RESET INPUT BUFFER POINTER AND CONTINUE INPUT PROCESSING ; ;----------------------------------------------------------------------; COPY: MOV RECADR,R5 ; SAVE CURRENT WORKING INPUT BUFFER ADDRESS MOV #RECBF0,R3 ; RESET INPUT BUFFER ADDRESS CMP R3,RECADR ; IS THIS THE CURRENT INPUT BUFFER? BNE 10$ ; NO, BUFFER POINTER SWITCH COMPLETE MOV #RECBF1,R3 ; YES, USE ALTERNATE INPUT BUFFER 10$: MOV R3,RECADR ; SAVE INPUT BUFFER ADDRESS ;----------------------------------------------------------------------; ; TEST FOR TYPE OF COPY TO BE PERFORMED: QIO OR FCS ; ;----------------------------------------------------------------------; CPYTST: TST QIOFLG ; IS THIS A QIO TRANSFER? BNE GETQIO ; YES, USE QIO INTERFACE JMP GETFCS ; NO, USE FCS INTERFACE .SBTTL READ A RECORD USING QIO INTERFACE ;----------------------------------------------------------------------; ; ; ; ; ; READ A RECORD USING QIO INTERFACE ; ; ; ; ; ;----------------------------------------------------------------------; ; READ A RECORD AND CHECK FOR SUCCESSFUL DIRECTIVE COMPLETION ; ;----------------------------------------------------------------------; GETQIO: WTSE$S #MTFLAG ; WAIT FOR LAST INPUT OPERATION TO COMPLETE MOV BYTCNT,R2 ; GET NUMBER OF BYTES READ ;----------------------------------------------------------------------; ; CHECK FOR SUCCESSFUL COMPLETION OF READ OR END-OF-FILE ; ;----------------------------------------------------------------------; CMPB #IS.SUC,IOSTAT ; NORMAL SUCCESSFUL COMPLETION? BNE 100$ ; NO, CHECK FOR END-OF-FILE OR END-OF-VOLUME BIC #EOFFLG,CSIMKW ; RESET END-OF-FILE DETECTOR FLAG ;----------------------------------------------------------------------; ; QUEUE NEXT INPUT RECORD AND CHECK FOR SUCCESSFUL DIRECTIVE ; ;----------------------------------------------------------------------; QIO$S #IO.RLB,#MTLUN,#MTFLAG,,#IOSTAT,, BCC 10$ ; BRANCH IF NO DIRECTIVE ERROR ERROR $DSW ; SIGNAL DIRECTIVE ERROR TO USER ;----------------------------------------------------------------------; ; LOAD CURRENT RECORD SIZE AND FIND LARGEST RECORD SIZE ; ;----------------------------------------------------------------------; 10$: MOV R2,FI.RSL ; LOAD LAST RECORD READ SIZE CMP R2,FI.RSZ ; IS THIS LARGER THAN LARGEST RECORD? BLE 20$ ; NO, DO NOT MODIFY LARGEST RECORD SIZE MOV R2,FI.RSZ ; YES, THIS IS NEW LARGEST RECORD SIZE ;----------------------------------------------------------------------; ; FIND SMALLEST RECORD SIZE ; ;----------------------------------------------------------------------; 20$: CMP R2,FI.RSS ; IS THIS SMALLER THAN SMALLEST RECORD? BGT 30$ ; NO, DO NOT MODIFY SMALLEST RECORD SIZE MOV R2,FI.RSS ; YES, THIS IS NEW SMALLEST RECORD SIZE BEQ GETQIO ; IF ZERO LENGTH QIO RECORD, IGNORE IT 30$: JMP PUTREC ; WRITE A SINGLE RECORD ;----------------------------------------------------------------------; ; ; ; ; ; QIO COMPLETION STATUS WAS NOT NORMAL - CHECK FOR ERRORS ; ; ; ; ; ;----------------------------------------------------------------------; ; CHECK FOR END-OF-FILE AND END-OF-VOLUME STATUS RETURNS ; ;----------------------------------------------------------------------; 100$: CMPB #IE.EOF,IOSTAT ; END-OF-FILE? BEQ 110$ ; YES, PROCESS LAST RECORD ERROR IOSTAT ; NO, INFORM USER OF FATAL READ ERROR ;----------------------------------------------------------------------; ; ; ; FLUSH LAST RECORD BUFFER AND ISSUE CHECKSUM+EOR RECORDS ; ; ; ;----------------------------------------------------------------------; 110$: CALL LSTREC ; DO LAST RECORD PROCESSING BIT #EOFFLG,CSIMKW ; END-OF-VOLUME (DOUBLE EOF) DETECTED? BNE 130$ ; YES, SKIP TO PROCESS TAPE REWINDS CALL CHKSUM ; PERFORM CHECKSUM OUTPUT ;----------------------------------------------------------------------; ; IGNORE END-OF-FILE MARKS IF END-OF-VOLUME SWITCH ENABLED ; ;----------------------------------------------------------------------; BIT #EOVFLG,CSIMKW ; IGNORE END-OF-FILE MARKS? BEQ 130$ ; NO, CHECK FOR REWIND FLAG QIO$S #IO.RLB,#MTLUN,#MTFLAG,,#IOSTAT,, BCC 120$ ; BRANCH ON NO DIRECTIVE ERROR ERROR $DSW ; SIGNAL DIRECTIVE EXECUTION ERROR TO USER 120$: BIS #EOFFLG,CSIMKW ; INDICATE THAT ONE EOF HAS BEEN READ JMP COPY ; COPY NEXT INPUT BUFFER FROM TAPE ;----------------------------------------------------------------------; ; MAG TAPE PROCESSING COMPLETE - REWIND TAPE DRIVE IF SELECTED ; ;----------------------------------------------------------------------; 130$: BIT #REWFLG,CSIMKW ; HAS USER SPECIFIED REWIND ON COMPLETION? BEQ 140$ ; NO, SKIP MAG TAPE REWIND CODE QIO$S #IO.RWU,#MTLUN,#MTFLAG,,#IOSTAT ; REWIND MAG TAPE - DO NOT WAIT BCC 140$ ; BRANCH ON NO ERROR ERROR $DSW ; SIGNAL DIRECTIVE ERROR TO USER ;----------------------------------------------------------------------; ; MAG TAPE PROCESSING COMPLETE - DETACH DEVICE ; ;----------------------------------------------------------------------; 140$: QIOW$S #IO.DET,#MTLUN,#MTFLAG,,#IOSTAT ; DETACH MAG TAPE - WAIT BCC 150$ ; BRANCH IF NO ERROR DETACHING DEVICE ERROR $DSW ; SIGNAL DIRECTIVE ERROR TO USER ;----------------------------------------------------------------------; ; INSURE DEVICE IS DETACHED BY CHECKING I/O COMPLETION STATUS ; ;----------------------------------------------------------------------; 150$: CMPB #IS.SUC,IOSTAT ; NORMAL SUCCESSFUL COMPLETION? BEQ 160$ ; YES, REPORT ON INPUT FILE ERROR IOSTAT ; NO, INFORM USER OF QIO DETACH ERROR ;----------------------------------------------------------------------; ; REPORT ON TRANSFER COUNT FROM TAPE AND PROCESS NEXT INPUT FILE ; ;----------------------------------------------------------------------; 160$: CALL RPTFIL ; REPORT ON INPUT FILE JMP NXTFIL ; SELECT NEXT INPUT FILE .SBTTL READ A RECORD USING FCS INTERFACE ;----------------------------------------------------------------------; ; ; ; ; ; READ A RECORD USING FCS INTERFACE ; ; ; ; ; ;----------------------------------------------------------------------; GETFCS: GET$ #FDBRD,RECADR,#RECSIZ ; READ A SINGLE RECORD MOV F.NRBD(R0),R2 ; GET NUMBER OF BYTES READ FROM INPUT BCS 20$ ; IF ERROR, THEN CHECK FOR EOF ;----------------------------------------------------------------------; ; LOAD CURRENT RECORD SIZE AND FIND LARGEST RECORD SIZE ; ;----------------------------------------------------------------------; MOV R2,FI.RSL ; LOAD LAST RECORD READ SIZE CMP R2,FI.RSZ ; IS THIS LARGER THAN LARGEST RECORD? BLE 10$ ; NO, DO NOT MODIFY LARGEST RECORD SIZE MOV R2,FI.RSZ ; YES, THIS IS NEW LARGEST RECORD SIZE ;----------------------------------------------------------------------; ; FIND SMALLEST RECORD SIZE ; ;----------------------------------------------------------------------; 10$: CMP R2,FI.RSS ; IS THIS SMALLER THAN SMALLEST RECORD? BGT PUTREC ; NO, DO NOT MODIFY SMALLEST RECORD SIZE MOV R2,FI.RSS ; YES, THIS IS NEW SMALLEST RECORD SIZE BNE PUTREC ; WRITE THIS BLOCK TO OUTPUT FILE ;----------------------------------------------------------------------; ; ZERO LENGTH INPUT RECORD - FLUSH CARD BUFFER AND OUTPUT BLANKS ; ;----------------------------------------------------------------------; CALL LSTREC ; DO LAST CARD PROCESSING CALL PADREC ; PAD ZERO LENGTH CARD WITH BLANKS JMP COPY ; GET ANOTHER INPUT BUFFER ;----------------------------------------------------------------------; ; A READ ERROR HAS OCCURRED - CHECK FOR END-OF-FILE ; ;----------------------------------------------------------------------; 20$: CMPB #IE.EOF,F.ERR(R0) ; END-OF-FILE? BEQ 30$ ; YES, PROCESS NEXT FILE ERROR F.ERR(R0) ; NO, INFORM USER OF INPUT READ ERROR ;----------------------------------------------------------------------; ; END-OF-FILE FOR FCS PROCESSING: CLOSE INPUT FILE ; ;----------------------------------------------------------------------; 30$: CALL LSTREC ; PERFORM LAST RECORD PROCESSING CLOSE$ #FDBRD ; CLOSE INPUT FILE BCC 40$ ; BRANCH ON NO FILE CLOSE ERROR JMP RPTFIL ; REPORT ON INPUT FILE ERROR FDBRD+F.ERR ; INFORM USER OF FILE CLOSE ERROR ;----------------------------------------------------------------------; ; REPORT FILE STATISTICS AND SELECT NEXT INPUT FILE ; ;----------------------------------------------------------------------; 40$: CALL RPTFIL ; REPORT FILE STATISTICS CALL CHKSUM ; PERFORM CHECKSUM OUTPUT JMP NXTFIL ; SELECT NEXT INPUT FILE .SBTTL TRANSFER INPUT RECORD TO OUTPUT DISK FILE ;----------------------------------------------------------------------; ; ; ; ; ; TRANSFER INPUT RECORD TO OUTPUT DISK FILE ; ; ; ; ; ;----------------------------------------------------------------------; ; THE TRANSFER MECHANISM USED IN THIS PROGRAM IS INEFFICIENT ; ; BUT VERY SIMPLE IN DESIGN, IMPLEMENTATION, AND MODIFIABILITY. ; ; IT IS FOR THESE REASONS IT WAS CHOSEN OVER A FASTER, MORE ; ; COMPLEX DESIGN UTILIZING SINGLE LEVEL BUFFERING. ; ; ; ; NOTE THAT THE ASCII HEX CONVERSION ROUTINE WILL HAVE TO BE ; ; MODIFIED IF THE OUTPUT CARD SIZE IS ODD. ; ;----------------------------------------------------------------------; ; INCREMENT BLOCK COUNTERS ; ;----------------------------------------------------------------------; PUTREC: INCL FT.BLK ; INCREMENT BLOCK COUNTER (TOTAL) INCL FI.BLK ; INCREMENT BLOCK COUNTER (FILE) MOV R2,R5 ; GET LENGTH OF INPUT BUFFER ADD RECADR,R5 ; CALCULATE INPUT BUFFER LOGICAL LIMIT ;----------------------------------------------------------------------; ; TRANSFER A BYTE FROM INPUT BUFFER TO OUTPUT BUFFER ; ;----------------------------------------------------------------------; ; TRANSFORM DATA TO HEXADECIMAL FORMAT IF HEX SWITCH SPECIFIED ; ;----------------------------------------------------------------------; 10$: BIT #HEXFLG,CSIMKW ; HEX CONVERSION SPECIFIED? BEQ 20$ ; NO, USE NORMAL TRANSFER MOVB (R3)+,R0 ; GET LOW NIBBLE OF DATA BYTE BIC #177400,R0 ; CLEAR UPPER BYTE ADD R0,FI.SUM ; ADJUST FILE CHECKSUM MOV R0,R1 ; GET HIGH NIBBLE OF DATA BYTE ROR R1 ; SHIFT TO GET AT HIGH NIBBLE ROR R1 ; ROR R1 ; ROR R1 ; BIC #177760,R1 ; MASK TO GET HIGH NIBBLE MOVB HEX(R1),(R4)+ ; TRANSFORM HIGH NIBBLE TO ASCII HEX BICB #177760,R0 ; MASK TO GET LOW NIBBLE MOVB HEX(R0),(R4)+ ; TRANSFORM LOW NIBBLE TO ASCII HEX BR 50$ ; CHECK FOR BUFFER OVERFLOW ;----------------------------------------------------------------------; ; CHECK FOR BINARY DATA TRANSFERS - DO NO CONVERSION ; ;----------------------------------------------------------------------; 20$: MOVB (R3)+,R0 ; GET 1 BYTE FROM INPUT BUFFER BIC #177400,R0 ; CLEAR UPPER BYTE ADD R0,FI.SUM ; ADJUST FILE CHECKSUM BIT #BINFLG,CSIMKW ; BINARY DATA TRANSFER? BNE 40$ ; YES, DO NO DATA CONVERSION ;----------------------------------------------------------------------; ; CHECK FOR ASCII DATA TRANSFERS - CONVERT FROM ASCII TO EBCDIC ; ;----------------------------------------------------------------------; BIT #ASCFLG,CSIMKW ; ASCII DATA TRANSFER? BEQ 30$ ; NO, CONVERT DATA TO EBCDIC MOVB ASCII(R0),R0 ; CONVERT EBCDIC TO ASCII BR 40$ ; STORE RESULT ;----------------------------------------------------------------------; ; NORMAL DATA TRANSFER - CONVERT ASCII TO EBCDIC ; ;----------------------------------------------------------------------; 30$: BIC #177600,R0 ; STRIP OFF ALL BUT LOWER 7 BITS MOVB EBCDIC(R0),R0 ; CONVERT ASCII TO EBCDIC ;----------------------------------------------------------------------; ; OUTPUT TRANSLATED BYTE AND CHECK FOR END OF OUTPUT BUFFER ; ;----------------------------------------------------------------------; 40$: MOVB R0,(R4)+ ; MOVE 1 TRANSLATED BYTE TO OUTPUT BUFFER 50$: CMP #CRDEND,R4 ; END OF OUTPUT CARD BUFFER? BNE 70$ ; NO, CHECK FOR END OF INPUT BUFFER ;----------------------------------------------------------------------; ; INCREMENT RECORD COUNTERS AND ADJUST BYTE COUNTERS ; ;----------------------------------------------------------------------; INCL FT.REC ; INCREMENT RECORD COUNTER (TOTAL) INCL FI.REC ; INCREMENT RECORD COUNTER (FILE) ADDL #CRDSIZ,FT.BYT ; INCREMENT BYTE COUNTER (TOTAL) ADDL #CRDSIZ,FI.BYT ; INCREMENT BYTE COUNTER (FILE) ;----------------------------------------------------------------------; ; A FULL OUTPUT CARD IMAGE HAS BEEN FORMED - WRITE IT TO DISK ; ;----------------------------------------------------------------------; PUT$ #FDBWT,#CRDBUF,#CRDSIZ ; WRITE A SINGLE RECORD BCC 60$ ; BRANCH IF NO WRITE ERROR ENCOUNTERED ERROR FDBWT+F.ERR ; INFORM USER OF FILE WRITE ERROR 60$: MOV #CRDBUF,R4 ; RESET OUTPUT BUFFER POINTER ;----------------------------------------------------------------------; ; CHECK FOR END OF INPUT BUFFER ; ;----------------------------------------------------------------------; 70$: CMP R5,R3 ; END OF INPUT MAG TAPE BUFFER? BNE 10$ ; NO, CONTINUE TRANSFER ;----------------------------------------------------------------------; ; IF INPUT RECORD LENGTH IS LESS THAN A FULL OUTPUT RECORD, PAD ; ; WITH BLANKS TO FILL TO A FULL OUTPUT RECORD ; ;----------------------------------------------------------------------; CMP #CRDSIZ,R2 ; INPUT BUFFER GREATER THAN A FULL CARD? BLE 80$ ; YES, GET ANOTHER INPUT BUFFER CALL LSTREC ; PAD RECORD WITH BLANKS AND OUTPUT 80$: JMP COPY ; READ ANOTHER INPUT BUFFER .SBTTL LAST RECORD (SHORT RECORD) PROCESSING ;----------------------------------------------------------------------; ; ; ; ; ; LAST RECORD (SHORT RECORD) PROCESSING ; ; ; ; ; ;----------------------------------------------------------------------; ; THIS SUBROUTINE PROCESSES THE LAST RECORD OR SHORT RECORDS ; ; FROM THE INPUT STREAM. ; ; ; ; NOTE THAT SHORT RECORDS ARE PADDED WITH BLANKS TO A FULL CARD. ; ;----------------------------------------------------------------------; ; CHECK IF ANYTHING WAS LEFT FROM THE LAST LARGE BLOCK READ ; ;----------------------------------------------------------------------; LSTREC: CMP #CRDBUF,R4 ; IS THERE ANYTHING IN THE LAST BUFFER? BNE 10$ ; YES, PAD REST OF BUFFER AND WRITE RECORD RETURN ; RETURN WITH NO OUTPUT WRITTEN ;----------------------------------------------------------------------; ; INCREMENT RECORD COUNTERS AND ADJUST BYTE COUNTERS ; ;----------------------------------------------------------------------; 10$: PUSH R0 ; SAVE REGISTER R0 MOV R4,R0 ; GET CURRENT POINTER INTO OUTPUT BUFFER ADD #-CRDBUF,R0 ; REMOVE OFFSET FROM OUTPUT TO GET BYTE COUNT INCL FT.REC ; INCREMENT RECORD COUNTER (TOTAL) INCL FI.REC ; INCREMENT RECORD COUNTER (FILE) ADDL R0,FT.BYT ; INCREMENT BYTE COUNTER (TOTAL) ADDL R0,FI.BYT ; INCREMENT BYTE COUNTER (FILE) POP R0 ; RESTORE REGISTER R0 ;----------------------------------------------------------------------; ; SELECT PADDING CHARACTER - ASCII OR EBCDIC BLANK ; ;----------------------------------------------------------------------; PADREC: PUSH R0 ; SAVE REGISTER R0 MOV #ASCPAD,R0 ; ASSUME ASCII OUTPUT BIT #ASCFLG,CSIMKW ; EBCDIC TO ASCII CONVERSION SPECIFIED? BNE 10$ ; YES, USE ASCII BLANK MOV #BINPAD,R0 ; NO, USE EBCDIC BLANK ;----------------------------------------------------------------------; ; PAD REMAINDER OF DATA CARD WITH BLANKS ; ;----------------------------------------------------------------------; 10$: MOVB R0,(R4)+ ; PAD CARD WITH A BLANK CMP #CRDEND,R4 ; END OF OUTPUT CARD BUFFER? BNE 10$ ; NO, PAD ANOTHER BLANK ;----------------------------------------------------------------------; ; SOME DATA (SHORT BLOCK) NEEDS TO BE TRANSFERRED TO DISK FILE ; ;----------------------------------------------------------------------; PUT$ #FDBWT,#CRDBUF,#CRDSIZ ; WRITE A SINGLE RECORD (PADDED RECORD) BCC 20$ ; BRANCH IF NO WRITE ERROR ENCOUNTERED ERROR FDBWT+F.ERR ; INFORM USER OF FILE WRITE ERROR ;----------------------------------------------------------------------; ; RESET OUTPUT BUFFER POINTER, RESTORE REGISTERS, AND RETURN ; ;----------------------------------------------------------------------; 20$: MOV #CRDBUF,R4 ; RESET OUTPUT BUFFER POINTER POP R0 ; RESTORE REGISTER R0 RETURN ; RETURN WITH SHORT RECORDS PROCESSED .SBTTL PERFORM CHECKSUM ON OUTPUT FILE ;----------------------------------------------------------------------; ; ; ; ; ; PERFORM CHECKSUM ON OUTPUT FILE ; ; ; ; ; ;----------------------------------------------------------------------; ; THIS SUBROUTINE ADDS AN ADDITIONAL CDC RECORD TO THE OUTPUT ; ; DISK FILE WHICH CONTAINS A CDC /*EOR RECORD AND AN OCTAL ; ; CHECKSUM RECORD. ALL OUTPUT DATA IS IN EBCDIC. ; ;----------------------------------------------------------------------; CHKSUM: SAVREG ; SAVE REGISTERS R0-R5 BIT #CHKFLG!EORFLG,CSIMKW ; OUTPUT CHECKSUM OR EOR SELECTED? BEQ 30$ ; NO, SKIP CHECKSUM AND EOF OUTPUT ;----------------------------------------------------------------------; ; OUTPUT THE END-OF-RECORD CARD ; ;----------------------------------------------------------------------; PUT$ #FDBWT,#EORBUF,#CRDSIZ ; WRITE END-OF-RECORD TO OUTPUT FILE BCC 10$ ; BRANCH IF NO WRITE ERROR ERROR FDBWT+F.ERR ; INFORM USER OF FILE WRITE ERROR ;----------------------------------------------------------------------; ; CONVERT BINARY CHECKSUM TO EBCDIC OCTAL IF CHECKSUM SELECTED ; ;----------------------------------------------------------------------; 10$: BIT #CHKFLG,CSIMKW ; OUTPUT CHECKSUM SELECTED? BEQ 30$ ; NO, SKIP CHECKSUM OUTPUT CBOMG #CHKNUM,FI.SUM,#1 ; CONVERT CHECKSUM TO ASCII OCTAL MOV #5,R0 ; GET ADDRESS OF CHECKSUM RECORD 20$: MOVB CHKBUF(R0),R1 ; GET ASCII BYTE BIC #177400,R1 ; CLEAR UPPER BYTE MOVB EBCDIC(R1),CHKBUF(R0) ; CONVERT BYTE TO EBCDIC DEC R0 ; DECREMENT BYTE POINTER BGE 20$ ; CONTINUE CONVERSION IF .GT. ZERO ;----------------------------------------------------------------------; ; APPEND CHECKSUM RECORD TO OUTPUT FILE ; ;----------------------------------------------------------------------; PUT$ #FDBWT,#CHKBUF,#CRDSIZ ; APPEND CHECKSUM RECORD BCC 30$ ; BRANCH IF NO FILE WRITE ERROR ERROR FDBWT+F.ERR ; INFORM USER OF FILE WRITE ERROR ;----------------------------------------------------------------------; ; RESTORE REGISTERS AND RETURN TO CALLER ; ;----------------------------------------------------------------------; 30$: RSTREG ; RESTORE REGISTERS R0-R5 RETURN ; RETURN TO CALLER .SBTTL REPORT ON INPUT FILE TRANSFER AFTER EOF ;----------------------------------------------------------------------; ; ; ; ; ; REPORT ON INPUT FILE TRANSFER AFTER EOF ; ; ; ; ; ;----------------------------------------------------------------------; ; SET FILE, BLOCK, BYTE, AND OUTPUT RECORD COUNTER ASCII FIELDS ; ;----------------------------------------------------------------------; RPTFIL: SAVREG ; SAVE REGISTERS R0-R5 CBDMG #MI.NUM,FT.NUM,#0 ; SET FILE NUMBER CDDMG #MI.BLK,#FI.BLK,#0 ; SET BLOCK COUNTER CBDMG #MI.RSZ,FI.RSZ,#0 ; SET SIZE OF LARGEST RECORD READ CBDMG #MI.RSS,FI.RSS,#0 ; SET SIZE OF SMALLEST RECORD READ CBDMG #MI.LST,FI.RSL,#0 ; SET SIZE OF LAST RECORD READ CDDMG #MI.BYT,#FI.BYT,#0 ; SET BYTE COUNTER CDDMG #MI.REC,#FI.REC,#0 ; SET RECORD COUNTER ;----------------------------------------------------------------------; ; TRANSFER STATISTICS MESSAGE TO USER TERMINAL ; ;----------------------------------------------------------------------; PRINT #MI.MSG,#MI.LEN ; PRINT MESSAGE ;----------------------------------------------------------------------; ; RESTORE REGISTERS AND RETURN TO CALLER ; ;----------------------------------------------------------------------; RSTREG ; RESTORE REGISTERS R0-R5 RETURN ; RETURN TO MAINLINE CODE .SBTTL REPORT ON OUTPUT FILE TRANSFER TOTALS ;----------------------------------------------------------------------; ; ; ; ; ; REPORT ON OUTPUT FILE TRANSFER TOTALS ; ; ; ; ; ;----------------------------------------------------------------------; ; DO NO FILE TOTALS REPORTING IF ONLY 1 FILE SELECTED ; ;----------------------------------------------------------------------; RPTALL: SAVREG ; SAVE REGISTERS R0-R5 CMP #1,FT.NUM ; ONLY 1 FILE SELECTED? BEQ 10$ ; YES, DO NOT REPORT FILE TOTALS ;----------------------------------------------------------------------; ; SET BLOCK, BYTE, AND OUTPUT RECORD COUNTER ASCII FIELDS ; ;----------------------------------------------------------------------; CDDMG #MT.BLK,#FT.BLK,#0 ; SET BLOCK COUNTER TOTALS CDDMG #MT.BYT,#FT.BYT,#0 ; SET BYTE COUNTER TOTALS CDDMG #MT.REC,#FT.REC,#0 ; SET RECORD COUNTER TOTALS ;----------------------------------------------------------------------; ; TRANSFER STATISTICS MESSAGE TO USER TERMINAL ; ;----------------------------------------------------------------------; PRINT #MT.MSG,#MT.LEN,#60 ; PRINT MESSAGE (DOUBLE SPACE) ;----------------------------------------------------------------------; ; RESTORE REGISTERS AND RETURN TO CALLER ; ;----------------------------------------------------------------------; 10$: RSTREG ; RESTORE REGISTERS R0-R5 RETURN ; RETURN TO MAINLINE CODE .SBTTL PRINT MESSAGE TO USER TERMINAL ;----------------------------------------------------------------------; ; ; ; ; ; PRINT MESSAGE TO USER TERMINAL ; ; ; ; ; ;----------------------------------------------------------------------; ; THIS SUBROUTINE PRINTS A MESSAGE TO THE USER TERMINAL ; ;----------------------------------------------------------------------; ; REGISTER USEAGE: MS.PTR - ADDRESS OF USER MESSAGE ; ; MS.LEN - LENGTH OF USER MESSAGE ; ; MS.SPC - PRINT CARRIAGE CONTROL ; ;----------------------------------------------------------------------; ; QUEUE MESSAGE TO OPERATOR ; ;----------------------------------------------------------------------; $MSG:: QIOW$S #IO.WVB,#TILUN,#TIFLAG,,#TTSTAT,, BCC 10$ ; CHECK FOR ERRORS ERROR $DSW ; SIGNAL DIRECTIVE EXECUTION ERROR ;----------------------------------------------------------------------; ; CHECK FOR SUCCESSFUL I/O COMPLETION ; ;----------------------------------------------------------------------; 10$: CMPB #IS.SUC,TTSTAT ; NORMAL SUCCESSFUL COMPLETION? BEQ 20$ ; YES, OUTPUT TO SYSTEM CONSOLE ERROR TTSTAT ; NO, SIGNAL QIO ERROR TO USER ;----------------------------------------------------------------------; ; QUEUE MESSAGE TO SYSTEM CONSOLE IF LOGGING SWITCH ENABLED ; ;----------------------------------------------------------------------; 20$: BIT #LOGFLG,CSIMKW ; LOG TO SYSTEM CONSOLE? BEQ 30$ ; NO, SKIP CONSOLE LOGGING QIOW$S #IO.WBT,#TTLUN,#TTFLAG,,#TTSTAT,, BCC 30$ ; CHECK FOR ERRORS ERROR $DSW ; SIGNAL DIRECTIVE EXECUTION ERROR ;----------------------------------------------------------------------; ; RETURN TO USER - BREAK THROUGH WRITE DO NOT CHECK STATUS CODE ; ;----------------------------------------------------------------------; 30$: RETURN ; RETURN TO MAINLINE CODE .SBTTL TASK TERMINATION ;----------------------------------------------------------------------; ; ; ; TASK TERMINATION ; ; ; ;----------------------------------------------------------------------; EXIT: EXIT$S ; EXIT TASK .END START ; END OF MAIN PROGRAM