-- Registration Server - Implementation of using heap and BTree as a registry.

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

-- Randy Gobbel,	20-May-81 13:03:14 
-- J. Dion,		September 10, 1979.
-- Andrew Birrell,	26-Oct-82 13:18:34 

DIRECTORY
BodyDefs	USING [maxRNameLength, RName, RNameSize, Timestamp],
HeapDefs,
Inline		USING[ LowHalf ],
PupDefs		USING [PupNameLookup],
PupStream	USING [PupAddress],
Process		USING [InitializeCondition, MsecToTicks],
ProtocolDefs,
RegistryDefs,
Time		USING [Current, Packed];

Registry: MONITOR
IMPORTS BodyDefs,  HeapDefs, Inline, PupDefs, Process, Time
EXPORTS RegistryDefs =

BEGIN

HeapObjectEnded: ERROR = CODE;

MangledHeapObject: ERROR = CODE;

Copy: PUBLIC PROC[reader: HeapDefs.ReaderHandle,
		     writer: HeapDefs.WriterHandle] =
  -- copies one component of an entry --
   BEGIN
   bLength: CARDINAL = 64;
   buffer: ARRAY [0..bLength) OF WORD;
   length: CARDINAL _ ReadComponentLength[reader];
   WriteComponentLength[writer, length];
   WHILE length > 0
   DO used: CARDINAL = HeapDefs.HeapReadData[reader,
                          [@buffer,MIN[length,bLength]] ].used;
      length _ length - used;
      HeapDefs.HeapWriteData[writer, [@buffer,used] ];
   ENDLOOP;
   END;

Skip: PUBLIC PROC[reader: HeapDefs.ReaderHandle] =
   -- skips one component of an entry --
   BEGIN
   length: CARDINAL = ReadComponentLength[reader];
   IF length > 0 --optimisation--
   THEN HeapDefs.SetReaderOffset[reader,
                                 length + HeapDefs.GetReaderOffset[reader]];
   END;

SkipIfEmpty: PUBLIC PROC[reader: HeapDefs.ReaderHandle]
                RETURNS[empty: BOOLEAN] =
   BEGIN
   pos: HeapDefs.ObjectOffset = HeapDefs.GetReaderOffset[reader];
   length: CARDINAL = ReadComponentLength[reader];
   IF length = 0
   THEN RETURN[TRUE]
   ELSE BEGIN
        HeapDefs.SetReaderOffset[reader, pos];
        RETURN[FALSE]
        END;
   END;

WriteList: PUBLIC PROC[writer: HeapDefs.WriterHandle,
                       name: BodyDefs.RName,
                       stamp: BodyDefs.Timestamp] =
   BEGIN
   -- writes single or zero entry list, with no deletions --
   IF name = NIL
   THEN { WriteEmptyList[writer]; WriteEmptyList[writer] }
   ELSE { WriteRNameList[writer,name]; WriteStampList[writer,stamp]; };
   WriteEmptyList[writer]; WriteEmptyList[writer];
   END;

StartSublist: PUBLIC PROC RETURNS[ writer: HeapDefs.WriterHandle] =
   BEGIN
   writer _ HeapDefs.HeapStartWrite[temp];
   WriteComponentLength[writer, 0]; -- place holder --
   END;

AddNameToSublist: PUBLIC PROC[writer: HeapDefs.WriterHandle,
                              name: BodyDefs.RName] =
   BEGIN
   HeapDefs.HeapWriteRName[writer, name];
   END;

EndSublist: PUBLIC PROC[writer: HeapDefs.WriterHandle, count: CARDINAL]
                RETURNS[reader: HeapDefs.ReaderHandle] =
   BEGIN
   offset: HeapDefs.ObjectOffset _ HeapDefs.GetWriterOffset[writer];
   HeapDefs.SetWriterOffset[writer, HeapDefs.objectStart];
   WriteComponentLength[writer, Inline.LowHalf[offset-SIZE[CARDINAL]]];
   HeapDefs.SetWriterOffset[writer, offset];
   WriteComponentLength[writer, count * SIZE[BodyDefs.Timestamp]];
   BEGIN
      stamp: BodyDefs.Timestamp = MakeTimestamp[];
      THROUGH [0..count) DO WriteTimestamp[writer, stamp] ENDLOOP;
   END;
   WriteEmptyList[writer]; WriteEmptyList[writer]; -- deletions --
   BEGIN
      GetReader: PROC[obj: HeapDefs.ObjectNumber] =
         { reader _ HeapDefs.HeapStartRead[obj] };
      HeapDefs.HeapEndWrite[writer, GetReader];
   END;
   END;

EnumerateRList: PUBLIC PROC[reader: HeapDefs.ReaderHandle,
                            work: PROC[BodyDefs.RName]RETURNS[done:BOOLEAN]] =
   BEGIN
   length: CARDINAL _ ReadComponentLength[reader];
   WHILE length > 0
   DO name: BodyDefs.RName = [BodyDefs.maxRNameLength];
      [] _ HeapDefs.HeapReadRName[reader, name];
      length _ length - BodyDefs.RNameSize[name];
      IF work[name] THEN EXIT;
   ENDLOOP;
   END;

ReadPrefix: PUBLIC PROC[reader: HeapDefs.ReaderHandle,
                        name: BodyDefs.RName]
               RETURNS[type: ProtocolDefs.RNameType,
                        stamp: BodyDefs.Timestamp] =
   BEGIN
   length: CARDINAL = ReadComponentLength[reader];
   stamp _ ReadTimestamp[reader];
   [,] _ HeapDefs.HeapReadData[reader, [@type,SIZE[ProtocolDefs.RNameType]]];
   [] _ HeapDefs.HeapReadRName[reader, name];
   IF length # SIZE[ProtocolDefs.RNameType] + SIZE[BodyDefs.Timestamp] +
         BodyDefs.RNameSize[name]
   THEN ERROR MangledHeapObject;
   END;

WritePrefix: PUBLIC PROC[writer: HeapDefs.WriterHandle,
                         type: ProtocolDefs.RNameType,
                         stamp: POINTER TO BodyDefs.Timestamp,
                         name: BodyDefs.RName] =
   BEGIN
   WriteComponentLength[writer, SIZE[ProtocolDefs.RNameType] +
                                SIZE[BodyDefs.Timestamp] +
                                BodyDefs.RNameSize[name] ];
   WriteTimestamp[writer, stamp^];
   HeapDefs.HeapWriteData[writer, [@type,SIZE[ProtocolDefs.RNameType]]];
   HeapDefs.HeapWriteRName[writer, name];
   END;

ReadPassword: PUBLIC PROC[reader: HeapDefs.ReaderHandle]
                 RETURNS [pw: ProtocolDefs.Password,
                          stamp: BodyDefs.Timestamp] =
   BEGIN
   IF ReadComponentLength[reader] # SIZE [ProtocolDefs.Password] +
        SIZE[BodyDefs.Timestamp] 
   THEN ERROR MangledHeapObject;
   stamp _ ReadTimestamp[reader];
   [] _ HeapDefs.HeapReadData [reader, [@pw, SIZE [ProtocolDefs.Password]]];
   END;

WritePassword: PUBLIC PROC[writer: HeapDefs.WriterHandle,
                           pw: ProtocolDefs.Password,
                           stamp: BodyDefs.Timestamp] =
   BEGIN
   WriteComponentLength[writer,
                     SIZE[ProtocolDefs.Password]+SIZE[BodyDefs.Timestamp]];
   WriteTimestamp[writer, stamp];
   HeapDefs.HeapWriteData [writer, [@pw, SIZE [ProtocolDefs.Password]]];
   END;

ReadConnect: PUBLIC PROC[reader: HeapDefs.ReaderHandle,
                         connect: ProtocolDefs.Connect]
                RETURNS [stamp: BodyDefs.Timestamp] =
   BEGIN
   [] _ ReadComponentLength[reader];
   stamp _ ReadTimestamp[reader];
   connect.length _ LAST[CARDINAL];
   [,] _ HeapDefs.HeapReadData[reader, [@(connect.length),SIZE[CARDINAL]] ];
   IF connect.length > connect.maxlength
   THEN ERROR MangledHeapObject;
   [] _ HeapDefs.HeapReadData [reader,
          [@(connect.text), (1+connect.length)/2] ];
   END;

WriteConnect: PUBLIC PROC[writer: HeapDefs.WriterHandle,
                          connect: ProtocolDefs.Connect,
                          stamp: BodyDefs.Timestamp] =
   BEGIN
   WriteComponentLength[writer,
       SIZE[BodyDefs.Timestamp] + SIZE[CARDINAL] + (1+connect.length)/2];
   WriteTimestamp[writer, stamp];
   HeapDefs.HeapWriteData[writer, [@(connect.length),SIZE[CARDINAL]] ];
   HeapDefs.HeapWriteData [writer,
      [@(connect.text), (1+connect.length)/2] ];
   END;

WriteStampList: PROC[writer: HeapDefs.WriterHandle,
                          stamp: BodyDefs.Timestamp] =
   BEGIN
   WriteComponentLength[writer, SIZE [BodyDefs.Timestamp]];
   WriteTimestamp[writer, stamp];
   END;

WriteRNameList: PROC[writer: HeapDefs.WriterHandle,
                          name: BodyDefs.RName] =
   BEGIN
   WriteComponentLength[writer, BodyDefs.RNameSize[name] ];
   HeapDefs.HeapWriteRName[writer, name];
   END;

WriteEmptyList: PROC[writer: HeapDefs.WriterHandle] = INLINE
   BEGIN
   zero: CARDINAL _ 0;
   HeapDefs.HeapWriteData[writer, [@zero,SIZE[CARDINAL]] ];
   END;

ReadComponentLength: PROC[reader: HeapDefs.ReaderHandle]
                     RETURNS[length: CARDINAL] = INLINE
   BEGIN
   length _ LAST[CARDINAL];
   [,] _ HeapDefs.HeapReadData[reader, [@length,SIZE[CARDINAL]] ];
   END;

WriteComponentLength: PROC[writer: HeapDefs.WriterHandle,
                           length: CARDINAL] =
   BEGIN
   HeapDefs.HeapWriteData[writer, [@length,SIZE[CARDINAL]] ];
   END;

ReadTimestamp: PROC[reader: HeapDefs.ReaderHandle]
           RETURNS [stamp: BodyDefs.Timestamp] = INLINE
   BEGIN
   [,] _ HeapDefs.HeapReadData [reader,
                                [@stamp, SIZE [BodyDefs.Timestamp]] ];
   END;

WriteTimestamp: PROCEDURE [writer: HeapDefs.WriterHandle,
                           stamp: BodyDefs.Timestamp] =
   BEGIN
   HeapDefs.HeapWriteData [writer, [@stamp, SIZE [BodyDefs.Timestamp]]];
   END;


-- single-name updates --

-- RegistryDefs.UpdateInfo: TYPE = { done, noChange, outOfDate };
--   noChange => name already (not) there (timestamp may have been altered)
--   outOfDate => better timestamp already in list

AddName: PUBLIC PROC[reader: HeapDefs.ReaderHandle,
                     name: BodyDefs.RName,
                     stamp: POINTER TO BodyDefs.Timestamp,
                     writer: HeapDefs.WriterHandle]
            RETURNS[ info: RegistryDefs.UpdateInfo ] =
   BEGIN
   memInfo: RegistryDefs.UpdateInfo =
     SingleChangeToSublist[reader, name, stamp, writer, add];
   delMemInfo: RegistryDefs.UpdateInfo =
     SingleChangeToSublist[reader, name, stamp, writer, remove];
   info _ SELECT memInfo FROM
     done => IF delMemInfo = outOfDate THEN outOfDate ELSE done,
     noChange => IF delMemInfo = noChange THEN noChange ELSE ERROR,
     outOfDate => IF delMemInfo = noChange THEN outOfDate ELSE ERROR,
     ENDCASE => ERROR;
   END;

RemoveName: PUBLIC PROC[reader: HeapDefs.ReaderHandle,
                        name: BodyDefs.RName,
                        stamp: POINTER TO BodyDefs.Timestamp,
                        writer: HeapDefs.WriterHandle]
               RETURNS[ info: RegistryDefs.UpdateInfo ] =
   BEGIN
   memInfo: RegistryDefs.UpdateInfo =
     SingleChangeToSublist[reader, name, stamp, writer, remove];
   delMemInfo: RegistryDefs.UpdateInfo =
     SingleChangeToSublist[reader, name, stamp, writer, add];
   info _ SELECT delMemInfo FROM
     done => IF memInfo = outOfDate THEN outOfDate ELSE memInfo,
     noChange => IF memInfo = noChange THEN noChange ELSE ERROR,
     outOfDate => IF memInfo = noChange THEN outOfDate ELSE ERROR,
     ENDCASE => ERROR;
   END;

SingleChangeToSublist: PROC[reader: HeapDefs.ReaderHandle,
                                   name: BodyDefs.RName,
                                   stamp: POINTER TO BodyDefs.Timestamp,
                                   writer: HeapDefs.WriterHandle,
                                   change: {add,remove} ]
                          RETURNS[ info: RegistryDefs.UpdateInfo ] =
   BEGIN
   beforeCount: CARDINAL _ 0;
   afterCount: CARDINAL _ 0;
   member: BodyDefs.RName = [BodyDefs.maxRNameLength];
   originalLength: CARDINAL = ReadComponentLength[reader];
   length: CARDINAL _ originalLength;
   lengthPos: HeapDefs.ObjectOffset = HeapDefs.GetWriterOffset[writer];
   ResetLength: PROC =
      BEGIN -- length didn't change after all --
      now: HeapDefs.ObjectOffset = HeapDefs.GetWriterOffset[writer];
      HeapDefs.SetWriterOffset[writer, lengthPos];
      WriteComponentLength[writer, originalLength];
      HeapDefs.SetWriterOffset[writer, now];
      END;
   WriteComponentLength[writer, IF change = add
                 THEN length + BodyDefs.RNameSize[name]
                 ELSE length - BodyDefs.RNameSize[name] ];
   info _ done;

   -- copy preceding names --
   WHILE length > 0
   DO [] _ HeapDefs.HeapReadRName[reader, member];
      length _ length - BodyDefs.RNameSize[member];
      SELECT CompareRNames[member, name] FROM
        less =>
          BEGIN
          HeapDefs.HeapWriteRName[writer, member];
          beforeCount _ beforeCount + 1;
          END;
        equal =>
          BEGIN
          IF change = add
          THEN { info _ noChange; HeapDefs.HeapWriteRName[writer, name] };
          EXIT
          END;
        greater =>
          BEGIN
          IF change = add
          THEN HeapDefs.HeapWriteRName[writer, name]
          ELSE info _ noChange;
          afterCount _ 1;
          HeapDefs.HeapWriteRName[writer, member];
          EXIT
          END;
      ENDCASE => ERROR;
   REPEAT
   FINISHED =>
      IF change = add
      THEN HeapDefs.HeapWriteRName[writer, name]
      ELSE info _ noChange;
   ENDLOOP;

   -- copy following names --
   WHILE length > 0
   DO [] _ HeapDefs.HeapReadRName[reader, member];
      length _ length - BodyDefs.RNameSize[member];
      HeapDefs.HeapWriteRName[writer, member];
      afterCount _ afterCount + 1;
   ENDLOOP;

   SELECT info FROM
     done => NULL;
     noChange => ResetLength[];
   ENDCASE => ERROR;

   -- stamp list length --
   WriteComponentLength[writer, 
       IF info = noChange
       THEN ReadComponentLength[reader]
       ELSE IF change = add
            THEN ReadComponentLength[reader] + SIZE[BodyDefs.Timestamp]
            ELSE ReadComponentLength[reader] - SIZE[BodyDefs.Timestamp] ];
   THROUGH [1..beforeCount]
   DO WriteTimestamp[writer, ReadTimestamp[reader] ]; ENDLOOP;
   IF change = add
   THEN BEGIN
        IF info = done
        THEN WriteTimestamp[writer, stamp^]
        ELSE BEGIN
             prev: BodyDefs.Timestamp = ReadTimestamp[reader];
             best: BodyDefs.Timestamp;
             SELECT CompareTimestamps[stamp^, prev ] FROM
               less => { best _ prev; info _ outOfDate };
               equal => best _ stamp^;
               greater => best _ stamp^;
               ENDCASE => ERROR;
             WriteTimestamp[writer, best];
             END;
        END
   ELSE IF info = noChange
        THEN NULL
        ELSE BEGIN
             prev: BodyDefs.Timestamp = ReadTimestamp[reader];
             IF CompareTimestamps[stamp^, prev ] = less THEN info _ outOfDate;
             END;
   THROUGH [1..afterCount]
   DO WriteTimestamp[writer, ReadTimestamp[reader] ]; ENDLOOP;
   END;


-- General merge algorithm --

Inlist: TYPE = RECORD [
        RNameReader, TimestampReader: HeapDefs.ReaderHandle,
        RNameWordsLeft, TimestampWordsLeft: CARDINAL,
        RNameStart, TimestampStart: HeapDefs.ObjectOffset,
        name: BodyDefs.RName,
        stamp: BodyDefs.Timestamp,
        empty: BOOLEAN];

Outlist:TYPE = RECORD [
        RNameWriter, TimestampWriter: HeapDefs.WriterHandle,
        RNameStart: HeapDefs.ObjectOffset,
        RNameWordsUsed, TimestampWordsUsed: CARDINAL];

MergeLists: PUBLIC PROC[reader1, reader2: HeapDefs.ReaderHandle,
                        writer: HeapDefs.WriterHandle]
               RETURNS [newer1, newer2: BOOLEAN] =
   BEGIN
   -- allocate buffers for R-Names locally, to avoid FSP fragmentation --
   name1: BodyDefs.RName = [BodyDefs.maxRNameLength];
   name2: BodyDefs.RName = [BodyDefs.maxRNameLength];
   name3: BodyDefs.RName = [BodyDefs.maxRNameLength];
   name4: BodyDefs.RName = [BodyDefs.maxRNameLength];
   addlist1, addlist2, dellist1, dellist2: Inlist;
   n1, n2: BOOLEAN;
   CreateInlist [@addlist1, name1, reader1];
   CreateInlist [@dellist1, name2, reader1];
   CreateInlist [@addlist2, name3, reader2];
   CreateInlist [@dellist2, name4, reader2];
   [newer1, newer2] _
      MergeSublists [@addlist1, @addlist2, @dellist1, @dellist2, writer];
   ResetInlist [@addlist1];
   ResetInlist [@dellist1];
   ResetInlist [@addlist2];
   ResetInlist [@dellist2];
   [n1, n2] _ 
      MergeSublists [@dellist1, @dellist2, @addlist1, @addlist2, writer];
   newer1 _ newer1 OR n1;
   newer2 _ newer2 OR n2;
   DeleteInlist [@addlist1];
   DeleteInlist [@dellist1];
   DeleteInlist [@addlist2];
   DeleteInlist [@dellist2];
END;


MergeSublists:

PROCEDURE [add1, add2, del1, del2: POINTER TO Inlist, writer: HeapDefs.WriterHandle]
RETURNS [newer1, newer2: BOOLEAN] =
BEGIN
  outlist: Outlist;
  CreateOutlist [@outlist, writer];
  newer1 _ newer2 _ FALSE;
  UNTIL CompareElements [add1, add2] = Null
  DO WHILE CompareElements [add1, add2] = Less
      DO WHILE CompareElements [del2, add1] = Less DO Get [del2] ENDLOOP;
         IF ~(CompareElements [del2, add1] = Equal
              AND Newer [del2, add1])
         THEN BEGIN Put [add1, @outlist]; newer1 _ TRUE END;
         Get [add1]
      ENDLOOP;
      IF CompareElements [add1, add2] = Equal
      THEN BEGIN
             IF Newer [add1, add2]
             THEN BEGIN Put [add1, @outlist]; newer1 _ TRUE END
             ELSE BEGIN Put [add2, @outlist]; newer2 _ TRUE END;
             Get [add1]; Get [add2]
           END;
      WHILE CompareElements [add2, add1]= Less
      DO WHILE CompareElements [del1, add2]= Less DO Get [del1] ENDLOOP;
         IF ~(CompareElements [del1, add2]= Equal
              AND Newer [del1, add2])
         THEN BEGIN Put [add2, @outlist]; newer2 _ TRUE END;
         Get [add2]
      ENDLOOP;
  ENDLOOP;
  DeleteOutlist [@outlist, writer]
END;

CreateInlist:

PROCEDURE [inlist: POINTER TO Inlist, name: BodyDefs.RName,
           reader: HeapDefs.ReaderHandle] =
BEGIN
  inlist.name _ name;
  inlist.RNameReader _ HeapDefs.CopyReader[reader];
  inlist.RNameStart _ HeapDefs.GetReaderOffset[reader];
  Skip[reader];
  inlist.TimestampReader _ HeapDefs.CopyReader [reader];
  inlist.TimestampStart _ HeapDefs.GetReaderOffset[reader];
  Skip[reader];
  inlist.RNameWordsLeft _ ReadComponentLength[inlist.RNameReader];
  inlist.TimestampWordsLeft _ ReadComponentLength[inlist.TimestampReader];
  Get[inlist];
END;

ResetInlist:
PROCEDURE [inlist: POINTER TO Inlist] =
BEGIN
  HeapDefs.SetReaderOffset[inlist.RNameReader, inlist.RNameStart];
  HeapDefs.SetReaderOffset[inlist.TimestampReader, inlist.TimestampStart];
  inlist.RNameWordsLeft _ ReadComponentLength[inlist.RNameReader];
  inlist.TimestampWordsLeft _ ReadComponentLength[inlist.TimestampReader];
  Get[inlist];
END;

DeleteInlist:

PROCEDURE [inlist: POINTER TO Inlist] =
BEGIN
  HeapDefs.HeapEndRead[inlist.RNameReader];
  HeapDefs.HeapEndRead[inlist.TimestampReader];
END;

CreateOutlist:

PROCEDURE [outlist: POINTER TO Outlist, writer: HeapDefs.WriterHandle] =
BEGIN
  outlist.RNameWriter _ writer;
  outlist.RNameStart _ HeapDefs.GetWriterOffset[writer];
  WriteComponentLength[outlist.RNameWriter, 0]--placeholder--;
  outlist.RNameWordsUsed _ 0;
  outlist.TimestampWriter _ HeapDefs.HeapStartWrite[temp];
  outlist.TimestampWordsUsed _ 0;
END;

DeleteOutlist:

PROCEDURE [outlist: POINTER TO Outlist, writer: HeapDefs.WriterHandle] =
BEGIN
  CopyToWriter: PROC [object: HeapDefs.ObjectNumber] =
    BEGIN
    reader: HeapDefs.ReaderHandle = HeapDefs.HeapStartRead [object];
    bLength: CARDINAL = 64;
    buffer: ARRAY [0..bLength) OF WORD;
    length: CARDINAL _ outlist.TimestampWordsUsed;
    WHILE length > 0
    DO used: CARDINAL = HeapDefs.HeapReadData[reader,
                          [@buffer,MIN[length,bLength]] ].used;
      length _ length - used;
      HeapDefs.HeapWriteData[writer, [@buffer,used] ];
    ENDLOOP;
    HeapDefs.HeapEndRead[reader];
    END;
  TimestampStart: HeapDefs.ObjectOffset =
      HeapDefs.GetWriterOffset[outlist.RNameWriter];
  -- write component length for RName list --
  HeapDefs.SetWriterOffset[outlist.RNameWriter, outlist.RNameStart];
  WriteComponentLength[outlist.RNameWriter, outlist.RNameWordsUsed];
  HeapDefs.SetWriterOffset[outlist.RNameWriter, TimestampStart];
  IF outlist.RNameWriter # writer THEN ERROR;
  -- write component length for timestamp list --
  WriteComponentLength[writer, outlist.TimestampWordsUsed];
  -- append timestamp list --
  HeapDefs.HeapEndWrite[outlist.TimestampWriter, CopyToWriter];
END;

Get:

PROCEDURE [inlist: POINTER TO Inlist] =
BEGIN
  IF inlist.RNameWordsLeft > 0
  THEN BEGIN
         [] _ HeapDefs.HeapReadRName [inlist.RNameReader, inlist.name];
         inlist.stamp _ ReadTimestamp [inlist.TimestampReader];
         IF inlist.TimestampWordsLeft < SIZE[BodyDefs.Timestamp]
         OR inlist.RNameWordsLeft < BodyDefs.RNameSize[inlist.name]
         THEN ERROR MangledHeapObject;
         inlist.TimestampWordsLeft _ inlist.TimestampWordsLeft -
                  SIZE[BodyDefs.Timestamp];
         inlist.RNameWordsLeft _
                  inlist.RNameWordsLeft - BodyDefs.RNameSize[inlist.name];
         IF (inlist.TimestampWordsLeft = 0 OR inlist.RNameWordsLeft = 0)
            AND inlist.TimestampWordsLeft + inlist.RNameWordsLeft # 0
         THEN ERROR MangledHeapObject;
         inlist.empty _ FALSE;
       END
  ELSE inlist.empty _ TRUE;
END;

Put:

PROCEDURE [inlist: POINTER TO Inlist, outlist: POINTER TO Outlist] =
BEGIN
  IF inlist.empty THEN ERROR HeapObjectEnded;
  HeapDefs.HeapWriteRName [outlist.RNameWriter, inlist.name];
  outlist.RNameWordsUsed _ outlist.RNameWordsUsed + BodyDefs.RNameSize [inlist.name];
  WriteTimestamp [outlist.TimestampWriter, inlist.stamp];
  outlist.TimestampWordsUsed _ outlist.TimestampWordsUsed +
                           SIZE [BodyDefs.Timestamp];
END;

CompareElements: PROCEDURE [e1, e2: POINTER TO Inlist]
                   RETURNS [{Less, Equal, Greater, Null}] =
BEGIN
  IF e1.empty
  THEN IF e2.empty
       THEN RETURN [Null]
       ELSE RETURN [Greater]
  ELSE IF e2.empty
       THEN RETURN [Less]
       ELSE SELECT CompareRNames [e1.name, e2.name] FROM
              less => RETURN[Less];
              equal => RETURN[Equal];
              greater => RETURN[Greater];
            ENDCASE => ERROR;
END;

Newer: PROCEDURE [e1, e2: POINTER TO Inlist] RETURNS [BOOLEAN] =
   BEGIN
   RETURN [CompareTimestamps [e1.stamp, e2.stamp] = greater]
   END;

CompareRNames: PUBLIC PROC[n1, n2: BodyDefs.RName]
                  RETURNS [RegistryDefs.Comparison] =
   BEGIN
   length: CARDINAL = MIN [n1.length, n2.length];
   i: CARDINAL;
   FOR i IN [0 .. length)
   DO BEGIN
      ch1: CHARACTER = IF n1[i] IN CHARACTER['A .. 'Z] 
                       THEN (n1[i] - 'A) + 'a ELSE n1[i];
      ch2: CHARACTER = IF n2[i] IN CHARACTER['A .. 'Z] 
                       THEN (n2[i] - 'A) + 'a ELSE n2[i];
      IF ch1 < ch2 THEN RETURN [less];
      IF ch1 > ch2 THEN RETURN [greater];
      END
   ENDLOOP;
   IF n1.length < n2.length
   THEN RETURN [less]
   ELSE IF n1.length = n2.length
        THEN RETURN [equal]
        ELSE RETURN [greater];
   END;

futureLimit: CARDINAL _ 14;

CompareTimestamps: PUBLIC ENTRY PROC[t1, t2: BodyDefs.Timestamp]
                      RETURNS [RegistryDefs.Comparison] =
   BEGIN
   -- Garbage check: treat timestamps more than 14 days future as 0 --
   latest: Time.Packed =
     LOOPHOLE[ prevTime + (LONG[futureLimit] * 24) * 60 * 60 ];
   IF t1.time > latest THEN RETURN [less];
   IF t2.time > latest THEN RETURN [greater];
   IF t1.time < t2.time THEN RETURN [less];
   IF t1.time > t2.time THEN RETURN [greater];
   IF t1.net < t2.net THEN RETURN [less];
   IF t1.net > t2.net THEN RETURN [greater];
   IF t1.host < t2.host THEN RETURN [less];
   IF t1.host > t2.host THEN RETURN [greater];
   RETURN [equal]
   END;

prevTime: Time.Packed _ Time.Current[];
aWeeWhile: CONDITION;

MakeTimestamp: PUBLIC ENTRY PROCEDURE RETURNS [stamp: BodyDefs.Timestamp] =
  BEGIN
  newTime: Time.Packed;
  WHILE (newTime _ Time.Current[]) = prevTime
  DO WAIT aWeeWhile -- ensure uniqueness of timestamps -- ENDLOOP;
  stamp.net _ ThisMachine.net;
  stamp.host _ ThisMachine.host;
  stamp.time _ prevTime _ newTime;
  END;

ThisMachine: PupStream.PupAddress;


-- regPurger subroutines --

CheckStampList: PUBLIC PROC[reader: HeapDefs.ReaderHandle,
                     limit: BodyDefs.Timestamp]
              RETURNS[old: BOOLEAN] =
   BEGIN
   length: CARDINAL = ReadComponentLength[reader];
   THROUGH [0..length/SIZE[BodyDefs.Timestamp])
   DO IF CompareTimestamps[ReadTimestamp[reader], limit] = less
      THEN RETURN[TRUE];
   ENDLOOP;
   RETURN[FALSE]
   END;

FilterStampList: PUBLIC PROC[reader: HeapDefs.ReaderHandle,
                      limit: BodyDefs.Timestamp,
                      writer: HeapDefs.WriterHandle] =
   BEGIN
   namePos: HeapDefs.ObjectOffset = HeapDefs.GetWriterOffset[writer];
   nameLength: CARDINAL _ 0;
   stampLength: CARDINAL;
   stampReader: HeapDefs.ReaderHandle = HeapDefs.CopyReader[reader];
   Action: PROC[name: BodyDefs.RName] RETURNS[done:BOOLEAN] =
      BEGIN
      stamp: BodyDefs.Timestamp = ReadTimestamp[stampReader];
      done _ FALSE;
      IF CompareTimestamps[stamp, limit] # less
      THEN BEGIN
           HeapDefs.HeapWriteRName[writer, name];
           nameLength _ nameLength + BodyDefs.RNameSize[name];
           END
      ELSE stampLength _ stampLength - SIZE[BodyDefs.Timestamp];
      END;
   Skip[stampReader];
   stampLength _ ReadComponentLength[stampReader];
   WriteComponentLength[writer, 0];
   EnumerateRList[reader, Action];
   BEGIN
      newPos: HeapDefs.ObjectOffset = HeapDefs.GetWriterOffset[writer];
      HeapDefs.SetWriterOffset[writer, namePos];
      WriteComponentLength[writer, nameLength];
      HeapDefs.SetWriterOffset[writer, newPos];
   END;
   HeapDefs.HeapEndRead[stampReader];
   WriteComponentLength[writer, stampLength];
   THROUGH [0..ReadComponentLength[reader]/SIZE[BodyDefs.Timestamp])
   DO stamp: BodyDefs.Timestamp = ReadTimestamp[reader];
      IF CompareTimestamps[stamp, limit] # less
      THEN WriteTimestamp[writer, stamp];
   ENDLOOP;
   END;

PupDefs.PupNameLookup [@ThisMachine, "ME"];

Process.InitializeCondition[@aWeeWhile, Process.MsecToTicks[100]];

END.