
    <<XNSCHHacks.mesa>>
        <<Demers, February 4, 1987 4:00:38 pm PST>>

    DIRECTORY
        CHEntriesP0V0 USING [members],
        Convert USING [XNSHostFromRope, XNSNetFromRope],
        Rope USING [ROPE],
        XNS USING [Address, Host, Net],
        XNSCH USING [Conversation, Error, InitiateConversation, ListMembers, LookupAddress, Name, TerminateConversation],
        XNSCHName USING [NameFromRope];

    XNSCHHacks: CEDAR MONITOR
        IMPORTS Convert, XNSCH, XNSCHName
        ~ {
        ROPE: TYPE ~ Rope.ROPE;

        Name: TYPE ~ XNSCH.Name;
        NameList: TYPE ~ LIST OF Name;

        Pair: TYPE ~ RECORD [name: Name, address: XNS.Address];
        PairList: TYPE ~ LIST OF Pair;

        FilterProc: TYPE ~ PROC [pair: Pair] RETURNS [yes: BOOL];


        glueGroupName: ROPE _ "CHServers:CHServers:CHServers";

        EnumerateGroup: PROC [groupName: ROPE _ NIL]
        RETURNS [n: NAT _ 0, nameList: NameList] ~ {
            c: XNSCH.Conversation;
            EachMember: PROC [it: XNSCH.Name] ~ {
                n _ n.SUCC;
                nameList _ CONS[it, nameList] };
            c _ XNSCH.InitiateConversation[];
            IF groupName = NIL THEN groupName _ glueGroupName;
            [] _ XNSCH.ListMembers[c~c, pattern~XNSCHName.NameFromRope[groupName], pID~CHEntriesP0V0.members, eachMember~EachMember];
            XNSCH.TerminateConversation[c];
            };

        PairsFromNameList: PROC [nameList: NameList] RETURNS [n: NAT _ 0, pairList: PairList] ~ {
            c: XNSCH.Conversation;
            c _ XNSCH.InitiateConversation[];
            FOR list: NameList _ nameList, list.rest WHILE list # NIL DO
            pair: Pair;
                [pair.name, pair.address] _ XNSCH.LookupAddress[c~c, pattern~list.first
                ! XNSCH.Error => { --pair _ [list.first, XNS.unknownAddress];-- LOOP } ];
                n _ n.SUCC;
                pairList _ CONS[pair, pairList];
                ENDLOOP;
            XNSCH.TerminateConversation[c];
            };

        FilterPairList: PROC [pairList: PairList, iWantIt: FilterProc]
        RETURNS [n: NAT _ 0, filteredPairList: PairList] ~ {
            c: XNSCH.Conversation;
            c _ XNSCH.InitiateConversation[];
            FOR list: PairList _ pairList, list.rest WHILE list # NIL DO
                IF NOT iWantIt[list.first] THEN LOOP;
                n _ n.SUCC;
                filteredPairList _ CONS[list.first, filteredPairList];
                ENDLOOP;
            XNSCH.TerminateConversation[c];
            };

        FilterPairListByNet: PROC [pairList: PairList, theDesiredNet: ROPE]
        RETURNS [n: NAT _ 0, filteredPairList: PairList] ~ {
            net: XNS.Net;
            FilterByNet: FilterProc ~ { yes _ pair.address.net = net };
            net _ Convert.XNSNetFromRope[theDesiredNet];
            [n, filteredPairList] _ FilterPairList[pairList, FilterByNet];
            };

        FilterPairListByHost: PROC [pairList: PairList, theDesiredHost: ROPE]
        RETURNS [n: NAT _ 0, filteredPairList: PairList] ~ {
            host: XNS.Host;
            FilterByHost: FilterProc ~ { yes _ pair.address.host = host };
            host _ Convert.XNSHostFromRope[theDesiredHost];
            [n, filteredPairList] _ FilterPairList[pairList, FilterByHost];
            };

        globalElementList: NameList _ NIL;
        DefaultElementStreamProc: PROC [n: Name] ~ {
            globalElementList _ CONS[n, globalElementList] };

        globalNameList: NameList _ NIL;
        DefaultNameStreamProc: PROC [n: Name] ~ {
            globalNameList _ CONS[n, globalNameList] };

        }.