-- Copyright (C) 1981, 1984, 1985  by Xerox Corporation. All rights reserved. 
-- Reader.mesa, Transport Mechanism Filestore - heap object reader --

-- HGM, 15-Sep-85 12:43:45
-- Mark Johnson 	10-Nov-81 16:59:41 --
-- 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 [LongCOPY, 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 = LONG 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: LONG 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: LONG POINTER TO HeapXDefs.PageHeader =
          LOOPHOLE[from.page, LONG 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, LONG 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.LongCOPY[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: LONG STRING]
    RETURNS [ended: BOOLEAN] =
    BEGIN
    Read: PROCEDURE [base: LONG 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;
    bufferAddr: LONG POINTER ¬ @buffer;
    [, ] ¬ 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, [LOOPHOLE[bufferAddr], 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[];
    bufferAddr: LONG POINTER ¬ buffer;
    BEGIN
    ENABLE
      UNWIND => BEGIN VMDefs.Release[buffer]; HeapDefs.HeapEndRead[from]; END;
    DO
      BEGIN
      [ended, used] ¬ HeapReadData[from, [buffer, VMDefs.pageSize]];
      Stream.PutBlock[
        str, [LOOPHOLE[bufferAddr], 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.