-- Transport Mechanism Filestore - heap object reader --

-- [Juniper]<Grapevine>MS>Reader.mesa

-- Randy Gobbel		19-May-81 11:52:23 --
-- Andrew Birrell	24-Feb-81 16:25:59 --

DIRECTORY
BodyDefs	USING[ ItemHeader, maxRNameLength, RName, RNameSize],
HeapDefs	USING[ Buffer, HeapEndRead, HeapReadRName, HeapStartRead,
		       ObjectOffset, objectStart ],
HeapFileDefs	USING[ NextPage ],
HeapXDefs	USING[ PageHeader, ObjectHeader, ReaderData],
Inline		USING[ COPY, LowHalf ],
ObjectDirDefs	USING[ FreeObject, ObjectNumber, UseObject ],
ObjectDirXDefs	USING[ ObjectBase ],
ProtocolDefs	USING[ endSST, Failed, SendCount ],
PupStream	USING[ StreamClosing ],
Stream		USING[ Handle, PutBlock, SetSST ],
VMDefs		USING[ AllocatePage, Page, PageIndex, pageSize, ReadPage,
		       Release ];

Reader: MONITOR LOCKS from USING from: Handle
   IMPORTS BodyDefs, HeapDefs, HeapFileDefs, Inline, ObjectDirDefs,
           ObjectDirXDefs, ProtocolDefs, PupStream, Stream, VMDefs
   EXPORTS HeapDefs, HeapXDefs =
BEGIN

ReaderData: PUBLIC TYPE = HeapXDefs.ReaderData;
Handle: TYPE = POINTER TO ReaderData;



SubObjectMissing: ERROR = CODE;
ReadingTooFar:    ERROR = CODE;
ObjectNotThere:   SIGNAL = CODE;

HeapReadData: PUBLIC ENTRY PROCEDURE[ from: Handle,
                                      to: HeapDefs.Buffer]
                             RETURNS[ end: BOOLEAN, used: CARDINAL ] =
   BEGIN -- there is always a current page --
   WHILE from.stopped DO WAIT from.canStart ENDLOOP;
   IF from.end THEN ERROR ReadingTooFar[];
   end _ FALSE; used _ 0;
   DO BEGIN
      word: VMDefs.PageIndex _ from.where.word;
      givenOffset: HeapDefs.ObjectOffset;--offset specified by disk data--
      objectHead: POINTER TO HeapXDefs.ObjectHeader;
      endOfSubObject: BOOLEAN _ FALSE; --whether complete sub-object read--
      ignored: BOOLEAN _ FALSE; --whether sub-object was ignored--

      -- check for offset given by page header --
      IF word = FIRST[ VMDefs.PageIndex ]
      THEN BEGIN
           pageHead: POINTER TO HeapXDefs.PageHeader =
                                     LOOPHOLE[from.page,POINTER] + word;
           word _ word + SIZE[HeapXDefs.PageHeader];
           givenOffset _ pageHead.offset;
           END
      ELSE givenOffset _ HeapDefs.objectStart;

      -- read object or sub-object header --
      objectHead _ LOOPHOLE[from.page,POINTER] + word;
      word _ word + SIZE[HeapXDefs.ObjectHeader];
      IF objectHead.number # from.object
      THEN -- skip past gaps or intervening objects --
           BEGIN
           IF from.offset = HeapDefs.objectStart THEN SIGNAL ObjectNotThere[]; 
           ignored _ endOfSubObject _ TRUE;
           END

      ELSE BEGIN
           IF from.offset < givenOffset THEN ERROR SubObjectMissing[];
           BEGIN -- read object data --
              relocation: CARDINAL = Inline.LowHalf[
                 MIN[from.offset-givenOffset, objectHead.size] ];
              available: CARDINAL = objectHead.size - relocation;
              amount: CARDINAL = MIN[ to.length - used, available ];
              Inline.COPY[from.page+word+relocation, amount,
                              to.where+used];
              used _ used + amount;
              from.offset _ from.offset + amount;

              -- update disk position only if complete sub-object read --
              endOfSubObject _ amount >= available;
           END;
           END;

      -- deal with end of page or of object --
      -- Remember that an object never ends on a page boundary --
      IF endOfSubObject
      THEN BEGIN
           from.where.word _ word + objectHead.size;
           IF from.where.word + SIZE[HeapXDefs.ObjectHeader]
                > LAST[VMDefs.PageIndex]
           THEN BEGIN -- move to sub-object on next page --
                VMDefs.Release[from.page];
                from.where _ HeapFileDefs.NextPage[from.where];
                from.page _ VMDefs.ReadPage[from.where.page,
                   IF from.object.type = body THEN 1 ELSE 0 --lookAhead--];
                END
           ELSE -- ignorable sub-object or end of object --
                IF NOT ignored
                THEN BEGIN --positioned after object--
                     from.end _ end _ TRUE; EXIT
                     END;
           END
      ELSE -- check for buffer full --
           IF used = to.length THEN EXIT ELSE ERROR;

      END;
   ENDLOOP;
   END;

BadString: ERROR[why: {tooLong, endOfObject}] = CODE;

HeapReadString: PUBLIC PROCEDURE[ from: Handle, s: STRING]
                        RETURNS[ ended: BOOLEAN] =
   BEGIN
   Read: PROCEDURE[base: POINTER, amount: CARDINAL ] =
      BEGIN
      used: CARDINAL;
      [ended,used] _ HeapReadData[from,[base,amount]];
      IF used # amount THEN ERROR BadString[endOfObject];
      END;
   temp: STRING = [0];
   Read[temp, SIZE[StringBody[0]]];
   IF temp.length > s.maxlength THEN ERROR BadString[tooLong];
   s.length _ temp.length;
   IF s.length > 0
   THEN BEGIN
        IF ended THEN ERROR BadString[endOfObject];
        Read[@(s.text),
             SIZE[StringBody[s.length]]-SIZE[StringBody[0]]];
        END;
   END;

ReadItemHeader: PUBLIC PROCEDURE[from: Handle]
                         RETURNS[header: BodyDefs.ItemHeader] =
   BEGIN
   [] _ HeapReadData[from, [@header, SIZE[BodyDefs.ItemHeader] ] ];
   END;

ReadRList: PUBLIC PROCEDURE[from: Handle,
               work: PROCEDURE[BodyDefs.RName]RETURNS[done:BOOLEAN] ] =
   BEGIN
   length: CARDINAL _ LAST[CARDINAL];
   [,] _ HeapReadData[from, [@length, SIZE[CARDINAL]] ];
   WHILE length > 0
   DO name: BodyDefs.RName = [BodyDefs.maxRNameLength];
      [] _ HeapDefs.HeapReadRName[from, name];
      length _ length - BodyDefs.RNameSize[name];
      IF work[name] THEN EXIT;
   ENDLOOP;
   END;

SendComponent: PUBLIC PROCEDURE[from: Handle,
                                str: Stream.Handle ] =
   BEGIN
   length: CARDINAL _ LAST[CARDINAL];
   bLength: CARDINAL = 64;
   buffer: ARRAY [0..bLength) OF WORD;
   [,] _ HeapReadData[from, [@length, SIZE[CARDINAL]] ];
   ProtocolDefs.SendCount[str, length];
   WHILE length > 0
   DO used: CARDINAL = HeapReadData[from,
               [@buffer, MIN[length, bLength] ] ].used;
      length _ length - used;
      Stream.PutBlock[str,[@buffer, 0, used*2], FALSE !
         PupStream.StreamClosing =>
               ERROR ProtocolDefs.Failed[communicationError]  ];
   ENDLOOP;
   END;

SendObj: PUBLIC PROCEDURE[from: Handle,
                          str: Stream.Handle ] =
   BEGIN
   ended:  BOOLEAN _ FALSE;
   used:   CARDINAL;
   buffer: VMDefs.Page = VMDefs.AllocatePage[];
   BEGIN
      ENABLE UNWIND =>
         BEGIN VMDefs.Release[buffer]; HeapDefs.HeapEndRead[from]; END;
      DO BEGIN
         [ended,used] _ HeapReadData[from,[buffer,VMDefs.pageSize]];
         Stream.PutBlock[str,[buffer, 0, used*2], FALSE !
            PupStream.StreamClosing =>
               ERROR ProtocolDefs.Failed[communicationError]  ];
         IF ended THEN EXIT;
         END
      ENDLOOP;
   END;
   VMDefs.Release[buffer];
   HeapDefs.HeapEndRead[from];
   Stream.SetSST[str, ProtocolDefs.endSST !
            PupStream.StreamClosing =>
               ERROR ProtocolDefs.Failed[communicationError]  ];
   END;

ReaderInfo: ENTRY PROCEDURE[ from: Handle ]
                    RETURNS[ ObjectDirDefs.ObjectNumber,
                             HeapDefs.ObjectOffset ] = INLINE
   BEGIN
   ObjectDirDefs.UseObject[from.object];
   RETURN[from.object, from.offset];
   END;

CopyReader: PUBLIC PROCEDURE[ from: Handle ]
                     RETURNS[ new: Handle ] =
   BEGIN
   -- Must not enter Reader monitor, since it calls ReaderAlloc --
   object: ObjectDirDefs.ObjectNumber;
   offset: HeapDefs.ObjectOffset;
   [object,offset] _ ReaderInfo[from]; -- snap-shot of reader --
   new _ HeapDefs.HeapStartRead[object];
   ObjectDirDefs.FreeObject[object]; -- to compensate for ReaderInfo --
   SetReaderOffset[new, offset];
   END;

GetReaderOffset: PUBLIC ENTRY PROCEDURE[ from: Handle ]
                                RETURNS[ HeapDefs.ObjectOffset ] =
   BEGIN
   RETURN[ from.offset ];
   END;

SetReaderOffset: PUBLIC ENTRY PROCEDURE[ from: Handle,
                                         offset: HeapDefs.ObjectOffset ] =
   BEGIN
   WHILE from.stopped DO WAIT from.canStart ENDLOOP;
   IF offset >= from.offset
   THEN from.offset _ offset -- let reader skip by itself --
   ELSE { from.offset _ offset; Reset[from] };
   END;

GetReaderObject: PUBLIC ENTRY PROCEDURE[ from: Handle ]
                                RETURNS[ ObjectDirDefs.ObjectNumber ] =
   { RETURN[ from.object ] };

Reset: INTERNAL PROCEDURE[ from: Handle ] =
   BEGIN
   -- re-calculate disk address for current position --
   VMDefs.Release[from.page];
   from.where _ ObjectDirXDefs.ObjectBase[from.object];
   from.end _ FALSE;
   BEGIN
      -- skip to approximate place efficiently --
      excess: HeapDefs.ObjectOffset _ from.offset;
      WHILE excess > LAST[VMDefs.PageIndex]
      DO from.where _ HeapFileDefs.NextPage[from.where];
         excess _ excess - LAST[VMDefs.PageIndex];
      ENDLOOP;
   END;
   from.page _ VMDefs.ReadPage[ from.where.page, 0 --lookAhead-- ];
   -- reader will skip to correct place all by itself --
   END;

StopReader: PUBLIC ENTRY PROCEDURE[ from: Handle ] =
   BEGIN
   from.stopped _ TRUE;
   END;

RestartReader: PUBLIC ENTRY PROCEDURE[ from: Handle ] =
   BEGIN
   Reset[from]; --to re-calculate disk address--
   from.stopped _ FALSE;
   BROADCAST from.canStart;
   END;


END.