
    <<SunYPAgentImpl.mesa>>
        <<Copyright Ó 1989, 1991, 1992 by Xerox Corporation.  All rights reserved.>>
        <<Demers, November 28, 1988 10:47:03 am PST>>
        <<Alan Ishigo November 29, 1988 2:24:19 pm PST>>
        <<Willie-sue, January 18, 1993 3:27 pm PST>>
        <<>>
        <<TODO: the null server stuff is baroque.>>
        <<Chauser, January 3, 1992 11:07 am PST>>

    DIRECTORY
        Arpa USING [Address, MyAddress, nullAddress],
        ArpaUDP USING [nullPort, Port],
        Ascii USING [CR, FF, LF, SP, TAB],
        Basics USING [HFromCard16, IsBound, LowHalf],
        BasicTime USING [earliestGMT, GMT, Now, Period, TimeNotKnown, Update],
        Convert USING [RopeFromArpaAddress],
        Process USING [Detach, PauseMsec],
        RefText USING [Append, New, ObtainScratch, ReleaseScratch],
        Rope USING [FromRefText, Length, ROPE, Substr, ToRefText],
        SunPMap USING [udpPort],
        SunRPC USING [Destroy, Error, Handle],
        SunRPCOnUDP USING [Create, SetRemote],
        SunRPCAuth USING [Conversation, Error, Initiate, Terminate],
        SunYP USING [EachMapNameProc, ResponseKeyVal, ResponseVal, Status],
        SunYPAgent USING [TextSeq, TextSeqObject],
        SunYPAgentPrivate USING [Object, ServerObject],
        SunYPClient USING [First, Maplist, Match, Next, Null],
        SunYPFind USING [Error, GetDefaultDomain, GetServerAddressAndPortForDomain],
        SymTab USING [Create, Fetch, Ref, Store, Update, UpdateAction, Val],
        ThisMachineRegistry USING [ThisMachineProcsRec, ThisMachineRef, RegisterThisMachineProcs]
        ;

    SunYPAgentImpl: CEDAR MONITOR
        LOCKS lock USING lock: Lock
        IMPORTS Arpa, Basics, BasicTime, Convert, Process, RefText, Rope, SunRPC, SunRPCOnUDP, SunRPCAuth, SunYPClient, SunYPFind, SymTab, 
        ThisMachineRegistry
        EXPORTS SunYPAgent
        ~ {
        <<Parameters>>
            msecBetweenSweeps: CARD Ź 11111;
            initialServerTTL: CARDINAL Ź 300;
            initialCachedValueTTL: CARDINAL Ź 300;

            maxCachedValues: CARDINAL Ź 31;

            timeoutBase: CARD Ź 500;
            timeoutMsecPerHop: CARD Ź 250;
            pauseMsecPerHop: CARD Ź 100;

            maxTriesForSpecifiedServer: CARDINAL Ź 8;
            pauseMsecBetweenRetriesForSpecifiedServer: CARD Ź 1000;

            pMapPort: ArpaUDP.Port Ź Basics.HFromCard16[Basics.LowHalf[SunPMap.udpPort]];
            maxArgLength: CARDINAL Ź 100;

            hostsMapName: ROPE Ź "hosts.byaddr";
            hostNamePos: CARDINAL = 1;
        <<Types>>
            ROPE: TYPE ~ Rope.ROPE;

            Lock: TYPE ~ REF LockObject;
            LockObject: TYPE ~ MONITORED RECORD [];

            Error: PUBLIC ERROR [code: ATOM] ~ CODE;
        <<Server Cache>>
            Server: TYPE ~ REF ServerObject;
            ServerObject: TYPE ~ SunYPAgentPrivate.ServerObject;

            serverTab: SymTab.Ref Ź SymTab.Create[];

            serverLock: Lock ~ NEW[LockObject];
            serverList: Server Ź NIL;
            nullServerLock: Lock ~ NEW[LockObject];
            nullServerList: Server Ź NIL;

            GetServerByAddressAndPort: ENTRY PROC [address: Arpa.Address, port: ArpaUDP.Port, lock: Lock Ź serverLock] RETURNS [server: Server] 
            ~ {
                FOR server Ź serverList, server.next
                WHILE (server # NIL) AND ((server.address # address) OR (server.port # port))
                    DO NULL ENDLOOP;
                IF server = NIL THEN {
                    server Ź NEW[ServerObject Ź [serverList, address, port, initialServerTTL, FALSE]];
                    serverList Ź server;
                    };
                };

            SweepServers: ENTRY PROC [seconds: CARD, lock: Lock Ź serverLock] ~ {
                FOR server: Server Ź serverList, server.next WHILE server # NIL DO
                    server.ttl Ź (IF server.ttl > seconds THEN server.ttl - seconds ELSE 0);
                    ENDLOOP;
                };

            IsNullServer: PROC [server: Server] RETURNS [BOOL] ~ INLINE {
                RETURN [server.address = Arpa.nullAddress] };

            GetNullServer: ENTRY PROC [lock: Lock Ź nullServerLock] RETURNS [server: Server] ~ {
                server Ź NEW[ServerObject Ź [nullServerList, Arpa.nullAddress, ArpaUDP.nullPort, initialServerTTL, FALSE]];
                nullServerList Ź server;
                };

            SweepNullServers: ENTRY PROC [seconds: CARD, lock: Lock Ź nullServerLock] ~ {
                prev, server: Server;
                prev Ź NIL; server Ź nullServerList;
                WHILE server # NIL DO
                    IF server.ttl > seconds
                        THEN {
                            server.ttl Ź server.ttl - seconds;
                            prev Ź server;
                            }
                        ELSE {
                            server.ttl Ź 0;
                            IF prev = NIL THEN nullServerList Ź server.next ELSE prev.next Ź server.next;
                            };
                    server Ź server.next;
                    ENDLOOP;
                };

            GetServerForDomain: PROC [domain: ROPE] RETURNS [server: Server] ~ {
                <<This never raises Error, may store a down server in serverTab.>>
                server Ź NARROW[SymTab.Fetch[serverTab, domain].val];
                SELECT TRUE FROM
                    (server = NIL) => NULL;
                    (IsNullServer[server]) => IF server.ttl = 0 THEN server Ź NIL;
                    (server.down) => server Ź NIL;
                    (server.ttl = 0) AND (NOT ServerResponding[server]) => server Ź NIL;
                        <<NOTE: ServerResponding[server] will set server.down appropriately.>>
                    ENDCASE;
                IF server # NIL THEN RETURN;
                -- IF server = NIL THEN -- {
                    address: Arpa.Address Ź Arpa.nullAddress;
                    port: ArpaUDP.Port Ź ArpaUDP.nullPort;
                    [address, port] Ź SunYPFind.GetServerAddressAndPortForDomain[domain
                    ! SunYPFind.Error => CONTINUE];
                    IF address # Arpa.nullAddress THEN server Ź GetServerByAddressAndPort[address, port];
                    };
                IF server = NIL THEN {
                    server Ź GetNullServer[];
                    };
                [] Ź SymTab.Store[serverTab, domain, server];
                };

            GetServerByAddress: PROC [address: Arpa.Address, domain: ROPE]
            RETURNS [server: Server] ~ {
                <<Raises Error if the specified server can't be contacted or doesn't serve the specified domain.>>
                errorCode: ATOM Ź NIL;
                port: ArpaUDP.Port;
                [, port] Ź SunYPFind.GetServerAddressAndPortForDomain[domain, address
                ! SunYPFind.Error => { errorCode Ź code; CONTINUE } ];
                IF errorCode = NIL
                    THEN {
                        server Ź GetServerByAddressAndPort[address, port];
                        server.down Ź FALSE;
                        server.ttl Ź initialServerTTL;
                        [] Ź SymTab.Store[serverTab, domain, server];
                        }
                    ELSE {
                        ERROR Error[errorCode];
                        };
                };

            ServerResponding: PROC [server: Server] RETURNS [responding: BOOL Ź FALSE] ~ {
                h: SunRPC.Handle;
                c: SunRPCAuth.Conversation;
                IF NOT IsNullServer[server] THEN {
                    ENABLE SunRPC.Error, SunRPCAuth.Error => CONTINUE;
                    h Ź SunRPCOnUDP.Create[remoteAddress~server.address, remotePort~server.port];
                    c Ź SunRPCAuth.Initiate[];
                    server.ttl Ź initialServerTTL;
                    SunYPClient.Null[h, c];
                    responding Ź TRUE;
                    };
                server.down Ź NOT responding;
                IF h # NIL THEN SunRPC.Destroy[h]; h Ź NIL;
                IF c # NIL THEN SunRPCAuth.Terminate[c]; c Ź NIL;
                };
        <<Handles>>
            Handle: TYPE ~ REF Object;
            Object: PUBLIC TYPE ~ SunYPAgentPrivate.Object;

            ObtainHandle: PUBLIC PROC [domainName: ROPE, conversation: SunRPCAuth.Conversation, serverAddress: Arpa.Address] RETURNS [h: 
            Handle] ~ {
                server: Server Ź NIL;
                rpcHandle: SunRPC.Handle;
                serverSpecified: BOOL Ź (serverAddress # Arpa.nullAddress);
                IF domainName = NIL THEN domainName Ź SunYPFind.GetDefaultDomain[];
                IF serverSpecified
                    THEN {
                        FOR try: CARDINAL Ź 0, try.SUCC DO
                            server Ź GetServerByAddress[serverAddress, domainName
                                ! Error => IF try >= maxTriesForSpecifiedServer THEN REJECT ELSE CONTINUE];
                            IF server # NIL THEN EXIT;
                            Process.PauseMsec[pauseMsecBetweenRetriesForSpecifiedServer];
                            ENDLOOP;
                        }
                    ELSE {
                        server Ź GetServerForDomain[domainName];
                        IF IsNullServer[server] THEN ERROR Error[$domainNotFound];
                        };
                IF conversation = NIL THEN conversation Ź SunRPCAuth.Initiate[];
                rpcHandle Ź SunRPCOnUDP.Create[remoteAddress~server.address, remotePort~server.port];
                h Ź NEW[Object Ź [domain~domainName, server~server, rpcHandle~rpcHandle, conversation~conversation, 
                serverSpecified~serverSpecified]];
                };

            RefreshHandle: PUBLIC PROC [h: Handle, conversation: SunRPCAuth.Conversation, serverAddress: Arpa.Address] ~ {
                server: Server;
                IF serverAddress = Arpa.nullAddress
                    THEN {
                        server Ź GetServerForDomain[h.domain];
                        IF IsNullServer[server] THEN ERROR Error[$domainNotFound];
                        }
                    ELSE {
                        server Ź GetServerByAddress[serverAddress, h.domain];
                        };
                SunRPCAuth.Terminate[h.conversation];
                h.conversation Ź IF conversation # NIL THEN conversation ELSE SunRPCAuth.Initiate[];
                IF server # h.server THEN {
                    h.server Ź server;
                    h.rpcHandle Ź SunRPCOnUDP.SetRemote[h.rpcHandle, server.address, server.port];
                    };
                };

            ReleaseHandle: PUBLIC PROC [h: Handle] ~ {
                IF h.rpcHandle # NIL THEN { SunRPC.Destroy[h.rpcHandle]; h.rpcHandle Ź NIL };
                h.server Ź NIL;
                IF h.conversation # NIL THEN { SunRPCAuth.Terminate[h.conversation]; h.conversation Ź NIL };
                };

            FixupForDownServer: PROC [h: Handle] RETURNS [fixed: BOOL Ź FALSE] ~ {
                ENABLE Error => CONTINUE;
                oldServer: Server;
                IF h.serverSpecified THEN RETURN;
                oldServer Ź h.server;
                h.server Ź GetServerForDomain[h.domain];
                IF IsNullServer[h.server] THEN RETURN;
                IF h.server.address = oldServer.address THEN RETURN;
                IF h.server.down THEN RETURN;
                fixed Ź TRUE;
                };
        <<Match Response Cache>>
            CachedValue: TYPE ~ REF CachedValueObject;
            CachedValueObject: TYPE ~ RECORD [
                next, prev: CachedValue,
                ttl: CARDINAL Ź initialCachedValueTTL,
                busy: CARDINAL Ź 0,
                value: REF TEXT,
                key: ROPE,
                table: SymTab.Ref
                ];

            cachedValueLock: Lock ~ NEW[LockObject];
            cachedValueHead, cachedValueTail: CachedValue;
            numCachedValues: CARD Ź 0;
            cachedValueAvailable: CONDITION;

            tabByDomain: SymTab.Ref ~ SymTab.Create[];

            RemoveCachedValueFromTable: PROC [cV: CachedValue] ~ {
                value: SymTab.Val ~ cV;
                DeleteValue: SymTab.UpdateAction -- [found, val] RETURNS [op, new] -- ~ {
                    IF found AND val = value
                        THEN RETURN [delete, NIL]
                        ELSE RETURN [none, NIL];
                    };
                IF (cV.table = NIL) OR (cV.key = NIL) THEN ERROR;
                SymTab.Update[cV.table, cV.key, DeleteValue];
                };

            RemoveCachedValueFromList: INTERNAL PROC [cV: CachedValue] ~ {
                IF cV = cachedValueTail
                    THEN cachedValueTail Ź cV.prev
                    ELSE cV.next.prev Ź cV.prev;
                IF cV = cachedValueHead
                    THEN cachedValueHead Ź cV.next
                    ELSE cV.prev.next Ź cV.next;
                };

            LookupCachedValue: ENTRY PROC [domainName, mapName, key: ROPE, lock: Lock Ź cachedValueLock] RETURNS [cV: CachedValue] ~ {
                tabByMap, tabByKey: SymTab.Ref;
                GetTabByMap: SymTab.UpdateAction -- [found, val] RETURNS [op, new] -- ~ {
                    IF found
                        THEN { tabByMap Ź NARROW[val]; RETURN [none, NIL] }
                        ELSE { tabByMap Ź SymTab.Create[]; RETURN [store, tabByMap] };
                    };
                GetTabByKey: SymTab.UpdateAction -- [found, val] RETURNS [op, new] -- ~ {
                    IF found
                        THEN { tabByKey Ź NARROW[val]; RETURN [none, NIL] }
                        ELSE { tabByKey Ź SymTab.Create[]; RETURN [store, tabByKey] };
                    };
                SymTab.Update[tabByDomain, domainName, GetTabByMap];
                SymTab.Update[tabByMap, mapName, GetTabByKey];
                cV Ź NARROW[SymTab.Fetch[tabByKey, key].val];
                SELECT TRUE FROM
                    (cV = NIL) => {
                        DO
                            SELECT TRUE FROM
                                (numCachedValues < maxCachedValues) => {
                                    cV Ź NEW[CachedValueObject];
                                    numCachedValues Ź numCachedValues + 1;
                                    EXIT;
                                    };
                                (cachedValueHead = NIL) => {
                                    WAIT cachedValueAvailable;
                                    LOOP;
                                    };
                                ENDCASE => {
                                    cV Ź cachedValueTail;
                                    RemoveCachedValueFromTable[cV];
                                    RemoveCachedValueFromList[cV];
                                    EXIT;
                                    };
                            ENDLOOP;
                            cV.ttl Ź initialCachedValueTTL;
                            cV.key Ź key;
                            cV.value Ź NIL;
                            cV.table Ź tabByKey;
                        };
                    (cV.busy = 0) => {
                        RemoveCachedValueFromList[cV];
                        };
                    ENDCASE;
                cV.busy Ź cV.busy + 1;
                };

            CacheValue: ENTRY PROC [cV: CachedValue, newValue: REF TEXT Ź NIL, lock: Lock Ź cachedValueLock] ~ {
                IF newValue # NIL THEN {
                    IF cV.busy # 1 THEN ERROR;
                    cV.value Ź newValue;
                    [] Ź SymTab.Store[cV.table, cV.key, cV];
                    };
                IF (cV.busy Ź cV.busy - 1) = 0 THEN {
                    IF cachedValueHead = NIL
                        THEN {
                            cV.next Ź cV.prev Ź NIL;
                            cachedValueHead Ź cachedValueTail Ź cV;
                            NOTIFY cachedValueAvailable;
                            }
                        ELSE {
                            cV.next Ź cachedValueHead;
                            cV.prev Ź NIL;
                            cachedValueHead.prev Ź cV;
                            cachedValueHead Ź cV;
                            };
                    };
                };

            FreeCachedValue: INTERNAL PROC [cV: CachedValue, lock: Lock] ~ {
                cV.key Ź NIL;
                cV.value Ź NIL;
                cV.table Ź NIL;
                cV.next Ź cV.prev Ź NIL;
                numCachedValues Ź numCachedValues - 1;
                NOTIFY cachedValueAvailable;
                };

            ReleaseCacheEntry: ENTRY PROC [cV: CachedValue, lock: Lock Ź cachedValueLock] ~ {
                IF cV.busy # 1 THEN ERROR;
                FreeCachedValue[cV, lock];
                };

            SweepCachedValues: ENTRY PROC [seconds: CARD, lock: Lock Ź cachedValueLock] ~ {
                p, next: CachedValue;
                FOR p Ź cachedValueHead, next WHILE p # NIL DO
                    next Ź p.next;
                    IF p.ttl > seconds
                        THEN {
                            p.ttl Ź p.ttl - seconds;
                            }
                        ELSE {
                            IF p.busy # 0 THEN ERROR;
                            RemoveCachedValueFromTable[p];
                            RemoveCachedValueFromList[p];
                            FreeCachedValue[p, lock];
                            };
                    ENDLOOP;
                };
        <<Public Procedures>>
            MapErrorCode: PROC [code: ATOM, h: Handle] RETURNS [mappedCode: ATOM] ~ {
                h.server.down Ź TRUE;
                h.server.ttl Ź initialServerTTL;
                mappedCode Ź code;
                };

            MapErrorStatus: PROC [status: SunYP.Status, h: Handle] RETURNS [mappedCode: ATOM] ~ {
                h.server.down Ź FALSE;
                h.server.ttl Ź initialServerTTL;
                mappedCode Ź (SELECT status FROM
                    true => NIL,
                    nomore => $noMoreEntries,
                    nomap => $mapNotFound,
                    nodomain => $domainNotFound,
                    nokey => $keyNotFound,
                    ENDCASE => $protocol);
                };

            Match: PUBLIC PROC [h: Handle, map: ROPE, key: ROPE] RETURNS [val: REF TEXT] ~ {
                cV: CachedValue;
                errorCode: ATOM;
                response: SunYP.ResponseVal;
                cV Ź LookupCachedValue[h.domain, map, key];
                IF cV.value # NIL THEN {
                    val Ź cV.value;
                    CacheValue[cV];
                    RETURN;
                    };
                {
                    ENABLE SunRPC.Error => {
                        errorCode Ź MapErrorCode[code, h];
                        IF FixupForDownServer[h] THEN RETRY ELSE CONTINUE;
                        };
                    response Ź SunYPClient.Match[h.rpcHandle, h.conversation, [domain~h.domain, map~map, key~Rope.ToRefText[key]]];
                    errorCode Ź MapErrorStatus[response.status, h];
                    };
                IF errorCode = NIL
                    THEN {
                        val Ź response.val;
                        CacheValue[cV, val];
                        RETURN;
                        }
                    ELSE {
                        ReleaseCacheEntry[cV];
                        ERROR Error[errorCode];
                        };
                };

            First: PUBLIC PROC [h: Handle, map: ROPE] RETURNS [key: ROPE, val: REF TEXT] ~ {
                response: SunYP.ResponseKeyVal;
                errorCode: ATOM Ź NIL;
                {
                    ENABLE SunRPC.Error => {
                        errorCode Ź MapErrorCode[code, h];
                        IF FixupForDownServer[h] THEN RETRY ELSE CONTINUE;
                        };
                    response Ź SunYPClient.First[h.rpcHandle, h.conversation, [domain~h.domain, map~map]];
                    errorCode Ź MapErrorStatus[response.status, h];
                    };
                IF errorCode # NIL THEN ERROR Error[errorCode];
                RETURN [Rope.FromRefText[response.key], response.val];
                };

            Next: PUBLIC PROC [h: Handle, map: ROPE, keyBefore: ROPE]
            RETURNS [key: ROPE, val: REF TEXT] ~ {
                response: SunYP.ResponseKeyVal;
                errorCode: ATOM Ź NIL;
                {
                    ENABLE SunRPC.Error => {
                        errorCode Ź MapErrorCode[code, h];
                        IF FixupForDownServer[h] THEN RETRY ELSE CONTINUE;
                        };
                    response Ź SunYPClient.Next[h.rpcHandle, h.conversation, [domain~h.domain, map~map, key~Rope.ToRefText[keyBefore]]];
                    errorCode Ź MapErrorStatus[response.status, h];
                    };
                IF errorCode # NIL THEN ERROR Error[errorCode];
                RETURN [Rope.FromRefText[response.key], response.val];
                };

            MapList: PUBLIC PROC [h: Handle, eachMap: SunYP.EachMapNameProc] ~ {
                status: SunYP.Status;
                errorCode: ATOM Ź NIL;
                gotOne: BOOL Ź FALSE;
                eachMapOuter: SunYP.EachMapNameProc -- [map] -- ~ {
                    gotOne Ź TRUE;
                    RETURN [eachMap[map]];
                    };
                {
                    ENABLE SunRPC.Error => {
                        errorCode Ź MapErrorCode[code, h];
                        IF (NOT gotOne) AND FixupForDownServer[h] THEN RETRY ELSE CONTINUE;
                        };
                    status Ź SunYPClient.Maplist[h.rpcHandle, h.conversation, h.domain, eachMapOuter];
                    errorCode Ź MapErrorStatus[status, h];
                    };
                IF errorCode # NIL THEN ERROR Error[errorCode];
                };
        <<Utilities>>
            ExpandTextSeq: PROC [s: SunYPAgent.TextSeq] RETURNS [new: SunYPAgent.TextSeq] ~ {
                new Ź NEW[SunYPAgent.TextSeqObject[2*s.maxLength]];
                new.length Ź s.length;
                FOR i: CARDINAL IN [0 .. s.length) DO
                    new.refText[i] Ź s.refText[i];
                    ENDLOOP;
                };

            IsWhiteSpace: PROC [c: CHAR] RETURNS [isWhite: BOOL] ~ {
                OPEN Ascii;
                isWhite Ź (SELECT c FROM
                    TAB, LF, FF, CR, SP => TRUE,
                    ENDCASE => FALSE);
                };

            TokenizeUsingSeparator: PUBLIC PROC [in: REF READONLY TEXT, sepChar: CHAR, trimLeadingSpace, trimTrailingSpace: BOOL] RETURNS [out: 
            SunYPAgent.TextSeq]
                ~ {
                i, iTo, len: CARDINAL;
                scratch: REF TEXT Ź RefText.ObtainScratch[in.length];

                CountSeparators: PROC [txt: REF READONLY TEXT, sepChar: CHAR] RETURNS [ct: CARDINAL Ź 0] = {
                   FOR k: CARDINAL IN [0..txt.length) DO
                      IF txt[k] =  sepChar THEN ct Ź ct + 1;
                      ENDLOOP; 
                   };
                    
                len Ź CountSeparators[in, sepChar] + 1;            
                out Ź NEW[SunYPAgent.TextSeqObject[len]];  
                out.length Ź 0;
                i Ź 0;
                DO
                    IF i >= in.length THEN EXIT;
                    IF trimLeadingSpace AND IsWhiteSpace[in[i]] THEN { i Ź i + 1; LOOP };
                    iTo Ź 0;
                    DO
                        IF (i >= in.length) OR (in[i] = sepChar) THEN EXIT;
                        scratch[iTo] Ź in[i];
                        i Ź i + 1;
                        iTo Ź iTo + 1;
                        ENDLOOP;
                    IF trimTrailingSpace THEN
                        WHILE (iTo > 0) AND IsWhiteSpace[scratch[iTo-1]] DO iTo Ź iTo - 1 ENDLOOP;
                    scratch.length Ź iTo;
                    IF out.length >= out.maxLength THEN out Ź ExpandTextSeq[out];
                    out.refText[out.length] Ź RefText.Append[to~RefText.New[scratch.length], from~scratch];
                    out.length Ź out.length + 1;
                    i Ź i + 1;
                    ENDLOOP;
                <<Make sure each element of the seq is not NIL ... must have at least have a zero length rope>>
                scratch.length Ź 0;
                FOR k: CARDINAL DECREASING IN [0..len) DO
                  IF out.refText[k] = NIL THEN {
                    out.refText[k] Ź RefText.Append[to~RefText.New[scratch.length], from~scratch];
                  } ELSE EXIT;
                  ENDLOOP;  
                RefText.ReleaseScratch[scratch];
                out.length Ź len;
                };

            Tokenize: PUBLIC PROC [in: REF READONLY TEXT]
            RETURNS [out: SunYPAgent.TextSeq]
                ~ {
                i, iTo: CARDINAL;
                scratch: REF TEXT Ź RefText.ObtainScratch[in.length];
                out Ź NEW[SunYPAgent.TextSeqObject[8]];
                out.length Ź 0;
                i Ź 0;
                DO
                    IF i >= in.length THEN EXIT;
                    iTo Ź 0;
                    DO
                        IF i >= in.length THEN EXIT;
                        IF IsWhiteSpace[in[i]] THEN EXIT;
                        scratch[iTo] Ź in[i];
                        i Ź i + 1;
                        iTo Ź iTo + 1;
                        ENDLOOP;
                    scratch.length Ź iTo;
                    IF out.length >= out.maxLength THEN out Ź ExpandTextSeq[out];
                    out.refText[out.length] Ź RefText.Append[to~RefText.New[scratch.length], from~scratch];
                    out.length Ź out.length + 1;
                    i Ź i + 1;
                    WHILE (i < in.length) AND (IsWhiteSpace[in[i]]) DO i Ź i + 1 ENDLOOP;
                    ENDLOOP;
                RefText.ReleaseScratch[scratch];
                };

        <<Sweep Daemon and Rollback>>
            lastSweepTime: BasicTime.GMT Ź BasicTime.earliestGMT;

            Daemon: PROC ~ {
                DO
                    thisSweepTime: BasicTime.GMT;
                    secondsSinceLastSweep: INT;
                    secs: CARD; -- signed/unsigned ambiguity ... bletch!
                    thisSweepTime Ź BasicTime.Now[
                        ! BasicTime.TimeNotKnown => {
                            thisSweepTime Ź BasicTime.Update[lastSweepTime, (msecBetweenSweeps+999)/1000];
                            CONTINUE;
                            }
                        ];
                    secondsSinceLastSweep Ź BasicTime.Period[from~lastSweepTime, to~thisSweepTime];
                    IF secondsSinceLastSweep < 0 THEN ERROR;
                    secs Ź secondsSinceLastSweep;
                    SweepCachedValues[secs];
                    SweepServers[secs];
                    SweepNullServers[secs];
                    Process.PauseMsec[msecBetweenSweeps];
                    ENDLOOP;
                };

            <<Rollback: Booting.RollbackProc ~ {>>
                <<SweepCachedValues[CARD.LAST];>>
                <<SweepServers[CARD.LAST];>>
                <<SweepNullServers[CARD.LAST];>>
                <<};>>
                <<>>
            <<Proc passed to ThisMachineRegistry to register the IP name proc with the ThisMachine interface
>>
            IPNameProc: PROC RETURNS [name: ROPE] = {
                ENABLE Error => GOTO NoYP;
                h: Handle Ź NIL;
                addressRope, unbracketedAddressRope: ROPE;
                hostsEntry: REF TEXT;
                seq: SunYPAgent.TextSeq;

                h Ź ObtainHandle[NIL, NIL, Arpa.nullAddress];
                addressRope Ź Convert.RopeFromArpaAddress[Arpa.MyAddress[]];
                unbracketedAddressRope Ź Rope.Substr[addressRope, 1, Rope.Length[addressRope]-2];
                hostsEntry Ź Match[h, hostsMapName, unbracketedAddressRope];
                seq Ź Tokenize[hostsEntry];
                IF seq.length <= hostNamePos THEN GOTO NoYP;
                name Ź Rope.FromRefText[seq.refText[hostNamePos]];
                IF h # NIL THEN ReleaseHandle[h];
                EXITS
                NoYP => NULL;
                };
        <<
        Proc will be passed to ThisMachineRegistry to register with the ThisMachine interface.
>>
        IPAddressProc: PROC RETURNS [ROPE] = {
            RETURN[Convert.RopeFromArpaAddress[Arpa.MyAddress[]]];
            };    

        Init: PROC = {
            thisMachineProcs: ThisMachineRegistry.ThisMachineRef Ź
            NEW[ThisMachineRegistry.ThisMachineProcsRec Ź [
            which: $ip,
            Name: IPNameProc,
            Address: IPAddressProc,
            ProcessorID: NIL
            ]];
            IF Basics.IsBound[LOOPHOLE[ThisMachineRegistry.RegisterThisMachineProcs]] THEN
            ThisMachineRegistry.RegisterThisMachineProcs[thisMachineProcs];
            };

        <<Mainline code>>

        TRUSTED { Process.Detach[ FORK Daemon[] ] };
        Init[];
        <<Booting.RegisterProcs[r: Rollback];>>

        }...