-- PDQueueImpl.mesa
-- Copyright (C) 1984, Xerox Corporation.  All rights reserved.
-- Michael Plass, April 10, 1985 5:28:48 pm PST
-- Tim Diebert,  5-Sep-86 14:00:44
-- 
DIRECTORY Time, Checksum, Environment, Inline, PDInterpSysCalls,
   PDQueue, String, Process;
   
PDQueueImpl: MONITOR
   IMPORTS Time, Checksum, Inline, PDInterpSysCalls, String, Process
   EXPORTS PDQueue
   = BEGIN
   
   Request: TYPE = PDQueue.Request;
      
   readProc: PROC [address: LONG POINTER, nwords: CARDINAL] ¬ NIL;
      
   writeProc: PROC [address: LONG POINTER, nwords: CARDINAL] ¬ NIL;
      
   maxStateWords: CARDINAL ¬ 16*1024;
      
   deferSaving: BOOLEAN ¬ FALSE;
   saveDeferred: BOOLEAN ¬ FALSE;
   state: LONG POINTER TO StringSeqRep ¬ NIL;
   messages: LONG POINTER TO StringSeqRep ¬ NIL;
      
   StringSeqRep: TYPE = MACHINE DEPENDENT RECORD [
      nStrings: CARDINAL,
      end: CARDINAL,
      mark: CARDINAL,
      nMarked: CARDINAL,
      nDiscarded: CARDINAL ¬ 0,
      check: CARDINAL,
      nWords: CARDINAL,
      stringSpace: SEQUENCE COMPUTED CARDINAL OF WORD
      ];
      
   StringRep: TYPE = RECORD [
      nChars: CARDINAL,
      char: PACKED ARRAY [0..0) OF CHAR
      ];
      
   Validate: INTERNAL PROC [s: LONG POINTER TO StringSeqRep] RETURNS [ok: BOOLEAN] = {
      nStrings: CARDINAL ¬ 0;
      nMarked: CARDINAL ¬ 0;
      offset: CARDINAL ¬ 0;
      IF s.check # CalculateCheck[s] THEN RETURN [FALSE];
      IF s.mark > s.end THEN RETURN [FALSE];
      WHILE offset < s.end DO
         words: CARDINAL;
         nStrings ¬ nStrings + 1;
         IF offset > s.mark AND nMarked = 0 THEN RETURN [FALSE];
         IF offset >= s.mark THEN nMarked ¬ nMarked + 1;
         words ¬ (s[offset]+Environment.bytesPerWord-1)/Environment.bytesPerWord+1;
         offset ¬ offset + words;
         ENDLOOP;
      IF offset # s.end THEN RETURN [FALSE];
      IF nStrings # s.nStrings THEN RETURN [FALSE];
      IF nMarked # s.nMarked THEN RETURN [FALSE];
      RETURN [TRUE]
      };
      
   DiscardMessages: INTERNAL PROC [maxWords: CARDINAL] = {
      WHILE messages.end > maxWords DO Discard[messages, 1] ENDLOOP;
      };
      
   Discard: INTERNAL PROC [s: LONG POINTER TO StringSeqRep, n: CARDINAL] = {
      newStart: CARDINAL ¬ StringOffset[s, n];
      Inline.LongCOPY[from: @(s[newStart]), nwords: s.end-newStart, to: @(s[0])];
      s.nStrings ¬ s.nStrings - n;
      s.end ¬ s.mark ¬ s.end-newStart;
      s.nDiscarded ¬ s.nDiscarded + n;
      };
      
   StringOffset: INTERNAL PROC [s: LONG POINTER TO StringSeqRep, n: CARDINAL] RETURNS [offset: CARDINAL] = {
      offset ¬ 0;
      IF n = 0 THEN RETURN;
      IF n > s.nStrings THEN ERROR;
      FOR i: NAT IN [0..n) DO
         offset ¬ NextStringOffset[s, offset];
         ENDLOOP;
      };
      
   NextStringOffset: INTERNAL PROC [s: LONG POINTER TO StringSeqRep, offset: CARDINAL] RETURNS [CARDINAL] = INLINE {
      IF offset >= s.end THEN ERROR
      ELSE {
         words: CARDINAL ¬ (s[offset]+Environment.bytesPerWord-1)/Environment.bytesPerWord+1;
         IF words > s.end-offset THEN ERROR;
         offset ¬ offset + words;
         RETURN [offset];
         };
      };
      
   Append: INTERNAL PROC [s: LONG POINTER TO StringSeqRep, string: LONG STRING] = {
      body: LONG POINTER TO StringRep;
      chars: CARDINAL ¬ IF string = NIL THEN 0 ELSE string.length;
      words: CARDINAL ¬ (string.length+Environment.bytesPerWord-1)/Environment.bytesPerWord+1;
      IF s.mark # s.end THEN ERROR;
      IF s.end+words > s.nWords THEN ERROR;
      body ¬ LOOPHOLE[@(s[s.end])];
      body.nChars ¬ chars;
      FOR i: NAT IN [0..chars) DO
         body.char[i] ¬ string[i];
         ENDLOOP;
      IF chars MOD 2 = 1 THEN body.char[chars] ¬ '\000;
      s.mark ¬ s.end ¬ s.end+words;
      s.nStrings ¬ s.nStrings + 1;
      };
      
   AppendToString: INTERNAL PROC [string: LONG STRING, s: LONG POINTER TO StringSeqRep, offset: CARDINAL] = {
      body: LONG POINTER TO StringRep;
      IF offset >= s.end THEN ERROR;
      IF offset+(s[offset]+Environment.bytesPerWord-1)/Environment.bytesPerWord+1 > s.end THEN ERROR;
      body ¬ LOOPHOLE[@(s[offset])];
      FOR i: NAT IN [0..body.nChars) DO
         string[string.length] ¬ body.char[i];
         string.length ¬ string.length + 1;
         ENDLOOP;
      };
      
   MoveToString: INTERNAL PROC [string: LONG STRING, s: LONG POINTER TO StringSeqRep, offset: CARDINAL] = {
      string.length ¬ 0;
      AppendToString[string, s, offset];
      };
      
   GetNumberDiscardedMessages: ENTRY PROC RETURNS [CARDINAL] = {
      IF messages = NIL THEN Restore[];
      RETURN [messages.nDiscarded];
      };
      
   GetString: ENTRY PROC [string: LONG STRING, s: LONG POINTER TO StringSeqRep, n: CARDINAL] RETURNS [ok: BOOLEAN] = {
      string.length ¬ 0;
      IF n-s.nDiscarded > 32767 THEN RETURN [TRUE];
         -- funny condition due to unsigned arithmetic . . . nDiscarded may wrap
      IF n-s.nDiscarded >= s.nStrings THEN RETURN [FALSE];
      AppendToString[string, s, StringOffset[s, n-s.nDiscarded]];
      RETURN [TRUE];
      };
      
   MoveMarkedStrings: INTERNAL PROC [from, to: LONG POINTER TO StringSeqRep] = {
      nwords: CARDINAL ¬ from.end-from.mark;
      IF to.nWords < to.mark+nwords THEN ERROR;
      to.nStrings ¬ to.nStrings - to.nMarked;
      to.nMarked ¬ 0;
      to.end ¬ to.mark;
      Inline.LongCOPY[from: @(from[from.mark]), nwords: nwords, to: @(to[to.mark])];
      to.nStrings ¬ to.nStrings + from.nMarked;
      to.nMarked ¬ from.nMarked;
      to.end ¬ to.end + nwords;
      from.nStrings ¬ from.nStrings-from.nMarked;
      from.nMarked ¬ 0;
      from.end ¬ from.mark;
      };
      
   CalculateCheck: INTERNAL PROC [s: LONG POINTER TO StringSeqRep] RETURNS [CARDINAL] = {
      cs: CARDINAL ¬ Checksum.ComputeChecksum[nWords: 5, p: s];
      cs ¬ Checksum.ComputeChecksum[cs: cs, nWords: 1, p: s+6];
      RETURN [cs];
      };
      
   Save: INTERNAL PROC = {
      IF deferSaving THEN {saveDeferred ¬ TRUE; RETURN};
      IF state = NIL THEN ERROR;
      DiscardMessages[state.nWords-state.end];
      messages.nMarked ¬ messages.nStrings;
      messages.mark ¬ 0;
      MoveMarkedStrings[from: messages, to: state];
      state.check ¬ CalculateCheck[state];
      IF NOT Validate[state] THEN ERROR;
      IF writeProc # NIL THEN {
         usingDisk ¬ Process.GetCurrent[];
         writeProc[state, SIZE[StringSeqRep[state.end]]];
         usingDisk ¬ NIL;
         };
      MoveMarkedStrings[from: state, to: messages];
      messages.nMarked ¬ 0;
      messages.mark ¬ messages.end;
      saveDeferred ¬ FALSE;
      };
      
   Restore: INTERNAL PROC = {
      IF state # NIL THEN ERROR;
      IF readProc # NIL THEN {
         temp: LONG POINTER TO StringSeqRep ¬ PDInterpSysCalls.AllocateSpace[256];
         usingDisk ¬ Process.GetCurrent[];
         readProc[temp, 256];
         usingDisk ¬ NIL;
         IF temp.check = CalculateCheck[temp] THEN {
            words: CARDINAL ¬ SIZE[StringSeqRep[temp.end]];
            wordsAllocated: CARDINAL ¬ MAX[maxStateWords, words+255]/256*256;
            IF wordsAllocated <= maxStateWords THEN {
               state ¬ PDInterpSysCalls.AllocateSpace[wordsAllocated];
               usingDisk ¬ Process.GetCurrent[];
               readProc[state, words];
               usingDisk ¬ NIL;
               state.nWords ¬ wordsAllocated-SIZE[StringSeqRep[0]];
               IF Validate[state] THEN {
                  AllocMessages[];
                  MoveMarkedStrings[from: state, to: messages];
                  messages.nMarked ¬ 0;
                  messages.mark ¬ messages.end;
                  firstUnprintedMessage ¬ messages.nDiscarded+messages.nStrings-24;
                     -- it should be ok if this wraps around.
                  }
               ELSE {
                  PDInterpSysCalls.FreeSpace[state];
                  state ¬ NIL
                  };
               };
            };
         PDInterpSysCalls.FreeSpace[temp];
         temp ¬ NIL;
         };
      IF state = NIL THEN InternalReset[];
      };
      
   AllocMessages: INTERNAL PROC = {
      wordsAllocated: CARDINAL ¬ SIZE[StringSeqRep[state.nWords]];
      IF messages # NIL THEN {PDInterpSysCalls.FreeSpace[messages]; messages ¬ NIL};
      messages ¬ PDInterpSysCalls.AllocateSpace[wordsAllocated];
      messages.nWords ¬ wordsAllocated-SIZE[StringSeqRep[0]];
      messages.nStrings ¬ messages.end ¬ messages.mark ¬ messages.nMarked ¬ messages.nDiscarded ¬ 0;
      };
      
   InternalReset: INTERNAL PROC = {
      IF state # NIL THEN {PDInterpSysCalls.FreeSpace[state]; state ¬ NIL};
      state ¬ PDInterpSysCalls.AllocateSpace[maxStateWords];
      state.nWords ¬ maxStateWords-SIZE[StringSeqRep[0]];
      state.nStrings ¬ state.end ¬ state.mark ¬ state.nMarked ¬ state.nDiscarded ¬ 0;
      AllocMessages[];
      };
      
   Reset: PUBLIC ENTRY PROC = {InternalReset[]; Save[]};
      
   newRequest: CONDITION;
      
   stringsPerRequest: CARDINAL = 6;
      
   requestLimit: CARDINAL ¬ 1000;
      -- Requests are numbered modulo this number.
      
   ReqNumberFromStringNumber: PROC [stringNumber: CARDINAL] RETURNS [requestNumber: CARDINAL] = {
      requestNumber ¬ (stringNumber/stringsPerRequest) MOD requestLimit;
      };
      
   DecodeCopies: PROC [tag: LONG STRING] RETURNS [copies: CARDINAL] = {
      copies ¬ ORD[tag[2]]*256+ORD[tag[3]];
      };
      
   QueueRequest: PUBLIC ENTRY PROC [request: Request] RETURNS [requestNumber: INT] = {
      ENABLE UNWIND => NULL;
      tag: LONG STRING ¬ [4];
      wordsNeeded: INT ¬ 2*(INT[4]+request.fileName.length+request.requestTime.length+request.requestor.length+request.requestorPassword.length+request.separator.length) + stringsPerRequest*(SIZE[StringRep]+1);
      IF state = NIL THEN Restore[];
      IF state.nStrings >= stringsPerRequest*requestLimit THEN RETURN [-1];
      IF state.end+wordsNeeded+10 >= state.nWords THEN RETURN [-1];
      requestNumber ¬ ReqNumberFromStringNumber[state.nStrings+state.nDiscarded];
      String.AppendString[tag, "  "];
      String.AppendChar[tag, VAL[Inline.HighByte[CARDINAL[request.copies]]]];
      String.AppendChar[tag, VAL[Inline.LowByte[CARDINAL[request.copies]]]];
      Append[state, tag];
      Append[state, request.fileName];
      Append[state, request.requestTime];
      Append[state, request.requestor];
      Append[state, request.requestorPassword];
      Append[state, request.separator];
      IF stringsPerRequest # 6 THEN ERROR;
      BEGIN
         msg: LONG STRING ¬ [250];
         String.AppendString[msg, request.fileName];
         IF request.copies#1 THEN {
            String.AppendString[msg, " ("];
            String.AppendDecimal[msg, request.copies];
            String.AppendString[msg, " copies)"];
            };
         InternalLogMessage[msg, requestNumber, request.requestor];
         END;
         Save[];
      NOTIFY newRequest;
      };
      
   reprintCopies: CARDINAL ¬ 0;
   reprintCancelled: BOOLEAN ¬ FALSE;
      
   Reprint: PUBLIC ENTRY PROC [copies: CARDINAL] = {
      reprintCancelled ¬ FALSE;
      reprintCopies ¬ reprintCopies + copies;
      NOTIFY newRequest;
      };
      
   CancelReprint: PUBLIC ENTRY PROC = {
      reprintCancelled ¬ TRUE;
      reprintCopies ¬ 0;
      };
      
   ReprintCancelled: PUBLIC PROC RETURNS [BOOLEAN] = {RETURN [reprintCancelled]};
      
   printingSuspended: BOOLEAN ¬ FALSE;
      
   GetSuspended: PUBLIC ENTRY PROC RETURNS [BOOLEAN] = {RETURN [printingSuspended]};
   SetSuspended: PUBLIC ENTRY PROC [suspended: BOOLEAN] RETURNS [old: BOOLEAN] = {
      old ¬ printingSuspended;
      printingSuspended ¬ suspended;
      NOTIFY newRequest;
      };
      
   abortCurrent: BOOLEAN;
      
   FirstRequest: ENTRY PROC RETURNS [requestNumber: CARDINAL] = {
      ENABLE UNWIND => NULL;
      IF state = NIL THEN Restore[];
      requestNumber ¬ ReqNumberFromStringNumber[state.nDiscarded];
      };
      
   FindRequest: ENTRY PROC [requestNumber: CARDINAL, tag: LONG STRING, request: Request] = {
      ENABLE UNWIND => NULL;
      stringNumber: CARDINAL ¬ requestNumber*stringsPerRequest;
      offset: CARDINAL ¬ 0;
      IF state = NIL THEN Restore[];
      WHILE stringNumber < state.nDiscarded DO stringNumber ¬ stringNumber + requestLimit*stringsPerRequest ENDLOOP;
      IF stringNumber-state.nDiscarded >= state.nStrings THEN RETURN;
      offset ¬ StringOffset[state, stringNumber-state.nDiscarded];
      MoveToString[tag, state, offset]; offset ¬ NextStringOffset[state, offset];
      MoveToString[request.fileName, state, offset]; offset ¬ NextStringOffset[state, offset];
      MoveToString[request.requestTime, state, offset]; offset ¬ NextStringOffset[state, offset];
      MoveToString[request.requestor, state, offset]; offset ¬ NextStringOffset[state, offset];
      MoveToString[request.requestorPassword, state, offset]; offset ¬ NextStringOffset[state, offset];
      MoveToString[request.separator, state, offset];
      IF stringsPerRequest # 6 THEN ERROR;
      };
      
   GetRequest: ENTRY PROC [request: Request] RETURNS [requestNumber: INT, copies: CARDINAL] = {
      ENABLE UNWIND => NULL;
      tag: LONG STRING ¬ [4];
      IF state = NIL THEN Restore[];
      DO
         offset: CARDINAL ¬ 0;
         WHILE printingSuspended OR (state.nStrings = 0 AND reprintCopies = 0) DO WAIT newRequest ENDLOOP;
         abortCurrent ¬ FALSE;
         reprintCancelled ¬ FALSE;
         IF reprintCopies # 0 THEN {
            requestNumber ¬ -1;
            copies ¬ reprintCopies;
            reprintCopies ¬ 0;
            RETURN;
            };
         requestNumber ¬ ReqNumberFromStringNumber[state.nDiscarded];
         MoveToString[tag, state, offset]; offset ¬ NextStringOffset[state, offset];
         MoveToString[request.fileName, state, offset]; offset ¬ NextStringOffset[state, offset];
         MoveToString[request.requestTime, state, offset]; offset ¬ NextStringOffset[state, offset];
         MoveToString[request.requestor, state, offset]; offset ¬ NextStringOffset[state, offset];
         MoveToString[request.requestorPassword, state, offset]; offset ¬ NextStringOffset[state, offset];
         MoveToString[request.separator, state, offset];
         copies ¬ DecodeCopies[tag];
         IF stringsPerRequest # 6 THEN ERROR;
         IF tag[0] = '  THEN EXIT;
         Discard[state, stringsPerRequest];
         WHILE state.nDiscarded >= stringsPerRequest*requestLimit DO
            state.nDiscarded ¬ state.nDiscarded - stringsPerRequest*requestLimit;
            ENDLOOP;
         ENDLOOP;
      };
      
   RemoveRequest: ENTRY PROC [requestNumber: CARDINAL] = {
      ENABLE UNWIND => NULL;
      IF state = NIL THEN Restore[];
      IF requestNumber # ReqNumberFromStringNumber[state.nDiscarded] THEN ERROR;
      Discard[state, stringsPerRequest];
      WHILE state.nDiscarded >= stringsPerRequest*requestLimit DO
         state.nDiscarded ¬ state.nDiscarded - stringsPerRequest*requestLimit;
         ENDLOOP;
      Save[];
      };
      
   DeferSaving: PUBLIC ENTRY PROC = {
      ENABLE UNWIND => NULL;
      deferSaving ¬ TRUE;
      };
      
   DoDeferredSave: PUBLIC ENTRY PROC = {
      ENABLE UNWIND => NULL;
      deferSaving ¬ FALSE;
      IF saveDeferred THEN Save[];
      };
      
   DoRequest: PUBLIC PROC [action: PROC [request: Request, requestNumber: CARDINAL, abort: LONG POINTER TO BOOLEAN]] = {
      fileName: LONG STRING ¬ [80];
      requestTime: LONG STRING ¬ [20];
      requestor: LONG STRING ¬ [80];
      requestorPassword: LONG STRING ¬ [80];
      separator: LONG STRING ¬ [80];
      requestNumber: INT;
      body: LONG POINTER TO StringRep;
      copies: CARDINAL;
      aborted: BOOLEAN ¬ FALSE;
      [requestNumber, copies] ¬ GetRequest[[fileName, requestTime, requestor, requestorPassword, separator, 0]];
      IF requestNumber < 0 THEN {
         LogMessage["Reprint."];
         action[[NIL, NIL, NIL, NIL, NIL, copies], NAT.LAST, @abortCurrent ! ABORTED => {aborted ¬ TRUE; CONTINUE}];
         LogMessage["Reprint completed."];
         }
      ELSE {
         body ¬ LOOPHOLE[@(state[0])];
         IF body.nChars # 4 THEN ERROR;
         body.char[1] ¬ 'P;
         LogMessage["Started.", requestNumber, requestor];
         action[[fileName, requestTime, requestor, requestorPassword, separator, copies], requestNumber, @abortCurrent ! ABORTED => {aborted ¬ TRUE; CONTINUE}];
         IF aborted THEN LogMessage["Aborted.", requestNumber, requestor]
         ELSE LogMessage["Completed.", requestNumber, requestor];
         RemoveRequest[requestNumber];
         };
      };
      
   CancelRequest: PUBLIC ENTRY PROC [requestNumber: CARDINAL] RETURNS [ok: BOOLEAN] = {
      stringNumber: CARDINAL ¬ requestNumber*stringsPerRequest;
      body: LONG POINTER TO StringRep;
      IF state = NIL THEN Restore[];
      WHILE stringNumber < state.nDiscarded DO
         stringNumber ¬ stringNumber+requestLimit*stringsPerRequest
         ENDLOOP;
      IF stringNumber-state.nDiscarded >= state.nStrings THEN RETURN [FALSE];
      body ¬ LOOPHOLE[@(state[StringOffset[state, stringNumber-state.nDiscarded]])];
      IF body.nChars # 4 THEN ERROR;
      IF body.char[0] # '  THEN RETURN [FALSE];
      body.char[0] ¬ 'X;
      IF stringNumber = state.nDiscarded THEN abortCurrent ¬ TRUE;
      Save[];
      RETURN [TRUE];
      };
      -- 
   RequestStatus: TYPE = PDQueue.RequestStatus;
   CheckRequest: PUBLIC PROC [requestNumber: CARDINAL, action: PROC [request: Request, status: RequestStatus]] = {
      tag: LONG STRING ¬ [4];
      status: RequestStatus;
      fileName: LONG STRING ¬ [80];
      requestTime: LONG STRING ¬ [20];
      requestor: LONG STRING ¬ [80];
      requestorPassword: LONG STRING ¬ [80];
      separator: LONG STRING ¬ [80];
      tag.length ¬ 0;
      FindRequest[requestNumber, tag, [fileName, requestTime, requestor, requestorPassword, separator, 0]];
      IF tag.length = 0 THEN status ¬ notFound
      ELSE IF tag[0] = 'X THEN status ¬ canceled
      ELSE IF tag[1] = 'P THEN status ¬ printing
      ELSE status ¬ waiting;
      action[[fileName, requestTime, requestor, requestorPassword, separator, DecodeCopies[tag]], status];
      };
      
   CountRequests: PUBLIC ENTRY PROC RETURNS [requestCount: NAT] = {
      IF state = NIL THEN Restore[];
      requestCount ¬ state.nStrings/stringsPerRequest;
      };
      
   EnumerateRequests: PUBLIC PROC [action: PROC [requestNumber: CARDINAL, request: Request, status: RequestStatus] RETURNS [continue: BOOLEAN]] = {
      firstRequest: NAT ¬ FirstRequest[];
      nRequests: NAT ¬ CountRequests[];
      requestNumber: NAT ¬ firstRequest MOD requestLimit;
      THROUGH [0..nRequests) DO
         continue: BOOLEAN ¬ TRUE;
         myAction: PROC [request: Request, status: RequestStatus] = {
            IF status = printing OR status = waiting THEN continue ¬ action[requestNumber, request, status];
            };
         
         CheckRequest[requestNumber MOD requestLimit, myAction];
         IF NOT continue THEN EXIT;
         requestNumber ¬ (requestNumber + 1) MOD requestLimit;
         ENDLOOP;
      };
      
   RegisterDisk: PUBLIC ENTRY PROC [read, write: PROC [address: LONG POINTER, nwords: CARDINAL], maxWords: CARDINAL] = {
      IF state # NIL THEN {
         PDInterpSysCalls.FreeSpace[state];
         state ¬ NIL;
         };
      readProc ¬ read;
      writeProc ¬ write;
      maxStateWords ¬ maxWords;
      };
      
   usingDisk: PROCESS ¬ NIL;
      -- Records the process using the disk under the monitor, to avoid deadlocks in case of disk errors.
   LogMessage: PUBLIC PROC [message: LONG STRING, requestNumber: INT ¬ -1, userName: LONG STRING ¬ NIL] = {
      IF usingDisk = Process.GetCurrent[] THEN {
         IF writeLineProc = NIL THEN ERROR;
            -- Remote debug if it ever gets this bad.
         writeLineProc["Help!" ! ABORTED => CONTINUE];
         writeLineProc[message ! ABORTED => CONTINUE];
         }
      ELSE LogMessageEntry[message, requestNumber, userName];
      };
      
   LogMessageEntry: ENTRY PROC [message: LONG STRING, requestNumber: INT ¬ -1, userName: LONG STRING ¬ NIL] = {
      InternalLogMessage[message, requestNumber, userName];
      };
      
   InternalLogMessage: INTERNAL PROC [message: LONG STRING, requestNumber: INT ¬ -1, userName: LONG STRING ¬ NIL] = {
      msg: LONG STRING ¬ [250];
      Time.AppendCurrent[msg];
      msg[msg.length] ¬ ' ; msg.length ¬ msg.length + 1;
      IF requestNumber >= 0 THEN {
         String.AppendChar[msg, 'R];
         FOR i: CARDINAL ¬ requestLimit/10, i/10 WHILE i#0 DO
            String.AppendDecimal[msg, (requestNumber/i) MOD 10];
            ENDLOOP;
         String.AppendChar[msg, ' ];
         };
      String.AppendString[msg, message];
      IF userName#NIL THEN {
         String.AppendString[msg, " ("];
         String.AppendString[msg, userName];
         String.AppendChar[msg, ')];
         };
      IF state = NIL THEN Restore[];
      DiscardMessages[messages.nWords-SIZE[StringBody[msg.length]]];
      Append[messages, msg];
      TryToPrintMessages[];
      };
      
   loggingMessages: BOOLEAN ¬ FALSE;
   firstUnprintedMessage: CARDINAL ¬ 0;
   writeLineProc: PROC[LONG STRING] ¬ NIL;
      
   RegisterTTY: PUBLIC ENTRY PROC [writeLine: PROC[LONG STRING]] = {
      writeLineProc ¬ writeLine;
      TryToPrintMessages[];
      };
      
   TryToPrintMessages: INTERNAL PROC = {
      msg: LONG STRING ¬ [250];
      GetMsg: INTERNAL PROC [n: CARDINAL] RETURNS [ok: BOOLEAN] = {
         msg.length ¬ 0;
         IF n-messages.nDiscarded > 32767 THEN RETURN [TRUE];
            -- funny condition due to unsigned arithmetic . . . nDiscarded may wrap
         IF n-messages.nDiscarded >= messages.nStrings THEN RETURN [FALSE];
         AppendToString[msg, messages, StringOffset[messages, n-messages.nDiscarded]];
         RETURN [TRUE];
         };
      IF NOT loggingMessages OR writeLineProc = NIL THEN RETURN;
      FOR i: CARDINAL ¬ firstUnprintedMessage, i+1 UNTIL NOT GetMsg[i] DO
         writeLineProc[msg ! ABORTED => CONTINUE];
         firstUnprintedMessage ¬ i+1;
         ENDLOOP;
      };
      
   SetLogState: PUBLIC ENTRY PROC [logging: BOOLEAN] RETURNS [old: BOOLEAN] = {
      old ¬ loggingMessages;
      loggingMessages ¬ logging;
      IF messages # NIL THEN TryToPrintMessages[];
      };
      
   EnumerateMessages: PUBLIC PROC [action: PROC[message: LONG STRING] RETURNS [continue: BOOLEAN]] = {
      msg: LONG STRING ¬ [250];
      FOR i: CARDINAL ¬ GetNumberDiscardedMessages[], i+1 UNTIL NOT GetString[msg, messages, i] DO
         IF NOT action[msg].continue THEN EXIT;
         ENDLOOP;
      };
   
   END.