Trailing-Edge
-
PDP-10 Archives
-
BB-JF18A-BM
-
sources/rms/rmsio.b36
There are 6 other files named rmsio.b36 in the archive. Click here to see a list.
%TITLE 'R M S I O -- SEQ/REL I/O'
!<BLF/REQUIRE 'RMSBLF.REQ'>
MODULE rmsio (IDENT = '3.0'
) =
BEGIN
!+
!
! FUNCTION: THIS MODULE CONTAINS ROUTINES WHICH INTERFACE
! TO THE MONITOR TO PERFORM VARIOUS I/O FUNCTIONS
! FOR SEQUENTIAL AND RELATIVE FILES.
!
!
!
! COPYRIGHT (C) DIGITAL EQUIPMENT CORPORATION 1977, 1986.
! ALL RIGHTS RESERVED.
!
! THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND
! COPIED ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH
! THE INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR
! ANY OTHER COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE
! AVAILABLE TO ANY OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE
! SOFTWARE IS HEREBY TRANSFERRED.
!
! THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT
! NOTICE AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL
! EQUIPMENT CORPORATION.
!
! DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF
! ITS SOFTWARE ON EQUIPMENT THAT IS NOT SUPPLIED BY DIGITAL.
!
!
!
! AUTHOR: S. BLOUNT
!
!
! ********** TABLE OF CONTENTS **************
!
!
!
!
! ROUTINE FUNCTION
! ======= ========
!
! GTBYTE POSITION FILE TO A BYTE LOCATION
!
! GETWINDOW MAP IN A FILE PAGE
!
! MOVEREC TRANSFER A RECORD FROM/TO USER BUFFER
!
! NOSPAN CHECK A SEQUENTIAL FILE FOR PAGE OVERLAP
!
!
! NUMBERTORFA CONVERT A RECORD NUMBER TO A BYTE ADDRESS
!
! WRITEBUFFER OUTPUT A BUFFER FOR ASCII FILE
!
! READBUFFER INPUT A BUFFER FOR ASCII FILE
!
!
!
!
!
! REVISION HISTORY:
!
! EDIT DATE WHO PURPOSE
! ==== ==== === ========
!
! 1 8-JUL-76 /JK ADD READ AHEAD TO GETWINDOW AND MOVEREC
! 2 15-JUL-76 SEB MOVE SETPLOG TO RMSFIL
! 3 27-JUL-76 JK 'PUTBUF' HAS 4 ARGS, NOT 3!!!
! 4 27-JUL-76 JK 'GETWINDOW' SHOULD ALWAYS ASK FOR PMAPRD.
! 5 5-AUG-76 JK ADD NEW ASCII CHANGES.
! 6 7-FEB-77 SB TAKE OUT FSTHSZ
! 7 21-FEB-77 SB ADD ARG TO SINJSYS
! 8 14-MAR-77 SB ADD CHECK-BYTE AT END OF RECORD
! 9 5-PAR-77 SB TAKE OUT READ-AHEAD IN MOVEREC,
! MAKE NUMBERTORFA USE MRS, NOT RSZW
!
! *************************************************
! * *
! * NEW REVISION HISTORY *
! * *
! *************************************************
!
! PRODUCT MODULE SPR
! EDIT EDIT QAR DESCRIPTION
! ====== ====== ===== ===========
!
!
!
! ***** BEGIN VERSION 2 DEVELOPMENT *****
!
!
! PRODUCT MODULE SPR
! EDIT EDIT QAR DESCRIPTION
! ====== ====== ===== ===========
!
! 301 300 XXXXX SUPPORT EXTENDED ADDRESSING.
!
! 400 400 xxxxx Clean up BLISS code (RL, 22-Apr-83)
!
! 504 Image mode
! 570 Image mode fix
!
! ***** END OF REVISION HISTORY *****
!
!-
REQUIRE 'RMSREQ';
%SBTTL 'GTBYTE - position to next record'
GLOBAL ROUTINE gtbyte (rfa, abortflag) =
! GTBYTE
! ======
! THIS ROUTINE MAKES SURE THAT THE NEXT RECORD TO BE ACCESSED
! IS POSITIONED CORRECTLY WITHIN THE FILE WINDOW.
! THIS ROUTINE IS USED ONLY FOR SEQUENTIAL AND RELATIVE FILES.
! IT IS CALLED BY ALMOST ALL RMS-20 RECORD VERB PROCESSORS
! FOR SEQUENTIAL OR RELATIVE FILES. THIS ROUTINE IS NOT
! CALLED AT ALL TO PROCESS INDEXED FILES.
! ON INPUT, THE 'RECORD-FILE ADDRESS' (RFA) OF THE RECORD
! IS PASSED. ON OUTPUT, THE RECORD IS IN THE CURRENT BUCKET
! AND THE "PAGPTR" FIELD OF THE RST CONTAINS THE ADDRESS
! WITHIN THE WINDOW OF THE FIRST WORD OF THE RECORD
! HEADER.
!
! INPUT:
! RFA RFA OF TARGET RECORD
! ABORTFLAG FLAG TO DETERMINE IF PAGE EXISTS
! TRUE: ABORT IF NEXT PAGE IS NON-EXISTENT
! FALSE: DONT ABORT
! OUTPUT:
! TRUE: OK
! FALSE: ERROR
!
! ROUTINES USED:
! GETWINDOW
!
! NOTES:
!
! 1. THE FOLLOWING SYMBOLS ARE MACROS WHICH ARE DEFINED
! IN "RST.REQ". DO NOT CONFUSE THEM WITH LOCAL VARIABLES:
!
! CURRENTFILEPAGE
! CURRENTWINDOW
! CURENTBUFFERADR
!
! 2. THE RFA WHICH IS PASSED TO THIS ROUTINE IS ACTUALLY
! THE BYTE NUMBER OF THE STARTING ADDRESS OF THE TARGET
! RECORD. FOR SEQUENTIAL FILES, THIS BYTE NUMBER IS ALSO
! THE RFA, BUT FOR RELATIVE FILES, THE RFA (RECORD NUMBER)
! MUST BE CONVERTED INTO A BYTE NUMBER BEFORE THIS ROUTINE
! IS CALLED.
!
! 3. "ABORTFLAG" IS PASSED DIRECTLY TO GETWINDOW AND IS NOT
! USED BY THIS ROUTINE.
BEGIN
LOCAL
newpagptr,
arg1,
arg2,
arg3,
rfapagenum;
MAP
rfa : BLOCK [];
TRACE ('GTBYTE');
!+
! CHECK INPUT PARAMETERS
!-
checkinput (rfa, GEQ, 0); ! RFA MUST BE POSITIVE
checkinput (rfa, LSS, bitn (8)); ! AND ...
!+
! CHECK IF PAGE IS CURRENTLY IN WINDOW
!-
rfapagenum = .rfa [rfapage];
IF (.currentwindow EQL 0) ! THERE IS NO CURRENT BUCKET
OR (.currentfilepage NEQ .rfapagenum)
THEN
BEGIN
%( GET THE NEW PAGE )%
IF getwindow (%( PAGE NO. )%.rfapagenum, %( PAGE MUST EXIST )%.abortflag) EQL false
THEN
RETURN false ! BADRETURN IF PAGE DOESN'T EXIST
END;%( OF GET THE NEW PAGE )%
!+
! NOW, THE PAGE WE WANT IS IN OUR WINDOW .
! WE MUST SET UP A POINTER TO IT IN THE RST
!-
rst [rstpagptr] = (.curentbufferadr) + .rfa [ofset];
RETURN true; ! Return to caller
END;
%( OF GTBYTE )%
%SBTTL 'GETWINDOW - position page in window'
GLOBAL ROUTINE getwindow (fpage, abortf) =
! GETWINDOW
! ======
! THIS ROUTINE MAKES SURE THAT THE SPECIFIED FILE PAGE IS IN THE WINDOW.
! 'GETBKT' IS CALLED TO CHECK IF THE FILE PAGE IS ALREADY MAPPED INTO OUR
! PROCESS (OTHERWISE, THE FILE PAGE WILL BE MAPPED IN.) 'PUTBKT' WILL BE
! CALLED TO RELEASE THE BUFFER CONTAINING THE FILE PAGE WHICH IS CURRENTLY
! IN THE WINDOW.
!
! IF THE ABORT-FLAG IS ON, THEN A PRELIMINARY CHECK IS
! TO INSURE THAT THE TARGET FILE PAGE ACTAULLY EXISTS.
! IF THE PAGE DOES NOT EXIST, AN ERROR RETURN IS TAKEN.
! INPUT:
! FPAGE PAGE NO. OF FILE PAGE
! ABORTF FLAG TO DETERMINE IF PAGE EXISTS
! TRUE = PAGE MUST EXIST
! FALSE = PAGE DOESN'T HAVE TO EXIST
! OUTPUT:
! TRUE : OK
! FALSE: PAGE NON-EXISTENT
BEGIN
LOCAL
bpage,
bfdadr,
incore,
arg;
TRACE ('GETWINDOW ');%( CHECK INPUT PARAMETERS )%
checkinput (fpage, GEQ, 0); ! PAGE #'S ARE POSITIVE
checkinput (fpage, LSS, bitn (17)); ! 2**18 FILE PAGES
!+
! IF THERE IS A PAGE IN THE WINDOW, RELEASE IT
!-
IF NOT nullbd (cbd) THEN %(THERE IS A CURRENT BUCKET)%putbkt (%(NO UPDATE)%false, %(BKT DESC)%.cbd);
!+
! CHECK IF SPECIFIED FILE PAGE EXISTS (IF CALLER WANTS US TO)
!-
IF .abortf NEQ false
THEN
BEGIN
%( CHECK IF PAGE EXISTS )%
!+
! READ THE PAGE'S ACCESSIBILITY
!-
IF pagexist (.fst [fstjfn], .fpage) EQL false ! JFN + PAGE NO
THEN
RETURN false; ! Page non-existent
END;%( OF CHECK IF PAGE EXISTS )%
!+
! WE CAN NOW FETCH THE NEW BUCKET AND MAKE IT "CURRENT"
!-
IF getbkt (%(BKT NUM)%.fpage, %(SIZE)%seqbktsize, %(LOCK)%false, %(BD)%.cbd) EQL false
THEN
rmsbug (msgfailure);
RETURN true ! RETURN FROM GETWINDOW
END;
%( OF GETWINDOW )%
%SBTTL 'MOVEREC - move a record around'
GLOBAL ROUTINE moverec (windowptr, useradr, putflag, bytes, bytesize) =
! MOVEREC
! =======
! THIS ROUTINE TRANSFERS A RECORD FROM ONE PLACE TO ANOTHER.
! IT IS USED ON BOTH INPUT AND OUTPUT FOR SEQUENTIAL AND
! RELATIVE FILES. IT IS NOT CALLED FOR INDEXED FILES.
!
! ALL PAGE BOUNDARY PROBLEMS ARE HANDLED BY SWITCHING
! WINDOW PAGES. NO INDICATION IS GIVEN IF A NON-EXISTENT
! PAGE IS FOUND.
! INPUT:
! ADDRESS OF RECORD IN SYSTEM BUFFER
! ADDRESS OF USER BUFFER
! PUT-FLAG:
! TRUE : MOVE FROM USER TO WINDOW
! FALSE: MOVE FROM WINDOW TO USER
! # BYTES TO MOVE
! BYTE-SIZE OF RECORD
! OUTPUT:
! TRUE ALWAYS
!
! ROUTINES USED:
! GETWINDOW
! NOTES:
!
! 1. THE FOLLOWING SYMBOLS ARE MACROS WHICH ARE DEFINED
! IN "RST.REQ". DO NOT CONFUSE THEM WITH LOCAL VARIABLES:
!
! CURRENTFILEPAGE
! CURRENTWINDOW
! CURENTBUFFERADR
!
! 2. ON A $PUT OPERATION, THIS ROUTINE WILL MOVE FULL
! WORDS FROM THE USER'S BUFFER TO THE SYSTEM FILE
! BUFFER. ON A $GET, ONLY THE EXACT NUMBER OF BYTES
! IN THE RECORD ARE MOVED. THUS, THE USER'S BUFFER
! DOES NOT GET DESTROYED PAST THE END OF HIS RECORD.
BEGIN
LOCAL
wordcount, ! COUNTER OF WORDS TO MOVE
bytesword,
room, ! AMOUNT OF ROOM LEFT ON CURRENT PAGE
temp2,
extrabytes,
SOURCE,
dest,
buf2ptr : VECTOR [2]; !TWO-WORD BP IF NEEDED
REGISTER
temp;
TRACE ('MOVEREC');%( CHECK INPUT PARAMETERS )%
%IF dbug
%THEN
IF (.bytes LSS 0) OR (.bytesize LEQ 0) OR (.bytesize GTR 36) THEN rmsbug (msginput);
! BAD INPUT VALUES
%FI
bytesword = 36/.bytesize; ! FIND # OF BYTES IN WORD
wordcount = .bytes/.bytesword; ! # OF WORDS TO MOVE
extrabytes = .bytes - (.wordcount*.bytesword);
!+
! FOR A $PUT OPERATION, WE WILL MOVE THE RECORD BY USING
! A BLT INSTEAD OF A ILDB-IDPB LOOP. WHEN WE ARE LATER
! READING THE RECORD, WE MUST INSURE THAT WE DON'T MOVE
! THE EXTRA GARBAGE BYTES IN THE RECORD
!-
IF (.putflag)
THEN
IF (.extrabytes NEQ 0)
THEN
BEGIN
wordcount = .wordcount + 1; ! BUMP THE WORDCOUNT
extrabytes = 0 ! NO EXTRA BYTES
END;%( PRINT OUT THE RESULTS, SO FAR )%
lookat (' WORDCOUNT: ', wordcount);
lookat (' EXTRA: ', extrabytes);%([ LOOP FOR ALL FULL WORD MOVES...ONE LOOP FOR EACH PAGE
ONTO WHICH THE RECORD IS MOVED ])%
WHILE .wordcount NEQ 0 DO
BEGIN
!+
! COMPUTE HOW MUCH SPACE WE HAVE LEFT ON THIS PAGE
!-
room = (.curentbufferadr + pagesize) - .windowptr;
%IF dbug
%THEN
IF (.room LSS 0) OR (.room GTR pagesize) THEN rmsbug (msgcount);
IF .wordcount LSS 0 THEN rmsbug (msgcount); ! BAD VALUE FOR WORDCOUNT
%FI
!+
! WE MUST NOW CHECK TO SEE IF THE FILE PAGE IS COMPLETELY FULL
!-
IF .room EQL 0
THEN
%( WE MUST GET NEXT PAGE )%
BEGIN
temp = .currentfilepage + 1; ! GET # OF NEXT PAGE IN FILE
rtrace (%STRING (' SWITCHING PAGES...', %CHAR (13), %CHAR (10), ' '));
!+
! LOAD THE PAGE WE WANT RIGHT NOW.
!-
getwindow (%( PAGE NO. )%.temp, %( DON'T ABORT )%false);
windowptr = .curentbufferadr; ! RESET PTR TO START OF FILE BUFFER
room = pagesize ! AND AMOUNT LEFT
END;%( OF IF ROOM IS ZERO )%%( FIND THE LESSER OF RECORD SIZE, OR AMOUNT ON PAGE )%
IF .wordcount LSS .room THEN room = .wordcount;
!+
! ASSUME THAT THIS IS A $GET AND SET UP OUT POINTERS
!-
SOURCE = .windowptr; ! MOVE FROM FILE PAGE...
dest = .useradr; ! ...TO USER BUFFER
IF .putflag NEQ false %( MOVE FROM USER TO WINDOW )%
THEN
BEGIN
setbfdupd (cbd [bkdbfdadr]); !INDIC FILE PAGE UPD
SOURCE = .useradr; ! GET ADDRESS
dest = .windowptr ! AND DESTINATION
END;%( OF IF PUTFLAG IS TRUE )%
!+
! NOW, MOVE THIS RECORD SEGMENT FROM/TO USER BUFFER
!-
IF .rmssec NEQ 0
THEN
xcopy (%(FROM)%.SOURCE, %(TO)%.dest, %(SIZE)%.room)
ELSE
movewords (%(FROM)%.SOURCE, %(TO)%.dest, %(SIZE)%.room);
useradr = .useradr + .room; ! BUMP USER BUFFER POINTER
windowptr = .windowptr + .room; ! AND WINDOW POINTER
wordcount = .wordcount - .room
END;%( OF WHILE WORDCOUNT NEQ ZERO )%%([ WE HAVE NOW MOVED ALL FULL WORDS IN THE RECORD. WE MUST
THEN SEE IF THERE WERE ANY BYTES LEFT OVER TO MOVE ])%
IF .extrabytes EQL 0 THEN RETURN true; ! No extra bytes to move
!+
! FIRST, WE MUST CHECK TO SEE IF THESE LAST FEW BYTES
! WILL OVERLAP INTO THE NEXT PAGE OF THE FILE. IF SO,
! WE MUST MAP IN THE NEXT FILE PAGE AND MOVE THE BYTES
! IN THE NEW PAGE
!-
IF ((.curentbufferadr + pagesize) EQL .windowptr)
THEN
BEGIN
temp = (.currentfilepage + 1); ! GET # OF NEXT FILE PAGE
rtrace (%STRING (' CURRENT PAGE EXHAUSTED...', %CHAR (13), %CHAR (10), ' '));
IF getwindow (%( PAGE NO. )%.temp, %( DON'T ABORT )%false) EQL false THEN rmsbug (msgfailure);
windowptr = .curentbufferadr ! RESET ADDRESS
END;%( OF IF WINDOW IS EXHAUSTED )%
!+
! SET UP AN APPROPRIATE BYTE POINTER
!-
temp = .bytesize*.extrabytes; ! # OF BITS TO MOVE
temp = (.temp^6) + nullbp; ! FORM LH OF PTR
windowptr<lh> = .temp; !GET LOCAL BP TO WINDOW
IF .rmssec NEQ 0
THEN
BEGIN
buf2ptr [1] = .useradr;
buf2ptr<lh> = .temp OR %O'40'; !2-WORD BP
buf2ptr<rh> = 0;
ildb (temp, windowptr);
idpb (temp, buf2ptr)
END
ELSE
BEGIN
useradr<lh> = .temp; ! STORE IN POINTERS
ildb (temp, windowptr);
idpb (temp, useradr)
END;
RETURN true
END;
%( OF MOVEREC )%
%SBTTL 'NOSPAN - Calculate sequential NRP'
GLOBAL ROUTINE nospan (nrp) =
! NOSPAN
! ======
! THIS ROUTINE PERFORMS CALCULATION ON THE NRP
! OF A SEQUENTIAL FILE WHEN A RECORD IS TO BE WRITTEN.
! IF THE "BLOCKED" ATTRIBUTE ( FB$BLK) IS NOT
! DEFINED FOR THIS FILE, THIS ROUTINE IS NOT CALLED.
! ON INPUT TO THE ROUTINE, THE NRP IS PASSED AS AN ARGUMENT.
! THIS ROUTINE COMPUTES IF THE RECORD TO BE WRITTEN
! CAN FIT ON THE CURRENT PAGE. IF SO, THE NRP
! VALUE WHICH WAS PASSED TO THIS ROUTINE IS RETURNED
! UNCHANGED. IF NOT, IT RETURNS
! THE NEW VALUE OF THE NRP.
! IN THIS CASE, AN "END-OF-PAGE" MARKER WILL BE WRITTEN INTO
! THE FILE AT THE PLACE WHERE THIS RECORD WAS TO BE PLACED.
! INPUT:
! CURRENT NRP VALUE
! OUTPUT:
! UPDATED NRP
!
! GLOBALS USED:
! <NONE>
! NOTES:
!
! 1. THE FOLLOWING SYMBOLS ARE MACROS WHICH ARE DEFINED
! IN "RST.REQ". DO NOT CONFUSE THEM WITH LOCAL VARIABLES:
!
! CURRENTWINDOW
BEGIN
LOCAL
newnrp;
MAP
newnrp : BLOCK [1];
MAP
nrp : BLOCK [];
TRACE ('NOSPAN');
!+
! WE WILL NOW DEFINE A NEW BEGIN-END BLOCK IN ORDER
! TO REMAP NRP ONTO ANOTHER STRUCTURE LATER.
!-
BEGIN
%( A NEW BLOCK TO ALLOW RE-MAPPING OF NRP )%
!+
! COMPUTE AMOUNT OF SPACE REQUIRED FOR RECORD
!-
newnrp = .nrp + .rst [rstrszw] + headersize - 1; ! FIND END OF THIS RECORD
IF .newnrp [page] EQL .nrp [page] ! Check if it slops over to next page
THEN
RETURN .nrp;
!+
! WE NOW KNOW THAT THE NEXT RECORD TO BE WRITTEN
! CANNOT FIT ON THE CURRENT PAGE. SO, WE WILL
! BUMP THE NRP TO THE NEXT PAGE, AND STICK AN
! END-OF-PAGE MARKER AT THE END OF THIS PAGE
!-
newnrp = (.nrp OR ofsetmask) + 1; ! COMPUTE START OF NEXT PAGE
nrp [page] = .currentwindow; ! FORM ADDRESS OF PLACE TO PUT EOP
END;%( OF BEGIN BLOCK )%
BEGIN
%( A NEW BLOCK )%
MAP
nrp : REF BLOCK;
!+
! STORE THE END-OF-PAGE MARKER (-1) AT THE END
! OF THE LAST PAGE
!-
nrp [wholeword] = eopmarker; ! STORE MARKER
!+
! RETURN THE VALUE OF THE UPDATED POINTER TO THE
! NEXT PAGE
!-
RETURN .newnrp; ! RETURN THE NEW VALUE
END;
END;
%( OF NOSPAN )%
%SBTTL 'NUMBERTORFA - calculate relative record address'
GLOBAL ROUTINE numbertorfa (recnum) =
! NUMBERTORFA
! ===========
! THIS ROUTINE COMPUTES THE ABSOLUTE BYTE ADDRESS OF A RECORD
! IN A RELATIVE FILE. IT MUST COMPUTE THIS ADDRESS
! DEPENDING UPON WHETHER THE FILE HAS THE "BLK" ATTRIBUTE
! OR NOT.
! INPUT:
! RECNUM = RECORD NUMBER
! OUTPUT:
! NOT FALSE : RFA OF RECORD
! FALSE: BAD RECORD NUMBER
! GLOBALS USED:
! < NONE >
! USER ERRORS:
! BYTE NUMBER OF RECORD .GTR. FILE ADDRESS SPACE
BEGIN
LOCAL
startofdata, ! MOVING VALUE WHICH DENOTES THE START OF THE DATA WITHIN THE FILE
bytenum, ! BYTENUMBER OF RECORD
sizeofrecord, ! SIZE OF THE CURRENT RECORD
recsonanypage, ! NUMBER OF RECORDS ON ANY PAGE OF THE FILE
recsonpage0, ! NUMBER OF RECORDS ON THE FIRST FILE PAGE ( PAGE 0 )
temp;
MAP
recnum : BLOCK [];
TRACE ('NUMBERTORFA');
!+
! PRINT OUT THE INPUT VALUE
!-
lookat (' INPUT RECORD #: ', recnum);
!+
! COMPUTE THE TOTAL SIZE OF A RECORD IN THIS FILE
!-
sizeofrecord = sizeinwords (.fst [fstmrs], .fst [fstbsz]) + headersize;
! COMPUTE TOTAL LENGTH OF RECORD
!+
! WE MUST NOW CHECK TO SEE IF THIS RECORD NUMBER IS
! WITHIN THE ACCEPTABLE RANGE FOR THIS FILE. FOR
! INSTANCE, IT MAY BE .GTR. THE MAX-RECORD-NUMBER.
!-
IF ((.fst [fstmrn] NEQ 0) AND (.recnum GTR .fst [fstmrn])) OR (.recnum LEQ 0) THEN RETURN false;
!+
! COMPUTE THE ADDRESS OF THIS RECORD
!-
startofdata = .fst [fstlobyte]; ! 1ST BYTE AFTER PROLOGUE
!+
! DETERMINE THE # OF RECORDS WHICH WILL EXIST ON PAGE 0
!-
recsonpage0 = (pagesize - .startofdata)/(.sizeofrecord); ! FIND # OF RECORDS ON PAGE 1
!+
! IF THIS FILE HAS THE FB$BLK ATTRIBUTE, AND THIS
! RECORD IS NOT ON THE FIRST PAGE OF THE FILE, THEN
! WE MUST FIND THE PAGE ON WHICH IT LIVES. EACH PAGE
! AFTER PAGE 0 WILL HAVE THE SAME NUMBER OF RECORDS ON IT.
! THAT IS WHY WE MUST TREAT THE FIRST PAGE DIFFERENTLY
! THAN THE OTHER PAGES OF THE FILE.
!-
IF (blocked) AND .recnum GTR .recsonpage0
THEN ! ITS NOT ON PAGE 1
BEGIN
recnum = .recnum - .recsonpage0; ! SUBTRACT 1 PAGE OF RECORDS
recsonanypage = 512/.sizeofrecord; ! # OF RECORDS ON ANY FILE PAGE
temp = (.recnum - 1)/.recsonanypage; ! FIND WHERE RECORD BEGINS
bytenum = (.temp + 1)^p2w + ((.recnum - 1) MOD .recsonanypage)*.sizeofrecord;
! COMPUTE OFFSET INTO THAT PAGE
END %( OF IF .RECNUM GTR RECSONPAGE0 )%
ELSE
!+
! THIS FILE DOES NOT HAVE THE "FB$BLK" ATTRIBUTE,
! SO WE CAN COMPUTE THE START OF THE RECORD DIRECTLY
!-
bytenum = ((.recnum - 1)*(.sizeofrecord)) + .startofdata;%(LET'S SEE IT)%
lookat (' BYTE #: ', bytenum);
!+
! MAKE ONE LAST CHECK TO SEE IF THIS RECORD IS OFF THE END OF THE WORLD
!-
IF .bytenum GEQ bitn (8) THEN RETURN false;
RETURN .bytenum ! GIVE BACK THE BYTE ADDRESS
END;
%( OF NUMBERTORFA )%
%SBTTL 'WRITEBUFFER - Write non-indexed buffer'
GLOBAL ROUTINE writebuffer : NOVALUE =
! WRITEBUFFER
! ===========
! THIS ROUTINE WRITES OUT THE CURRENT BUFFER FOR FILES ON A SEQUENTIAL
! DEVICE, OR FOR ASCII ( LINE-SEQUENCED OR STREAM ) FILES.
! INPUT:
! <NONE>
! OUTPUT:
! <NONE>
! IMPLICIT INPUTS:
!
! RSTBYTECOUNT = NUMBER OF BYTES REMAINING IN FILE BUFFER
!
! ON EXIT, THE FILE BUFFER POINTER ( PAGPTR ) WILL BE RESET TO
! THE TOP OF THE FILE BUFFER. ALSO, THE BUFFER WILL BE
! SET TO INDICATE THAT IT IS EMPTY ( BYTECOUNT WILL BE SET
! TO THE SIZE OF AN EMPTY BUFFER )
! NOTES:
!
! 1. THE FOLLOWING SYMBOLS ARE MACROS WHICH ARE DEFINED
! IN "RST.REQ". DO NOT CONFUSE THEM WITH LOCAL VARIABLES:
!
! CURENTBUFFERADR
BEGIN
REGISTER
bufadd; !FOR CURRENT BUF ADDR
TRACE ('WRITEBUFFER');
!+
! DETERMINE THE NUMBER OF BYTES WE HAVE TO WRITE OUT
!-
bufadd = .curentbufferadr;
rtrace ('FLUSHING BUFFERS'); ! Use for debugging
IF .rst [rstbytecount] GTR 0 !ANYTHING THERE TO WRITE?
THEN
BEGIN !YES
ascwrite (.fst [fstjfn], .rst [rstnrp], .bufadd, .rst [rstbytecount]);
IF .rst[rst$h_byte_count]
EQL ( ( %BPVAL / .fst[fst$h_bsz] ) * rms$k_page_size ) !m570
THEN
BEGIN !WRITING FULL PAGE, SO POSIT TO NEXT P
rst [rstnrp] = .rst [rstnrp] + 1; !DONE (RE)WRITING THIS PAGE, POSIT TO NXT
rst [rstpagptr] = POINT (.bufadd, !m504
36,
.Fst[Fst$h_Bsz]); !RESET PTR TO TOP OF BUF
rst [rstbytecount] = 0; ! RESET NUMBER OF BYTES IN BUFFER
!+
! CLEAR ENTIRE BUFFER TO RESET ALL BIT 35'S.
! THIS IS NECESSARY SO THAT THE SECOND BUFFER WE WRITE
! DOESNT HAVE RANDOM BIT 35'S SET IN IT
!-
IF sequenced THEN clear (.bufadd, pagesize);
END; !END FULL PAGE
END; !END NON-EMPTY PAGE
RETURN
END;
%( OF WRITEBUFFER )%
%SBTTL 'READBUFFER - read non-indexed buffer'
GLOBAL ROUTINE readbuffer : NOVALUE =
! READBUFFER
! ==========
! THIS ROUTINE READS IN A NEW BUFFER FOR RMS-20 FILES ON
! A SEQUENTIAL DEVICE OR FOR ASCII FILES.
!
! INPUT:
! <NONE>
!
! OUTPUT:
! <NONE>
!
! NOTES:
!
! 1. FOR INPUT FROM THE TTY, A <CONTROL-Z> WILL RETURN
! AN ER$EOF ERROR CODE, BUT FURTHER INPUT FROM THE TTY
! WILL BE ALLOWED.
BEGIN
LOCAL
bytes_per_page; ! # of byte per page !a504
REGISTER
bufadd;
TRACE ('READBUFFER');
!+
! IF WE ARE ALREADY AT EOF, DONT BOTHER...
!-
IF endoffile THEN RETURN;
bufadd = .curentbufferadr; !USE A LOCAL
! REPOSITION TO BEGIN OF BUFFER
rst [rstpagptr] = POINT (.bufadd, 36, .Fst[Fst$h_bsz] ); !M504
!+
! FOR DEBUGGING
!-
rtrace ('READING BUFFER...');
bytes_per_page = (%BPUNIT/.Fst[Fst$h_Bsz])*pagesize; !a504
!+
! IF WE ARE READING FROM THE TTY, PROCESS ONE RECORD AT A TIME
! ELSE TRY TO FILL ENTIRE BUFFER
!-
IF tty
THEN
rst [rstbytecount] = readtty ( .bufadd, .bytes_per_page )
ELSE
BEGIN
rst [rstbytecount] = ascread (.fst [fstjfn],
.rst [rstnrp],
.bufadd,
.bytes_per_page ); !m504
rst [rstnrp] = .rst [rstnrp] + 1; !NEXT GROUP OF RECORDS IN NEXT BKT
END;
IF .rst [rstbytecount] EQL 0
THEN
BEGIN
setflag (rst [rstflags], flgeof); ! SET EOF FLAG
IF dasd !DISK FILE?
THEN
posascfil (.fst [fstjfn], sizefile (.fst [fstjfn])); !POSIT TO APPEND
END;
RETURN
END;
%(OF READBUFFER)%
END
ELUDOM