Type ASSEMBLE
Source Lines : 994
Fixes Applied : 5
Most Recent Version : Tuesday, December 12, 1978
Last Fix ID : [R14460DS]

Module

     DMSBRD   (RDBUF)

Function

       TO READ ONE OR MORE SUCCESSIVE ITEMS FROM A SPECIFIED
       FILE.

Attributes

       RESIDENT,  REENTRANT, CALLED  VIA  EITHER  AN SVC  OR
       BALR.

Operation

       AFTER  PERFORMING  SOME  ERROR  CHECKS,  RDBUF  CALLS
       ACTLKP  TO DETERMINE  IF  THE GIVEN  FILE  IS IN  THE
       ACTIVE FILE TABLE.   IF IT IS FOUND BUT  IS AN ACTIVE
       WRITE, AN ERROR 9 IS GIVEN.   IF AN ACTIVE READ, THEN
       PROCESSING PROCEEDS AS DESCRIBED UNDER "FILE ACTIVE".
       IF THE FILE IS ACTIVE BUT NEITHER A READ NOR A WRITE,
       THEN IT MUST HAVE BEEN PLACED  IN THE ACTIVE TABLE BY
       A  POINT  FUNCTION  CALL;   PROCESSING  CONTINUES  AS
       DESCRIBED  BELOW AT  THE  POINT  AFTER THE  ENTRY  IS
       PLACED IN THE ACTIVE FILE TABLE BY ACTFREE.

       FILE NOT ACTIVE:

       IF THE FILE IS NOT FOUND BY ACTLKP IN THE ACTIVE FILE
       TABLE, RDBUF CHECKS TO SEE  IF THE FILE REFERENCED AT
       STATEFST  (LEFT BY  THE MOST  RECENT  CALL TO  STATE)
       MATCHES  THE  CALLER'S  PARAMETER   LIST.   (AS  MANY
       COMMANDS  STATE A  FILE  TO  FIND ITS  EXISTENCE  AND
       CHARACTERISTICS AND THEN IMMEDIATELY  RDBUF THE FIRST
       RECORD, THERE IS A GOOD  CHANCE THIS WILL OCCUR--THUS
       SAVING A NEEDLESS SEARCH OF THE FST TABLES). IF FOUND
       AT STATEFST, THE  ADDRESSES OF THE ACTIVE  DISK TABLE
       AND THE FST ENTRY ITSELF  ARE OBTAINED FROM THE EIGHT
       BYTES IMMEDIATELY  FOLLOWING THE  STATEFST COPY,  AND
       FSTLKP IS  NOT CALLED.  (IF  NOT FOUND BY  FSTLKP, AN
       ERROR 1  OCCURS).  IF  FOUND BY  FSTLKP, OR  FOUND IN
       STATEFST AS ABOVE, THEN ACTFREE  IS CALLED TO FIND OR
       CREATE AN ENTRY  IN THE ACTIVE FILE  TABLE AND INSERT
       THE 40-BYTE FST ENTRY THEREIN.

       WHEN  THE FILE  HAS BEEN  PLACED IN  THE ACTIVE  FILE
       TABLE (OR WAS ALREADY THERE  FROM A POINT FUNCTION AS
       MENTIONED  ABOVE),  RDBUF  MARKS THE  FILE  AS  BEING
       ACTIVE.  NEXT, RDBUF OBTAINS  BUFFER SPACE INTO WHICH
       TO READ  THE DATA BLOCKS AND  INTO WHICH TO  READ THE
       FIRST CHAIN  LINK.  IT THEN  CALLS THE  RDTK FUNCTION
       PROGRAM  TO  READ  THE FIRST  CHAIN  LINK  INTO  MAIN
       STORAGE.  RDBUF NEXT MOVES THE  FIRST 80 BYTES OF THE
       FIRST CHAIN LINK INTO THE CHAIN LINK DIRECTORY IN THE
       ACTIVE FILE  TABLE ENTRY.   THEN RDBUF  DETERMINES IF
       THE ITEM(S)  TO BE READ  IS/ARE OF FIXED  OR VARIABLE
       LENGTH.  IF  OF VARIABLE LENGTH,  PROCESSING PROCEEDS
       AS  DESCRIBED UNDER  "VARIABLE-LENGTH  ITEM" IN  THIS
       SECTION. IF  OF FIXED LENGTH, PROCESSING  PROCEEDS AS
       DESCRIBED BELOW.

       FIXED-LENGTH ITEM:  RDBUF  CALCULATES THE  NUMBER  OF
       BYTES TO BE  READ.  THIS IS EQUAL TO  THE ITEM LENGTH
       MULTIPLIED BY  THE NUMBER  OF ITEMS  TO BE  READ.  IT
       THEN CALCULATES (FROM THE ITEM NUMBER SUPPLIED IN THE
       PARAMETER LIST) THE DATA BLOCK FROM WHICH THE ITEM(S)
       IS/ARE TO BE READ.  THIS  CALCULATION ALSO YIELDS THE
       DISPLACEMENT FROM THE START OF  THE DATA BLOCK OF THE
       FIRST  BYTE  TO  BE  READ.   NEXT,  RDBUF  DETERMINES
       WHETHER THE AFFECTED  DATA BLOCK IS IN  MAIN STORAGE.
       IF IT IS NOT, RDBUF DETERMINES WHETHER THE CHAIN LINK
       REQUIRED TO ACCESS  THE NEEDED DATA BLOCK  IS IN MAIN
       STORAGE.  IF THE  REQUIRED CHAIN LINK IS  NOT IN MAIN
       STORAGE,  RDBUF CALLS  THE RDTK  FUNCTION PROGRAM  TO
       READ IT INTO MAIN STORAGE.   AFTER THE REQUIRED CHAIN
       LINK HAS  BEEN READ  INTO MAIN STORAGE,  OR IF  IT IS
       ALREADY IN MAIN STORAGE, RDBUF DETERMINES WHETHER THE
       AFFECTED  DATA   BLOCK  EXISTS.   (IT  WILL   IF  ITS
       CORRESPONDING ENTRY IN THE CHAIN LINK THAT IS IN MAIN
       STORAGE  CONTAINS  A  VALID DISK  ADDRESS.)   IF  THE
       AFFECTED DATA BLOCK  DOES NOT EXIST, RDBUF  FILLS THE
       INPUT BUFFER WITH  ZEROES AND RETURNS TO  THE CALLING
       PROGRAM.  IF IT  DOES EXIST, RDBUF READS  IT INTO THE
       DATA BLOCK BUFFER.

       IF THE  AFFECTED DATA BLOCK  IS IN MAIN  STORAGE WHEN
       RDBUF IS CALLED,  OR IF IT IS NOT, AFTER  IT HAS BEEN
       READ  INTO   MAIN  STORAGE   (IF  NECESSARY),   RDBUF
       DETERMINES WHETHER IT CONTAINS ALL OF THE BYTES TO BE
       READ.   (IT  WILL IF  THE  RESULT  OF 800  MINUS  THE
       PREVIOUSLY CALCULATED DISPLACEMENT IS GREATER THAN OR
       EQUAL TO  THE NUMBER  OF BYTES TO  BE READ.)   IF THE
       DATA  BLOCK CONTAINS  ALL OF  THE BYTES  TO BE  READ,
       RDBUF MOVES  THEM FROM THE  DATA BLOCK  BUFFER (WHERE
       THE  DATA BLOCK  RESIDES)  TO  THE INPUT  BUFFER  AND
       RETURNS TO  THE CALLING PROGRAM.   IF THE  DATA BLOCK
       DOES NOT CONTAIN  ALL OF THE BYTES TO  BE READ, RDBUF
       MOVES THE PERTINENT BYTES FROM  THE DATA BLOCK BUFFER
       TO THE  INPUT BUFFER.   IT THEN  READS THE  NEXT DATA
       BLOCK INTO MAIN STORAGE,  OBTAINS THE REMAINING BYTES
       TO BE READ  FROM IT, MOVES THEM TO  THE INPUT BUFFER,
       AND  RETURNS TO  THE CALLING  PROGRAM.   (IF THE  800
       BYTES IN  THE NEXT DATA  BLOCK ARE NOT  SUFFICIENT TO
       SATISFY THE READ, RDBUF MOVES THE ENTIRE 800 BYTES TO
       THE INPUT BUFFER AND READS THE NEXT DATA BLOCK TO GET
       THE REMAINING  BYTES.  RDBUF  REPEATS THIS  PROCEDURE
       UNTIL THE NUMBER OF BYTES  IN THE INPUT BUFFER EQUALS
       THE NUMBER OF  BYTES TO BE READ.  IT  THEN RETURNS TO
       THE CALLING PROGRAM.)

       VARIABLE-LENGTH RECORD: RDBUF  READS SUCCESSIVE  DATA
       BLOCKS (STARTING WITH THE FIRST) UNTIL IT LOCATES THE
       ONE THAT  CONTAINS THE  START OF  THE VARIABLE-LENGTH
       ITEM TO BE READ. IT THEN MOVES THE ITEM LENGTH TO THE
       START OF  THE INPUT BUFFER.  IF THE FIRST  DATA BLOCK
       CONTAINS  THE  ENTIRE  ITEM,  RDBUF  RETURNS  TO  THE
       CALLING PROGRAM.  IF THE  FIRST DATA  BLOCK DOES  NOT
       CONTAIN THE ENTIRE  ITEM, RDBUF MOVES THE  DATA BLOCK
       TO THE  INPUT BUFFER  AND READS  THE NEXT  DATA BLOCK
       INTO THE  DATA BLOCK BUFFER,  MOVES THE  REMAINDER OF
       THE  ITEM TO  THE INPUT  BUFFER, AND  RETURNS TO  THE
       CALLING   PROGRAM.    IF   THE   REMAINDER   OF   THE
       VARIABLE-LENGTH ITEM IS NOT COMPLETELY CONTAINED WITH
       THE 800 BYTES  OF THE SECOND DATA  BLOCK, RDBUF READS
       THE  NEXT DATA  BLOCK  TO  GET THE  REMAINING  BYTES.
       RDBUF  REPEATS   THIS  PROCEDURE  UNTIL   THE  ENTIRE
       VARIABLE-LENGTH  ITEM HAS  BEEN PLACED  IN THE  INPUT
       BUFFER.  IT THEN RETURNS TO THE CALLING PROGRAM.

       FILE ACTIVE:

       IF THE FILE  IS ACTIVE, RDBUF DETERMINES  WHETHER THE
       ITEM TO BE  READ IS OF FIXED OR  VARIABLE LENGTH.  IF
       OF  FIXED  LENGTH,  IT   PROCEEDS  AS  DESCRIBED  FOR
       FIXED-LENGTH ITEMS  UNDER "FILE  NOT ACTIVE".   IF OF
       VARIABLE LENGTH AND  THE ITEM TO BE  READ IMMEDIATELY
       FOLLOWS   THE  ONE   JUST  READ,   RDBUF  MOVES   THE
       VARIABLE-LENGTH  ITEM INTO  THE INPUT  BUFFER IN  THE
       PREVIOUSLY DESCRIBED MANNER.   IF THE VARIABLE-LENGTH
       ITEM TO  BE READ  PRECEDES THE  ONE JUST  READ, RDBUF
       PROCEEDS  AS  DESCRIBED FOR  VARIABLE-LENGTH  RECORDS
       UNDER "FILE NOT ACTIVE".  IF THE VARIABLE-LENGTH ITEM
       TO BE READ FOLLOWS, BUT NOT IMMEDIATELY, THE ONE JUST
       READ, RDBUF  READS FORWARD FROM THE  CURRENT LOCATION
       IN  THE  FILE   UNTIL  IT  LOCATES  THE   DATA  BLOCK
       CONTAINING THE  START OF THE  DESIRED ITEM.   IT THEN
       MOVES THAT  ITEM TO  THE INPUT  BUFFER AS  PREVIOUSLY
       DESCRIBED.

Calls to Other Routines

       ACTFREE, ACTLKP, DMSFREE, DMSFRET, FSTLKP, RDTK