
    <<MaintainNSImpl.mesa -- From MaintainImpl.mesa>>
        <<Copyright Ó 1987, 1989, 1990, 1991, 1992 by Xerox Corporation.  All rights reserved.>>
        <<Wes Irish, July 21, 1989 12:13:18 pm PDT>>
        <<Bill Jackson (bj) January 22, 1990 6:30:11 pm PST>>
        <<Bryan Lyles,  November 8, 1990 1:03 pm PST>>
        <<Philip James, September 12, 1991 11:36 am PDT>>
        <<Willie-s, January 7, 1992 4:48 pm PST>>
        <<Michael Plass, March 11, 1992 1:50 pm PST>>
        <<Doug Wyatt, May 15, 1992 1:08 pm PDT>>
        <<>>
    DIRECTORY
        Atom USING[ GetPName ],
        AuthenticationP14V2 USING[ Problem, CallProblem ],
        BasicTime USING[ FromNSTime, GetClockPulses, GMT, Now, Period, Pulses, PulsesToSeconds, ToNSTime, UnpackedPeriod, UnpackPeriod ],
        CHEntriesP0V0,
        CHOpsP2V3 USING [ItemObject],
        Convert USING[ CardFromRope, Error, RopeFromCard, RopeFromInt, RopeFromTime, RopeFromXNSAddress, XNSAddressFromRope, 
        XNSHostFromRope ],
        GluePruneHacks USING [CacheEntry, DomainsForServer, ExposeErrorCode, RopeList],
        IO USING[ PutChar, PutF, PutF1, PutRope ],
        MaintainDefs USING[ CmdButton, Level, MyData, MyDataObject, RetrieveProc, What ],
        MaintainProcs USING[ ChangeLooksProc ],
        MaintainMisc USING[ CallForItems, EnumGroups, EnumIndividuals, Plural, Verify ],
        MaintainNS,
        Process USING[Pause, SecondsToTicks],
        Real USING[Fix],
        Rope USING[ Cat, Concat, Equal, Find, FindBackward, Index, Length, Replace, ROPE, Substr ],
        XNS USING[ Address, Host, unknownAddress, unknownHost, unknownSocket ],
        XNSAuth USING[ AuthenticationError, CallError, ChangeMyPasswords, CreateSimpleKey, CreateStrongKey, DeleteSimpleKey, 
        DeleteStrongKey, GetIdentityDetails, Identity, SimpleKeyFromPassword, StrongKeyFromPassword],
        XNSCH USING[ Add, AddAlias, AddGroupProperty, AddItemProperty, AddMember, AddSelf, ChangeItemProperty, Conversation, Delete, 
        DeleteAlias, DeleteMember, DeleteProperty, DeleteSelf, ElementStreamProc, Enumerate, EnumerateDomains, 
        EnumerateOrganizations, Error, ErrorCode, GetProperties, InitiateConversation, IsMember, IsMemberClosure, Item, 
        ListAliases, ListMembers, Lookup, LookupAddressFromRope, LookupItemProperty, Name, Properties, RopeFromItem, 
        TerminateConversation, Which],
        XNSCHACL USING[ AccessList, AddMemberToPropertyACL, DeleteMemberFromPropertyACL, ListMembersOfPropertyACL],
        XNSCHItemOps USING[AddressListFromItem, BoolFromItem, Card32FromItem, Card16IntoItem, Card32IntoItem, CreateNewItem, Error, 
        ItemFromAddressList, ItemFromCard16, ItemFromName, ItemFromRope, NameListFromItem, NameFromItem, NameIntoItem],
        XNSCHName USING[ FieldTooLong, NameFromRope, RopeFromName];

    MaintainNSImpl: CEDAR MONITOR LOCKS d USING d: MyData
        IMPORTS Atom, BasicTime, Convert, GluePruneHacks, IO, MaintainDefs, MaintainMisc, Process, Real, Rope, XNSAuth, XNSCH, XNSCHACL, 
        XNSCHItemOps, XNSCHName
        EXPORTS MaintainNS = {
        OPEN CHEntriesP0V0;
        ROPE: TYPE = Rope.ROPE;

        MyData: TYPE ~ MaintainDefs.MyData;
        MyDataObject: TYPE ~ MaintainDefs.MyDataObject;
        What: TYPE ~ MaintainDefs.What;

        Name: TYPE = XNSCH.Name;
        NameRef: TYPE = REF Name;
        NameList: TYPE = LIST OF NameRef;

        Item: TYPE = XNSCH.Item;
        AccessList: TYPE = XNSCHACL.AccessList;
        Identity: TYPE = XNSAuth.Identity;

        PropType: TYPE = {unknown, group, rope, name, addressList, authenticationLevel, userData, mailboxInfo};

        Property: TYPE = CARD32;

    <<******** Enquiry operations ******** -->>

        DoCommand: PUBLIC PROC [d: MyData, cb: MaintainDefs.CmdButton, name, args: ROPE] = {
            SELECT cb.cmd FROM
                type, isMember => DoTypeCommand[d, cb, name, args];
                set, add, remove, misc => DoUpdateCommand[d, cb, name, args];
                ENDCASE => ERROR;
            };

        DoEnumerate: PUBLIC PROC [d: MyData, cb: MaintainDefs.CmdButton, pattern, args: ROPE] = {
            Enumerate: PROC [d: MyData, cb: MaintainDefs.CmdButton, pattern, args: ROPE] = {
                AddNameToOrgList: PROC [name: Name] = {
                    nr: NameRef Ź NEW[Name Ź name];
                    orgNameList Ź CONS[nr, orgNameList];
                    nOrganizations Ź SUCC[nOrganizations];
                    IF d.verbose THEN d.out.PutChar['.];
                    };
                AddNameToDomainList: PROC [name: Name] = {
                    nr: NameRef Ź NEW[Name Ź name];
                    domainNameList Ź CONS[nr, domainNameList];
                    nDomains Ź SUCC[nDomains];
                    IF d.verbose THEN d.out.PutChar['.];
                    };
                AddNameToFullList: PROC [name: Name] = {
                    nr: NameRef Ź NEW[Name Ź name];
                    fullNameList Ź CONS[nr, fullNameList];
                    nNames Ź SUCC[nNames];
                    };
                ReverseList: PROC [original: NameList] RETURNS[newList: NameList]= {
                    FOR list: NameList Ź original, list.rest UNTIL list = NIL DO
                        newList Ź CONS[list.first, newList];
                        ENDLOOP;
                    };
                startTime: BasicTime.GMT;
                patternName, pat: Name;
                wildcardInAnyField, wildcardInObject, wildcardInDomain, wildcardInOrganization: BOOL;
                orgNameList, domainNameList, fullNameList: NameList Ź NIL;
                eC: XNSCH.ErrorCode;
                eW: XNSCH.Which;
                problems: BOOL Ź FALSE;
                fieldTooLong: BOOL Ź FALSE;
                patternName Ź XNSCHName.NameFromRope[pattern
                    ! XNSCHName.FieldTooLong => {fieldTooLong Ź TRUE; RESUME;}];
                wildcardInObject Ź Rope.Find[patternName.object, "*"] >= 0;
                wildcardInDomain Ź Rope.Find[patternName.domain, "*"] >= 0;
                wildcardInOrganization Ź Rope.Find[patternName.organization, "*"] >= 0;
                wildcardInAnyField Ź wildcardInObject OR wildcardInDomain OR wildcardInOrganization;
                <<This is the simple case, no wildcards>>
                IF ~wildcardInAnyField AND cb.what # matches THEN {
                    DoCommand[d, cb, pattern, args];
                    RETURN;
                    };
                <<Wildcards present, enumerate all names...>>
                pat Ź patternName;
                startTime Ź BasicTime.Now[];
                IF d.verbose THEN d.out.PutF1["\n[Starting name expansion of \"%g\"]", [rope[pattern]]];
                IF ~wildcardInOrganization
                    THEN AddNameToOrgList[pat]
                    ELSE {
                        XNSCH.EnumerateOrganizations[c, pat, AddNameToOrgList
                            ! XNSCH.Error => {
                                eC Ź code;
                                eW Ź which;
                                problems Ź TRUE;
                                d.out.PutF["\n=> Error: %g (\"%g\")\n",
                                    [rope[ExposeErrorCode[eC, LOOPHOLE[eW]]]],
                                    [rope[XNSCHName.RopeFromName[pat]]]];
                                CONTINUE;
                                }];
                        orgNameList Ź ReverseList[orgNameList];
                        };
                FOR thisOrg: NameList Ź orgNameList, thisOrg.rest UNTIL (thisOrg = NIL OR d.stop) DO
                    domainNameList Ź NIL;
                    pat.organization Ź thisOrg.first.organization;
                    pat.domain Ź patternName.domain;
                    IF d.verbose THEN d.out.PutF1["\n[Org: \"%g\"]", [rope[pat.organization]]];
                    IF ~wildcardInDomain
                        THEN AddNameToDomainList[pat]
                        ELSE {
                            XNSCH.EnumerateDomains[c, pat, AddNameToDomainList
                                ! XNSCH.Error => {
                                    nOrganizationProblems Ź nOrganizationProblems+1;
                                    eC Ź code;
                                    eW Ź which;
                                    problems Ź TRUE;
                                    d.out.PutF["\n=> Error: %g (\"%g\")\n",
                                        [rope[ExposeErrorCode[eC, LOOPHOLE[eW]]]],
                                        [rope[XNSCHName.RopeFromName[pat]]]];
                                    CONTINUE;
                                    }];
                            domainNameList Ź ReverseList[domainNameList];
                            };
                    FOR thisDomain: NameList Ź domainNameList, thisDomain.rest UNTIL (thisDomain = NIL OR d.stop) DO
                        firstObjectInDomain: BOOL Ź TRUE;
                        prop: Property;
                        host: XNS.Host;
                        atom: ATOM;
                        IF cb.what = matches THEN atom Ź NARROW[d.cmdData];
                        fullNameList Ź NIL;
                        pat.organization Ź thisDomain.first.organization;
                        pat.domain Ź thisDomain.first.domain;
                        pat.object Ź patternName.object;
                        IF d.verbose THEN d.out.PutF["\n  [Domain: \"%g:%g\"]", [rope[pat.domain]], [rope[pat.organization]]];
                        IF cb.what = matches THEN prop Ź PropertyFromAtom[atom, d];
                        IF cb.what = matches AND atom # $GroupsAndUsers
                            THEN {
                                d.out.PutF1["(matching: %g) ... ", [rope[GetPropertyInfo[prop].shortLabel]]];
                                XNSCH.Enumerate[c, pat, prop, AddNameToFullList
                                    ! XNSCH.Error => {
                                        nDomainProblems Ź nDomainProblems+1;
                                        eC Ź code;
                                        eW Ź which;
                                        problems Ź TRUE;
                                        d.out.PutF["\n=> Error: %g (\"%g\")\n",
                                            [rope[ExposeErrorCode[eC, LOOPHOLE[eW]]]],
                                            [rope[XNSCHName.RopeFromName[pat]]]];
                                        CONTINUE;
                                        }];
                                }
                            ELSE {
                                IF MaintainMisc.EnumGroups[cb] THEN
                                XNSCH.Enumerate[c, pat, userGroup, AddNameToFullList
                                    ! XNSCH.Error => {
                                        nDomainProblems Ź nDomainProblems+1;
                                        eC Ź code;
                                        eW Ź which;
                                        problems Ź TRUE;
                                        d.out.PutF["\n=> Error: %g (\"%g\")\n",
                                            [rope[ExposeErrorCode[eC, LOOPHOLE[eW]]]],
                                            [rope[XNSCHName.RopeFromName[pat]]]];
                                        CONTINUE;
                                        }];
                                IF MaintainMisc.EnumIndividuals[cb] THEN
                                    XNSCH.Enumerate[c, pat, user, AddNameToFullList
                                        ! XNSCH.Error => {
                                            nDomainProblems Ź nDomainProblems+1;
                                            eC Ź code;
                                            eW Ź which;
                                            problems Ź TRUE;
                                            d.out.PutF["\n=> Error: %g (\"%g\")\n",
                                                [rope[ExposeErrorCode[eC, LOOPHOLE[eW]]]],
                                                [rope[XNSCHName.RopeFromName[pat]]]];
                                            CONTINUE;
                                            }];
                                };
                        fullNameList Ź ReverseList[fullNameList];
                        IF cb.what = matches AND prop = addressList
                            THEN host Ź HostAddressFromSelection[d];
                        FOR thisName: NameList Ź fullNameList, thisName.rest UNTIL (thisName = NIL OR d.stop) DO
                            IF cb.what = matches THEN {
                                name: Name Ź thisName.first­;
                                IF prop # addressList OR host = XNS.unknownHost OR MatchHostAddressForObject[host, name] THEN {
                                    IF ~d.firstTime
                                        THEN d.out.PutRope[", "]
                                        ELSE d.firstTime Ź FALSE;
                                    d.out.PutF1["\"%g\"", [rope[XNSCHName.RopeFromName[name]]]];
                                    };
                                LOOP;
                                };
                            IF firstObjectInDomain THEN {
                                IF d.verbose THEN d.out.PutChar['\n];
                                firstObjectInDomain Ź FALSE;
                                };
                            DoCommand[d, cb, XNSCHName.RopeFromName[thisName.first­], args];
                            ENDLOOP;
                        ENDLOOP;
                    ENDLOOP;
                IF nNames > 1 OR nDomains > 1 OR nOrganizations > 1 THEN {
                    d.out.PutF["\n(%g %g", [cardinal[nNames]], [rope[MaintainMisc.Plural["name", "names", nNames]]]];
                    IF nDomains > 1 OR nOrganizations > 1 THEN
                        d.out.PutF[" in %g %g", [cardinal[nDomains]], [rope[MaintainMisc.Plural["domain", "domains", nDomains]]]];
                    IF nOrganizations > 1 THEN
                        d.out.PutF[" in %g %g", [cardinal[nOrganizations]], [rope[MaintainMisc.Plural["organization", "organizations", nOrganizations]]]];
                    d.out.PutRope[" enumerated."];
                    IF nDomainProblems > 0 OR nOrganizationProblems > 0 THEN {
                        d.out.PutRope["  Problems with "];
                        d.out.PutF["%g %g and", [cardinal[nDomainProblems]], [rope[MaintainMisc.Plural["domain", "domains", nDomainProblems]]]];
                        d.out.PutF[" %g %g.)", [cardinal[nOrganizationProblems]], [rope[MaintainMisc.Plural["organization", "organizations", 
                        nOrganizationProblems]]]];
                        }
                        ELSE d.out.PutChar[')];
                    };
                IF d.verbose THEN d.out.PutF["\n[Start: %g, Stop: %g]", [rope[Convert.RopeFromTime[startTime]]], 
                [rope[Convert.RopeFromTime[BasicTime.Now[]]]]];
                };
        c: XNSCH.Conversation Ź XNSCH.InitiateConversation[d.identity, d.conversationAddress];
        nNames, nDomains, nOrganizations: CARD Ź 0;
        nDomainProblems, nOrganizationProblems: CARD Ź 0;
        Enumerate[d, cb, pattern, args];
        XNSCH.TerminateConversation[c];
        };

        DoForEachArgument: PROC [d: MyData, c: XNSCH.Conversation, proc: PROC[Name, ROPE, Name, ROPE, BOOL], check: BOOL Ź TRUE, doDisting: 
        BOOL Ź TRUE, leader: ROPE Ź "\n"] = {
            FOR argList: LIST OF ROPE Ź d.argList, argList.rest WHILE argList # NIL DO
                name, distingName: Name;
                nameRope, distingNameRope, thisArg: ROPE;
                problems: BOOL;
                thisArg Ź argList.first;
                name Ź XNSCHName.NameFromRope[thisArg
                    ! XNSCHName.FieldTooLong => RESUME];
                nameRope Ź XNSCHName.RopeFromName[name];
                IF doDisting
                    THEN [distingName, problems, , ] Ź DistinguishedName[name, c]
                    ELSE problems Ź TRUE;
                IF ~problems THEN distingNameRope Ź XNSCHName.RopeFromName[distingName];
                IF check AND ~CheckName[name] THEN {
                    IF MaintainMisc.Verify[d] THEN {
                        d.out.PutF1["\n\"%g\" is NOT a valid name.", [rope[nameRope]]];
                        RETURN;
                        };
                    d.out.PutF["%g(\"%g\" is an invalid name) ... ", [rope[leader]], [rope[nameRope]]];
                    };
                proc[name, nameRope, distingName, distingNameRope, ~problems];
                ENDLOOP;
            };

        DoUpdateCommand: PROC [d: MyData, cb: MaintainDefs.CmdButton, name, args: ROPE] = {
            UpdatePassword: PROC = {
                SELECT cb.cmd FROM
                    set => {
                        type: ROPE Ź IF cb.what = password THEN "strong" ELSE "simple";
                        idName, dIdName, dParmName: Name;
                        sameName: BOOL;
                        dIdNameRope, dParmNameRope: ROPE;
                        idName Ź XNSAuth.GetIdentityDetails[d.identity].name;
                        [dIdName, problems, , ] Ź DistinguishedName[idName, c];
                        dIdNameRope Ź XNSCHName.RopeFromName[dIdName];
                        IF problems THEN {
                            d.out.PutF1["\nSorry, unable to discern logged-in user: \"%g\"?  Password not changed.", [rope[dIdNameRope]]];
                            RETURN;
                            };
                        [dParmName, problems, , ] Ź DistinguishedName[nsName, c];
                        dParmNameRope Ź XNSCHName.RopeFromName[dParmName];
                        IF problems THEN {
                            d.out.PutF1["\nSorry, unable to distinguish name: \"%g\".  Password not changed.", [rope[dParmNameRope]]];
                            RETURN;
                            };
                        sameName Ź  Rope.Equal[dIdNameRope, dParmNameRope, FALSE];
                        SELECT TRUE FROM
                            sameName, d.level = normal, d.level = owner => {
                                IF ~sameName THEN {
                                    d.out.PutF["\nSorry, in Normal and Owner level the provided name must be the same as the logged in user (\"%g\" # \"%g\").  
                                    Password not changed.", [rope[dParmNameRope]], [rope[dIdNameRope]]];
                                    RETURN;
                                    };
                                d.out.PutF["\nChanging my (%g) password (%g) ...", [rope[type]], [rope[dIdNameRope]]];
                                [] Ź XNSAuth.ChangeMyPasswords[d.identity, args, cb.what = password, cb.what = simple
                                    ! XNSAuth.AuthenticationError => {
                                        d.out.PutF1[" Error: %g.", [rope[ExposeAuthProblem[problem]]]];
                                        problems Ź TRUE;
                                        CONTINUE
                                        };
                                    XNSAuth.CallError => {
                                        d.out.PutF1[" Error: %g.", [rope[ExposeAuthCallProblem[problem]]]];
                                        problems Ź TRUE;
                                        CONTINUE
                                        };
                                    ];
                                };
                            ENDCASE => {
                                d.out.PutF["\nChanging (%g) password for \"%g\" ...", [rope[type]], [rope[name]]];
                                d.out.PutF1[" deleting existing %g key ...", [rope[type]]];
                                IF cb.what = password
                                    THEN [] Ź XNSAuth.DeleteStrongKey[d.identity, nsName
                                        ! XNSAuth.AuthenticationError => {
                                            d.out.PutF1[" %g ...", [rope[ExposeAuthProblem[problem]]]];
                                            problems Ź TRUE;
                                            CONTINUE
                                            };
                                        XNSAuth.CallError => {
                                            d.out.PutF1[" %g ...", [rope[ExposeAuthCallProblem[problem]]]];
                                            problems Ź TRUE;
                                            CONTINUE
                                            };
                                        ]
                                    ELSE [] Ź XNSAuth.DeleteSimpleKey[d.identity, nsName
                                        ! XNSAuth.AuthenticationError => {
                                            d.out.PutF1[" %g ...", [rope[ExposeAuthProblem[problem]]]];
                                            problems Ź TRUE;
                                            CONTINUE
                                            };
                                        XNSAuth.CallError => {
                                            d.out.PutF1[" %g ...", [rope[ExposeAuthCallProblem[problem]]]];
                                            problems Ź TRUE;
                                            CONTINUE
                                            };
                                        ];
                                problems Ź FALSE;
                                d.out.PutF1[" creating new %g key ...", [rope[type]]];
                                IF cb.what = password
                                    THEN [] Ź XNSAuth.CreateStrongKey[d.identity, nsName, XNSAuth.StrongKeyFromPassword[args]
                                        ! XNSAuth.AuthenticationError => {
                                            d.out.PutF1[" %g ...", [rope[ExposeAuthProblem[problem]]]];
                                            problems Ź TRUE;
                                            CONTINUE
                                            };
                                        XNSAuth.CallError => {
                                            d.out.PutF1[" %g ...", [rope[ExposeAuthCallProblem[problem]]]];
                                            problems Ź TRUE;
                                            CONTINUE
                                            };
                                        ]
                                    ELSE [] Ź XNSAuth.CreateSimpleKey[d.identity, nsName, XNSAuth.SimpleKeyFromPassword[args]
                                        ! XNSAuth.AuthenticationError => {
                                            d.out.PutF1[" %g ...", [rope[ExposeAuthProblem[problem]]]];
                                            problems Ź TRUE;
                                            CONTINUE
                                            };
                                        XNSAuth.CallError => {
                                            d.out.PutF1[" %g ...", [rope[ExposeAuthCallProblem[problem]]]];
                                            problems Ź TRUE;
                                            CONTINUE
                                            };
                                        ];
                                };
                        IF ~problems
                            THEN d.out.PutRope[" ok."]
                            ELSE d.out.PutRope[" errors."];
                        };
                    ENDCASE =>  NotImplementedYet[d];
                };
            UpdateAlias: PROC = {
                UpdateOneAlias: PROC [thisName: Name, thisNameRope: ROPE, distingName: Name, distingNameRope: ROPE, disting: BOOL] = {
                    SELECT cb.cmd FROM
                        add => {
                            IF disting THEN
                                d.out.PutF1["\nSorry, that alias/name (%g) is already taken.", [rope[thisNameRope]]]
                            ELSE {
                                d.out.PutF["\nAdding alias \"%g\" for \"%g\" ...", [rope[thisNameRope]], [rope[name]]];
                                [] Ź XNSCH.AddAlias[c, nsName, thisName
                                    ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                                };
                            };
                        remove => {
                            IF ~disting THEN
                                d.out.PutF1["\nSorry, that alias (%g) is not currently assigned.", [rope[thisNameRope]]]
                            ELSE {
                                d.out.PutF1["\nRemoving alias \"%g\" ...", [rope[thisNameRope]]];
                                [] Ź XNSCH.DeleteAlias[c, thisName
                                    ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                                };
                            };
                        ENDCASE => NotImplementedYet[d];
                    IF problems THEN {
                        d.out.PutF1[" Error => %g", [rope[ExposeErrorCode[eC, LOOPHOLE[eW]]]]];
                        problems Ź FALSE;
                        }
                    ELSE d.out.PutRope[" ok."];
                    };
                DoForEachArgument[d, c, UpdateOneAlias, FALSE, TRUE];
                };

            RemoveProperty: PROC [prop: Property] = {
                d.out.PutF["\nRemoving %g property from \"%g\" ...", [rope[ExposePropertyCode[prop]]], [rope[name]]];
                [] Ź XNSCH.DeleteProperty[c, nsName, prop
                    ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                };

            UpdateRemark: PROC = {
                SELECT cb.what FROM
                    individualRemark => {
                        d.out.PutF["\nSetting remark for \"%g\" to \"%g\" ...", [rope[name]], [rope[args]]];
                        [] Ź XNSCH.ChangeItemProperty[c, nsName, user, XNSCHItemOps.ItemFromRope[args].newItem
                            ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                        };
                    groupRemark => {
                        d.out.PutF["\nSetting remark for \"%g\" to \"%g\" ...", [rope[name]], [rope[args]]];
                        [] Ź XNSCH.ChangeItemProperty[c, nsName, userGroup, XNSCHItemOps.ItemFromRope[args].newItem
                            ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                        };
                    ENDCASE => NotImplementedYet[d];
                IF problems THEN {
                    d.out.PutF1[" Error => %g", [rope[ExposeErrorCode[eC, LOOPHOLE[eW]]]]];
                    problems Ź FALSE;
                    }
                ELSE {
                    d.out.PutRope[" ok."];
                    };
                };
            UpdateProperties: PROC = {
                atom: ATOM Ź NARROW[d.cmdData];
                SetRopeProperty: PROC [prop: Property, type, value: ROPE] = {
                    d.out.PutF["\nSetting %g for \"%g\" to \"%g\" ...", [rope[type]], [rope[name]], [rope[value]]];
                    problems Ź FALSE;
                    [] Ź XNSCH.AddItemProperty[c, nsName, prop, XNSCHItemOps.ItemFromRope[value].newItem
                        ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                    IF problems THEN {
                        problems Ź FALSE;
                        [] Ź XNSCH.ChangeItemProperty[c, nsName, prop, XNSCHItemOps.ItemFromRope[value].newItem
                            ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                        };
                    };
                SetNamePropertyFromRope: PROC [prop: Property, type, value: ROPE] = {
                    item: Item;
                    thisName: Name;
                    d.out.PutF["\nSetting %g for \"%g\" to \"%g\" ...", [rope[type]], [rope[name]], [rope[value]]];
                    thisName Ź XNSCHName.NameFromRope[value
                        ! XNSCHName.FieldTooLong => {RESUME}];
                    item Ź XNSCHItemOps.ItemFromName[thisName].newItem;
                    problems Ź FALSE;
                    [] Ź XNSCH.AddItemProperty[c, nsName, prop, item
                        ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                    IF problems THEN {
                        problems Ź FALSE;
                        [] Ź XNSCH.ChangeItemProperty[c, nsName, prop, item
                            ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                        };
                    };
                SetListOfCard16PropertyFromRope: PROC [prop: Property, type, value: ROPE] = {
                    item: Item Ź ItemFromListOfCard16Rope[value];
                    problems Ź FALSE;
                    IF item = NIL THEN {
                        d.out.PutF1["\n\"%g\" is not a valid list of CARD16.", [rope[value]]];
                        RETURN;
                        };
                    d.out.PutF["\nSetting %g for \"%g\" to \"%g\" ...", [rope[type]], [rope[name]], [rope[value]]];
                    [] Ź XNSCH.AddItemProperty[c, nsName, prop, item
                        ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                    IF problems THEN {
                        problems Ź FALSE;
                        [] Ź XNSCH.ChangeItemProperty[c, nsName, prop, item
                            ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                        };
                    };
                SELECT atom FROM
                    $UserFileService => NotImplementedYet[d];
                    $AddressList => {
                        addresses: LIST OF XNS.Address;
                        addresses Ź AddressListFromRopeList[args
                            ! Convert.Error => {problems Ź TRUE; CONTINUE}];
                        IF problems THEN {
                            d.out.PutF1["\nSorry, but you have given an invalid address: \"%g\"", [rope[args]]];
                            GOTO someProblems;
                            };
                        d.out.PutRope["\nSetting the Address List property to: "];
                        PutAddressList[d, addresses];
                        d.out.PutRope[" ..."];
                        problems Ź FALSE;
                        [] Ź XNSCH.ChangeItemProperty[c, nsName, addressList, XNSCHItemOps.ItemFromAddressList[addresses].newItem
                            ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                        IF problems THEN {
                            problems Ź FALSE;
                            [] Ź XNSCH.AddItemProperty[c, nsName, addressList, XNSCHItemOps.ItemFromAddressList[addresses].newItem
                                ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                            };
                        d.out.PutF1[" %g.", [rope[IF ~problems THEN "ok" ELSE "errors"]]];
                        EXITS
                            someProblems => NULL;
                        };
                    $PrintService => SetRopeProperty[printService, "print service remark", args];
                    $FileSerivce => SetRopeProperty[fileService, "file service remark", args];
                    $CHService => SetRopeProperty[clearinghouseService, "clearingHouse service remark", args];
                    $UserRemark => SetRopeProperty[user, "user remark", args];
                    $GroupRemark => SetRopeProperty[userGroup, "group remark", args];
                    $AssociatedWorkstation => SetNamePropertyFromRope[associatedWorkstation, "Associated Workstation name", args];
                    $RopePropFromSelection => SetRopeProperty[PropertyFromSelection[d], ExposePropertyCode[PropertyFromSelection[d]], args];
                    $NamePropFromSelection => SetNamePropertyFromRope[PropertyFromSelection[d], ExposePropertyCode[PropertyFromSelection[d]], args];
                    $ListOfCard16PropFromSelection => SetListOfCard16PropertyFromRope[PropertyFromSelection[d], 
                    ExposePropertyCode[PropertyFromSelection[d]], args];
                    ENDCASE => NotImplementedYet[d];
                IF problems THEN {
                    d.out.PutF1[" Error => %g", [rope[ExposeErrorCode[eC, LOOPHOLE[eW]]]]];
                    problems Ź FALSE;
                    }
                ELSE {
                    d.out.PutRope[" ok."];
                    };
                };
            UpdateMember: PROC = {
                UpdateOneMember: PROC [thisName: Name, thisNameRope: ROPE, distingName: Name, distingNameRope: ROPE, disting: BOOL]= {
                    myGroup: Name Ź nsName;
                    myGroupRope: ROPE Ź name;
                    changed: BOOL Ź FALSE;
                    IF d.level IN [normal..owner] THEN
                        [myGroup, myGroupRope, changed] Ź GetPossibleSubList[nsName];
                    SELECT cb.cmd FROM
                        add => {
                            IF disting THEN {
                                d.out.PutF["\nAdding member \"%g\" to \"%g\" ...", [rope[distingNameRope]], [rope[name]]];
                                IF changed THEN d.out.PutF1[" split-list, using \"%g\" sub-list ...", [rope[myGroupRope]]];
                                [] Ź XNSCH.AddMember[c, myGroup, prop, distingName
                                    ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                                }
                            ELSE {
                                d.out.PutF["\nAdding (possibly not distinguished) member \"%g\" to \"%g\" ...", [rope[thisNameRope]], [rope[name]]];
                                IF changed THEN d.out.PutF1[" split-list, using \"%g\" sub-list ...", [rope[myGroupRope]]];
                                [] Ź XNSCH.AddMember[c, myGroup, prop, thisName
                                    ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                                };
                            };
                        remove => {
                            d.out.PutF["\nRemoving member \"%g\" from \"%g\" ...", [rope[thisNameRope]], [rope[name]]];
                            IF changed THEN d.out.PutF1[" split-list, using \"%g\" sub-list ...", [rope[myGroupRope]]];
                            [] Ź XNSCH.DeleteMember[c, myGroup, prop, thisName
                                ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                            IF problems THEN {
                                [distingName, problems, , ] Ź DistinguishedName[thisName, c];
                                IF ~problems THEN {
                                    distingNameRope Ź XNSCHName.RopeFromName[distingName];
                                    d.out.PutF1[" trying distinguished name \"%g\" ...", [rope[distingNameRope]]];
                                    [] Ź XNSCH.DeleteMember[c, myGroup, prop, distingName
                                        ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                                    };
                                };
                            };
                        ENDCASE => NotImplementedYet[d];
                    IF problems THEN {
                        d.out.PutF1[" Error => %g", [rope[ExposeErrorCode[eC, LOOPHOLE[eW]]]]];
                        problems Ź FALSE;
                        }
                    ELSE d.out.PutRope[" ok."];
                    };
                DoForEachArgument[d, c, UpdateOneMember, cb.cmd = add, cb.cmd = add];
                };
            UpdateOwner: PROC = {
                UpdateOneOwner: PROC [thisName: Name, thisNameRope: ROPE, distingName: Name, distingNameRope: ROPE, disting: BOOL]= {
                    SELECT cb.cmd FROM
                        add => {
                            IF disting THEN {
                                d.out.PutF["\nAdding owner (administrator) \"%g\" to \"%g\" ...", [rope[distingNameRope]], [rope[name]]];
                                [] Ź XNSCHACL.AddMemberToPropertyACL[c, nsName, members, administrators, distingName
                                    ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                                }
                            ELSE {
                                d.out.PutF["\nAdding (possibly not distinguished) owner (administrator) \"%g\" to \"%g\" ...", [rope[thisNameRope]], [rope[name]]];
                                [] Ź XNSCHACL.AddMemberToPropertyACL[c, nsName, members, administrators, thisName
                                    ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                                };
                            };
                        remove => {
                            d.out.PutF["\nRemoving owner (administrator) \"%g\" from \"%g\" ...", [rope[thisNameRope]], [rope[name]]];
                            [] Ź XNSCHACL.DeleteMemberFromPropertyACL[c, nsName, members, administrators, thisName
                                ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                            IF problems THEN {
                                [distingName, problems, , ] Ź DistinguishedName[thisName, c];
                                IF ~problems THEN {
                                    d.out.PutF1[" trying distinguished name \"%g\" ...", [rope[distingNameRope]]];
                                    [] Ź XNSCHACL.DeleteMemberFromPropertyACL[c, nsName, members, administrators, distingName
                                        ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                                    };
                                };
                            };
                        ENDCASE => NotImplementedYet[d];
                    IF problems THEN {
                        d.out.PutF1[" Error => %g", [rope[ExposeErrorCode[eC, LOOPHOLE[eW]]]]];
                        problems Ź FALSE;
                        }
                    ELSE d.out.PutRope[" ok."];
                    };
                DoForEachArgument[d, c, UpdateOneOwner, cb.cmd = add, cb.cmd = add];
                };
            UpdateFriend: PROC = {
                UpdateOneFriend: PROC [thisName: Name, thisNameRope: ROPE, distingName: Name, distingNameRope: ROPE, disting: BOOL]= {
                    SELECT cb.cmd FROM
                        add => {
                            IF disting THEN {
                                d.out.PutF["\nAdding friend (self-controller) \"%g\" to \"%g\" ...", [rope[distingNameRope]], [rope[name]]];
                                [] Ź XNSCHACL.AddMemberToPropertyACL[c, nsName, members, selfControl, distingName
                                    ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                                }
                            ELSE {
                                d.out.PutF["\nAdding (possibly not distinguished) friend (self-controller) \"%g\" to \"%g\" ...", [rope[thisNameRope]], 
                                [rope[name]]];
                                [] Ź XNSCHACL.AddMemberToPropertyACL[c, nsName, members, selfControl, thisName
                                    ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                                };
                            };
                        remove => {
                            d.out.PutF["\nRemoving friend (self-controller) \"%g\" from \"%g\" ...", [rope[thisNameRope]], [rope[name]]];
                            [] Ź XNSCHACL.DeleteMemberFromPropertyACL[c, nsName, members, selfControl, thisName
                                ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                            IF problems THEN {
                                [distingName, problems, , ] Ź DistinguishedName[thisName, c];
                                IF ~problems THEN {
                                    d.out.PutF1[" trying distinguished name \"%g\" ...", [rope[distingNameRope]]];
                                    [] Ź XNSCHACL.DeleteMemberFromPropertyACL[c, nsName, members, selfControl, distingName
                                        ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                                    };
                                };
                            };
                        ENDCASE => NotImplementedYet[d];
                    IF problems THEN {
                        d.out.PutF1[" Error => %g", [rope[ExposeErrorCode[eC, LOOPHOLE[eW]]]]];
                        problems Ź FALSE;
                        }
                    ELSE d.out.PutRope[" ok."];
                    };
                <<-- we set check to FALSE because friends should be able to be things like "*:*:Xerox">>
                DoForEachArgument[d, c, UpdateOneFriend, FALSE, cb.cmd = add];
                };
            UpdateSelf: PROC = {
                myGroup: Name;
                myGroupRope: ROPE;
                changed: BOOL Ź FALSE;
                [myGroup, myGroupRope, changed] Ź GetPossibleSubList[nsName];
                SELECT cb.cmd FROM
                    add => {
                        d.out.PutF1["\nAdding self to \"%g\" ...", [rope[name]]];
                        IF changed THEN d.out.PutF1[" split-list, using \"%g\" sub-list ...", [rope[myGroupRope]]];
                        [] Ź XNSCH.AddSelf[c, myGroup, members
                            ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                        };
                    remove => {
                        d.out.PutF1["\nRemoving self from \"%g\" ...", [rope[name]]];
                        IF changed THEN d.out.PutF1[" split-list, using \"%g\" sub-list ...", [rope[myGroupRope]]];
                        [] Ź XNSCH.DeleteSelf[c, myGroup, members
                            ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                        };
                    ENDCASE => NotImplementedYet[d];
                IF problems THEN {
                    d.out.PutF1[" Error => %g", [rope[ExposeErrorCode[eC, LOOPHOLE[eW]]]]];
                    problems Ź FALSE;
                    }
                ELSE {
                    d.out.PutRope[" ok."];
                    };
                };
            UpdateOccurrences: PROC = {
                SELECT cb.cmd FROM
                    add => NotImplementedYet[d];
                    remove => NotImplementedYet[d];
                    ENDCASE => NotImplementedYet[d];
                };
            UpdateMailbox: PROC = {
                properties: XNSCH.Properties Ź GetProperties[nsName, c];
                item: Item;
                mbl: LIST OF ROPE  Ź NIL;
                existingMailboxes: LIST OF ROPE Ź NIL;
                IF HasProperty[mailboxes, properties]
                    THEN existingMailboxes Ź GetExistingMailboxes[nsName, c]
                ELSE {
                    d.out.PutRope[" creating mailboxes property ..."];
                    [] Ź XNSCH.AddItemProperty[c, nsName, mailboxes, MailboxItemFromList[NIL]
                        ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                    };
                FOR l: LIST OF ROPE Ź d.argList, l.rest WHILE l # NIL DO
                    distingName: Name;
                    problems: BOOL;
                    [distingName, problems, , ] Ź DistinguishedNameFromRope[l.first];
                    IF problems THEN
                        distingName Ź XNSCHName.NameFromRope[l.first];
                    mbl Ź CONS[XNSCHName.RopeFromName[distingName], mbl];
                    ENDLOOP;
                SELECT cb.cmd FROM
                    add => {
                        existingMailboxes Ź AddRopesToList[existingMailboxes, mbl];
                        };
                    remove => {
                        existingMailboxes Ź RemoveRopesFromList[existingMailboxes, d.argList];
                        existingMailboxes Ź RemoveRopesFromList[existingMailboxes, mbl];
                        };
                    ENDCASE => {
                        NotImplementedYet[d];
                        RETURN;
                        };
                IF existingMailboxes = NIL THEN {
                    d.out.PutRope[" no more mailboxes, deleting mailboxes property ..."];
                    [] Ź XNSCH.DeleteProperty[c, nsName, mailboxes
                        ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                        }
                ELSE {
                    d.out.PutRope[" changing mailboxes property to: "];
                    PutRopeList[d, existingMailboxes];
                    d.out.PutRope[" ..."];
                    item Ź MailboxItemFromList[existingMailboxes];
                    [] Ź XNSCH.ChangeItemProperty[c, nsName, mailboxes, item
                        ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                    };
                };
            UpdateForwarding: PROC = {
                DoNothingEnumeratorProc: PROC [XNSCH.ElementStreamProc] = {RETURN};
                GetProperties: PROC [name: Name] RETURNS [XNSCH.Properties] = {
                    [, properties] Ź XNSCH.GetProperties[c, name
                        ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                    RETURN[properties];
                    };
                HasAtLeastOneMember: PROC [group: Name] RETURNS[BOOL] = {
                    BumpCount: PROC [name: Name] = {
                        count Ź count + 1;
                        };
                    count: CARD Ź 0;
                    [] Ź XNSCH.ListMembers[c, group, members, BumpCount
                        ! XNSCH.Error => {CONTINUE}];
                    RETURN[count > 0];
                    };
                properties: XNSCH.Properties Ź GetProperties[nsName];
                d.out.PutF[" %g forwarding %g \"%g\"...",
                    [rope[SELECT cb.cmd FROM
                        add => "adding",
                        remove => "removing",
                        ENDCASE => "???"]],
                    [rope[SELECT cb.cmd FROM
                        add => "to",
                        remove => "from",
                        ENDCASE => "???"]],
                    [rope[name]]];
                IF ~HasProperty[user, properties] THEN {
                    d.out.PutRope[" must be a user."];
                    RETURN;
                    };
                SELECT cb.cmd FROM
                    add => {
                        IF HasProperty[mailboxes, properties] THEN {
                            d.out.PutRope[" This user presently has Mailboxes, they should be removed ..."];
                            };
                        IF HasProperty[userGroup, properties]
                            THEN d.out.PutRope[" group property already exists ..."]
                        ELSE {
                            d.out.PutRope[" adding group property ..."];
                            [] Ź XNSCH.AddItemProperty[c, nsName, userGroup, XNSCHItemOps.ItemFromRope[args].newItem
                                ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                            };
                        IF HasProperty[members, properties]
                            THEN d.out.PutRope[" members property already exists ..."]
                        ELSE {
                            d.out.PutRope[" adding members property ..."];
                            [] Ź XNSCH.AddGroupProperty[c, nsName, members, DoNothingEnumeratorProc
                                ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                            };
                        d.out.PutRope["\n(Note: use Add Member to actually add names to the \"forwarding\" list.)"];
                        };
                    remove => {
                        IF ~HasProperty[members, properties]
                            THEN d.out.PutRope[" no members property to remove ..."]
                            ELSE {
                                IF HasAtLeastOneMember[nsName]
                                    THEN {
                                        d.out.PutRope[" still forwarding to at least one member, remove members first ..."];
                                        RETURN;
                                        }
                                    ELSE {
                                        d.out.PutRope[" removing members property ..."];
                                        [] Ź XNSCH.DeleteProperty[c, nsName, members
                                            ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                                        };
                                    };
                        IF ~HasProperty[userGroup, properties]
                            THEN d.out.PutRope[" no group property to remove ..."]
                            ELSE {
                                d.out.PutRope[" removing group property ..."];
                                [] Ź XNSCH.DeleteProperty[c, nsName, userGroup
                                    ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                                };
                        d.out.PutRope["\n(Note: use Remove Member to actually remove names from the \"forwarding\" list.)"];
                        };
                    ENDCASE => NotImplementedYet[d];
                };
            UpdateCreate: PROC = {
                CreateUserData: PROC [name: Name] = {
                    fsName: Name Ź [name.organization, name.domain, "UNKNOWN"];
                    item: Item Ź XNSCHItemOps.ItemFromCard16[Rope.FindBackward[name.object, " "]+1].newItem;
                    [] Ź XNSCHItemOps.NameIntoItem[item, fsName, 1];
                    [] Ź XNSCH.AddItemProperty[c, name, userData, item
                        ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                    };
                SELECT cb.what FROM
                    createIndividual => {
                        atom: ATOM Ź NARROW[d.cmdData];
                        SELECT atom FROM
                            $CreateCHS => {
                                address: XNS.Address;
                                address Ź Convert.XNSAddressFromRope[args
                                    ! Convert.Error => {problems Ź TRUE; CONTINUE}];
                                IF problems THEN {
                                    d.out.PutF1["\nYou must provide a valid address; \"%g\" is invalid.", [rope[args]]];
                                    GOTO someProblems;
                                    };
                                address.socket Ź XNS.unknownSocket;
                                nsName Ź [object: nsName.object, domain: "CHServers", organization: "CHServers"];
                                name Ź XNSCHName.RopeFromName[nsName];
                                d.out.PutF1["\nCreating CHS entry for \"%g\" ...", [rope[name]]];
                                [] Ź XNSCH.Add[c, nsName
                                    ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                                IF problems THEN GOTO someProblems;
                                d.out.PutF1[" adding address = %g ...", [rope[Convert.RopeFromXNSAddress[address]]]];
                                [] Ź XNSCH.AddItemProperty[c, nsName, addressList, XNSCHItemOps.ItemFromAddressList[LIST[address]].newItem
                                    ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                                IF problems THEN GOTO someProblems;
                                d.out.PutRope[" adding mailboxes property ..."];
                                [] Ź XNSCH.AddItemProperty[c, nsName, mailboxes, MailboxItemFromList[LIST[name]]
                                    ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                                IF problems THEN GOTO someProblems;
                                d.out.PutRope[" adding clearinghouseService property ..."];
                                [] Ź XNSCH.AddItemProperty[c, nsName, clearinghouseService, NEW[CHOpsP2V3.ItemObject[0]]
                                    ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                                d.out.PutF1[" %g.", [rope[IF ~problems THEN "ok" ELSE "errors"]]];
                                EXITS
                                    someProblems => NULL;
                                };
                            $CreateObject => {
                                d.out.PutF1["\nCreating object \"%g\" ...", [rope[name]]];
                                [] Ź XNSCH.Add[c, nsName
                                    ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                                };
                            ENDCASE => {
                                d.out.PutF1["\nCreating individual \"%g\" ...", [rope[name]]];
                                [] Ź XNSCH.Add[c, nsName
                                    ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                                IF ~problems THEN [] Ź XNSCH.AddItemProperty[c, nsName, user, XNSCHItemOps.ItemFromRope[args].newItem
                                    ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                                IF ~problems THEN CreateUserData[nsName];
                                };
                        };
                    createGroup => {
                        DoNothingEnumeratorProc: PROC [XNSCH.ElementStreamProc] = {RETURN};
                        d.out.PutF1["\nCreating group \"%g\" ...", [rope[name]]];
                        [] Ź XNSCH.Add[c, nsName
                            ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                        IF ~problems THEN [] Ź XNSCH.AddItemProperty[c, nsName, userGroup, XNSCHItemOps.ItemFromRope[args].newItem
                            ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                        IF ~problems THEN [] Ź XNSCH.AddGroupProperty[c, nsName, members, DoNothingEnumeratorProc
                            ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                        };
                    ENDCASE => NotImplementedYet[d];
                IF problems THEN {
                    d.out.PutF1[" Error => %g", [rope[ExposeErrorCode[eC, LOOPHOLE[eW]]]]];
                    problems Ź FALSE;
                    }
                ELSE {
                    d.out.PutRope[" ok."];
                    };
                };
            UpdateDelete: PROC = {
                d.out.PutF1["\nDeleting object \"%g\" ...", [rope[name]]];
                [] Ź XNSCH.Delete[c, nsName
                    ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                IF problems THEN {
                    d.out.PutF1[" Error => %g", [rope[ExposeErrorCode[eC, LOOPHOLE[eW]]]]];
                    problems Ź FALSE;
                    }
                ELSE {
                    d.out.PutRope[" ok."];
                    };
                };
            c: XNSCH.Conversation Ź XNSCH.InitiateConversation[d.identity, d.conversationAddress];
            eC: XNSCH.ErrorCode;
            eW: XNSCH.Which;
            problems: BOOL Ź FALSE;
            nsName, argAsName: Name;
            prop: Property;
            atom: ATOM;
            IF ISTYPE[d.cmdData, ATOM] THEN {
                atom Ź NARROW[d.cmdData];
                prop Ź PropertyFromAtom[atom, d];
                };
            nsName Ź XNSCHName.NameFromRope[name
                ! XNSCHName.FieldTooLong => {RESUME;}];
            argAsName Ź XNSCHName.NameFromRope[args
                ! XNSCHName.FieldTooLong => {RESUME;}];
            IF cb.what # createIndividual AND cb.what # createGroup AND ~CheckName[nsName, c] THEN {
                d.out.PutF1["\"%g\" is an invalid name.", [rope[XNSCHName.RopeFromName[nsName]]]];
                XNSCH.TerminateConversation[c];
                RETURN;
                };
            SELECT cb.what FROM
                password, simple => UpdatePassword[];
                alias => {
                    IF cb.cmd = remove
                        THEN {
                            IF atom = $RemoveAlias
                                THEN UpdateAlias[]
                                ELSE RemoveProperty[PropertyFromSelection[d]];
                            }
                        ELSE UpdateAlias[];
                    };
                self => UpdateSelf[];
                individualRemark, groupRemark => UpdateRemark[];
                fileService => UpdateProperties[];
                member => UpdateMember[];
                owner => UpdateOwner[];
                friend => UpdateFriend[];
                mailbox => UpdateMailbox[];
                forwarding => UpdateForwarding[];
                occurrences => UpdateOccurrences[];
                createIndividual, createGroup => UpdateCreate[];
                delete => UpdateDelete[];
                ENDCASE => NotImplementedYet[d];
            XNSCH.TerminateConversation[c];
            };

        HasProperty: PROC [prop: Property, properties: XNSCH.Properties] RETURNS [BOOL] = {
            FOR pi: CARDINAL IN [0..properties.length) DO
                IF properties[pi] = prop THEN RETURN[TRUE];
                ENDLOOP;
            RETURN[FALSE];
            };

        DoTypeCommand: PROC [d: MyData, cb: MaintainDefs.CmdButton, name, args: ROPE] = {
            PutOneFink: PROC [fink: Name, allDownList: LIST OF ROPE, c: XNSCH.Conversation, doDelete: BOOL Ź FALSE, group: Name Ź [NIL, NIL, 
            NIL]] RETURNS [LIST OF ROPE] = {
                RopeInList: PROC [r: ROPE, l: LIST OF ROPE] RETURNS [BOOL] = {
                    FOR l Ź l, l.rest WHILE l # NIL DO
                        IF Rope.Equal[r, l.first, FALSE] THEN RETURN[TRUE];
                        ENDLOOP;
                    RETURN[FALSE];
                    };
                deleteThisFink: BOOL Ź FALSE;
                nr: ROPE = XNSCHName.RopeFromName[fink];
                IF d.verbose THEN {
                    problems: BOOL Ź FALSE;
                    eC: XNSCH.ErrorCode;
                    eW: XNSCH.Which;
                    properties: XNSCH.Properties;
                    domainOrganization: ROPE Ź Rope.Cat[fink.domain, ":", fink.organization];
                    IF RopeInList[domainOrganization, allDownList]
                        THEN {eC Ź allDown; problems Ź TRUE}
                        ELSE [, properties] Ź XNSCH.GetProperties[c, fink
                            ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                    SELECT TRUE FROM
                        problems => SELECT eC FROM
                            illegalPropertyID, illegalOrganizationName, illegalDomainName,
                            illegalObjectName, noSuchOrganization, noSuchDomain, noSuchObject => {
                                IF ExternalMailName[fink, c]
                                    THEN {
                                        d.out.PutF1["\n  \"%g\" => possible external mail name",
                                            [rope[nr]]];
                                        }
                                    ELSE {
                                        d.out.PutF["\n  \"%g\" => %g",
                                            [rope[nr]],
                                            [rope[ExposeErrorCode[eC, LOOPHOLE[eW]]]]];
                                        deleteThisFink Ź TRUE;
                                        };
                                };
                            ENDCASE => {
                                IF eC = allDown THEN
                                    IF ~RopeInList[domainOrganization, allDownList] THEN allDownList Ź CONS[domainOrganization, allDownList];
                                d.out.PutF["\n  \"%g\" => %g",
                                    [rope[nr]],
                                    [rope[ExposeErrorCode[eC, LOOPHOLE[eW]]]]];
                                };
                        (~HasProperty[mailboxes, properties]
                            AND ~HasProperty[members, properties]) =>
                                d.out.PutF1["\n  \"%g\" => no mailbox or members.", [rope[nr]]];
                        ENDCASE;
                    };
                IF deleteThisFink AND doDelete THEN DO {
                    problems Ź FALSE;
                    d.out.PutRope[" => Deleting ..."];
                    [] Ź XNSCH.DeleteMember[c, group, members, fink
                        ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                    IF problems THEN {
                        d.out.PutF1[" Error => %g", [rope[ExposeErrorCode[eC, LOOPHOLE[eW]]]]];
                        IF eC = overflowOfDataBase THEN {
                            d.out.PutRope["; Pausing for 5 minutes and then I'll try again ..."];
                            FOR i: CARD IN [0..(5*60)) WHILE ~d.stop DO
                                Process.Pause[Process.SecondsToTicks[1]];
                                ENDLOOP;
                            IF d.stop THEN EXIT;
                            LOOP;
                            };
                        }
                        ELSE d.out.PutRope[" deleted."];
                    EXIT;
                    } ENDLOOP;
                count Ź SUCC[count];
                RETURN[allDownList];
                };
            PutOneName: PROC [name: Name] = {
                IF ~firstName OR (cb.what = matches AND ~d.firstTime)
                    THEN d.out.PutRope[", "]
                    ELSE {firstName Ź FALSE; d.firstTime Ź FALSE};
                count Ź SUCC[count];
                d.out.PutF1["\"%g\"", [rope[XNSCHName.RopeFromName[name]]]];
                };
            PutOneDomainName: PROC [name: Name] = {
                IF firstName
                    THEN firstName Ź FALSE
                    ELSE d.out.PutRope[", "];
                count Ź SUCC[count];
                d.out.PutF["\"%g:%g\"", [rope[name.domain]], [rope[name.organization]]];
                };
            PutOneOrganizationName: PROC [name: Name] = {
                IF firstName
                    THEN firstName Ź FALSE
                    ELSE d.out.PutRope[", "];
                count Ź SUCC[count];
                d.out.PutF1["\"%g\"", [rope[name.organization]]];
                };
            PutItemAsRope: PROC [item: Item] = {
                rope: ROPE Ź XNSCH.RopeFromItem[item];
                d.out.PutF1["\"%g\"", [rope[rope]]];
                };
            PutItemAsName: PROC [item: Item, offset: INT Ź 0] = {
                name: Name Ź XNSCHItemOps.NameFromItem[item, offset].name;
                rope: ROPE Ź XNSCHName.RopeFromName[name];
                d.out.PutF1["\"%g\"", [rope[rope]]];
                };
            PutItemAsItem: PROC [item: Item, full: BOOL Ź FALSE] = {
                d.out.PutF1["length = %g", [cardinal[item.length]]];
                IF ~full OR item.length = 0 THEN RETURN;
                d.out.PutRope[":  "];
                FOR i: CARDINAL IN [0..item.length) DO
                    IF i # 0 THEN d.out.PutRope[", "];
                    d.out.PutF["%g (%g)", [cardinal[item[i]]], [rope[Convert.RopeFromCard[item[i], 8]]]];
                    ENDLOOP;
                };
            MaybePutItemAsRope: PROC [item: Item, full: BOOL Ź FALSE] = {
                IF item # NIL AND item.length > 0 AND item.length = LOOPHOLE[1 + (item[0]+1)/2, CARDINAL]
                    THEN PutItemAsRope[item]
                    ELSE PutItemAsItem[item, full];
                };
            PutUserDataInfo: PROC [item: Item, user: ROPE, details: BOOL, leadingSpace: ROPE Ź ""] = {
                name: Name;
                IF details THEN d.out.PutF["\n%gLast Name: \"%g\"",
                    [rope[leadingSpace]],
                    [rope[IF item.length <= 0 OR item[0] > Rope.Length[user]
                        THEN "(Invalid Index)"
                        ELSE Rope.Substr[user, item[0]]]]];
                name Ź XNSCHItemOps.NameFromItem[item, 1].name;
                d.out.PutF["\n%gUsers's File Service: \"%g\"", [rope[leadingSpace]], [rope[XNSCHName.RopeFromName[name]]]];
                };
            PutMailboxInfo: PROC [item: Item, leadingSpace: ROPE Ź "", printTime: BOOL] = {
                ENABLE
                    XNSCHItemOps.Error => {
                    d.out.PutRope["\nMailboxes: malformed property!"];
                    GOTO OutOfHere;
                    };
                pos: INT Ź 3;
                mailboxList: LIST OF Name;
                IF printTime THEN d.out.PutF["\n%gTime: %g", [rope[leadingSpace]], 
                [rope[Convert.RopeFromTime[BasicTime.FromNSTime[NSTimeFromItem[item]]]]]];
                d.out.PutF1["\n%gMailboxes: ", [rope[leadingSpace]]];
                mailboxList Ź XNSCHItemOps.NameListFromItem[item, 2].names;
                WHILE mailboxList # NIL DO
                    d.out.PutF1["\"%g\"", [rope[XNSCHName.RopeFromName[mailboxList.first]]]];
                    IF mailboxList.rest # NIL THEN d.out.PutRope[", "];
                    mailboxList Ź mailboxList.rest;
                    ENDLOOP;
                EXITS
                    OutOfHere => RETURN;
                };
            PutItemAsAddressList: PROC [item: Item] = {
                addresses: LIST OF XNS.Address;
                addresses Ź XNSCHItemOps.AddressListFromItem[item
                    ! XNSCHItemOps.Error => {addresses Ź NIL; CONTINUE}].addresses;
                PutAddressList[d, addresses];
                };
            PutItemAsAuthenticationLevel: PROC [item: Item] = {
                ENABLE
                    XNSCHItemOps.Error => {
                    d.out.PutRope["I don't understand: "];
                    PutItemAsItem[item, d.verbose];
                    GOTO OutOfHere;
                    };
                simpleSupported: BOOL = XNSCHItemOps.BoolFromItem[item, 0].bool;
                strongSupported: BOOL = XNSCHItemOps.BoolFromItem[item, 1].bool;
                IF simpleSupported THEN d.out.PutRope["simpleSupported"];
                IF strongSupported THEN d.out.PutF1["%gstrongSupported",
                    [rope[IF simpleSupported THEN ", " ELSE ""]]];
                EXITS
                    OutOfHere => RETURN;
                };
            CountMembers: PROC [group: Name, prop: Property] RETURNS[CARD] = {
                BumpCount: PROC [name: Name] = {
                    count Ź count + 1;
                    };
                count: CARD Ź 0;
                [] Ź XNSCH.ListMembers[c, group, prop, BumpCount
                    ! XNSCH.Error => {CONTINUE}];
                RETURN[count];
                };

            GiveNSInfo: PROC [level: What] = {
                OPEN CHEntriesP0V0;
                giveDetails: BOOL Ź FALSE;
                properties: XNSCH.Properties Ź NIL;
                [distingName , properties] Ź XNSCH.GetProperties[c, pattern
                    ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                IF d.stop THEN RETURN;
                IF problems THEN SELECT eC FROM
                    noSuchObject, allDown, wasUpNowDown => RETURN;
                    ENDCASE => IF ExternalMailName[pattern, c] THEN NULL ELSE RETURN;
                IF d.firstTime
                    THEN d.firstTime Ź FALSE
                    ELSE d.out.PutChar['\n];
                IF problems THEN {
                    d.out.PutF1["\nName: \"%g\"", [rope[name]]];
                    d.out.PutF["\nThe domain \"%g:%g\" appears to be connected via an External Mail Gateway.  (An External Mail Gateway is a 
                    \"controlled\" gateway that passes mail only -- it does not allow access to file servers, clearinghouses, etc.) 
                     The name \"%g\" may or may not be valid in that domain -- it is impossible to determine that from here.  
                    Individuals within such a domain are most likely not Xerox employes.  Caution should be exercised when sending 
                    sensitive data to this name or before adding such a name to a DL.", [rope[pattern.domain]], 
                    [rope[pattern.organization]], [rope[pattern.object]]];
                    problems Ź FALSE;
                    RETURN;
                    };
                d.out.PutF1["\nDistinguished name: \"%g\"", [rope[XNSCHName.RopeFromName[distingName]]]];
                IF d.stop OR NARROW[d.cmdData, ATOM] = $DistingOnly THEN RETURN;
                d.out.PutRope["\nAliases: "];
                [] Ź XNSCH.ListAliases[c, pattern, PutOneName
                    ! XNSCH.Error => {eC Ź code; eW Ź which; CONTINUE}];
                IF count = 0 THEN d.out.PutRope["(none)"];
                IF d.stop THEN RETURN;
                giveDetails Ź cb.what = details;
                FOR pi: CARDINAL IN [0..properties.length) DO
                    clProc: MaintainProcs.ChangeLooksProc Ź LOOPHOLE[MaintainDefs.RetrieveProc[d.flavor, $ChangeLooks]];
                    unknown: BOOL;
                    propInfo: PropertyInfoObject;
                    propType: PropType;
                    prop: Property Ź properties.body[pi];
                    IF d.stop THEN RETURN;
                    propInfo Ź GetPropertyInfo[prop];
                    unknown Ź propInfo.codeLabel = NIL;
                    IF (unknown AND ~giveDetails) OR propInfo.detailed AND ~giveDetails THEN LOOP;
                    IF ~propInfo.subLabels THEN d.out.PutF1["\n%g: ",
                        [rope[IF unknown
                            THEN Rope.Concat["Property ", propInfo.label]
                            ELSE propInfo.label]]];
                    propType Ź propInfo.propType;
                    SELECT propType FROM
                        group => {
                            atom: ATOM = NARROW[d.cmdData, ATOM];
                            firstName Ź TRUE;
                            IF d.verbose
                                THEN [] Ź XNSCH.ListMembers[c, pattern, prop, PutOneName
                                    ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}]
                                ELSE d.out.PutF1["%g", [cardinal[CountMembers[pattern, prop]]]];
                            IF atom # $NoACLInfo THEN {
                                FOR acl: AccessList IN [readAccess..selfControl] DO
                                    n: CARD Ź count;
                                    IF d.stop THEN RETURN;
                                    IF clProc # NIL THEN
                                        clProc[d, 'i];
                                    SELECT acl FROM
                                        readAccess => {d.out.PutRope["\nReaders: "];};
                                        administrators => {d.out.PutRope["\nAdministrators: "];};
                                        selfControl => {d.out.PutRope["\nSelfControllers: "];};
                                        ENDCASE => LOOP;
                                    IF clProc # NIL THEN
                                        clProc[d, ' ];
                                    firstName Ź TRUE;
                                    [] Ź XNSCHACL.ListMembersOfPropertyACL[c, pattern, prop, acl, PutOneName
                                        ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                                    IF n = count THEN d.out.PutRope["(none)"];
                                    ENDLOOP;
                                    };
                            };
                        ENDCASE => {
                            item: Item;
                            [, item] Ź XNSCH.LookupItemProperty[c, pattern, prop
                                ! XNSCH.Error => {CONTINUE}];
                            IF item # NIL THEN SELECT propType FROM
                                unknown => MaybePutItemAsRope[item, d.verbose];
                                rope => PutItemAsRope[item];
                                name => PutItemAsName[item];
                                authenticationLevel => PutItemAsAuthenticationLevel[item];
                                addressList => PutItemAsAddressList[item];
                                userData => PutUserDataInfo[item, distingName.object, giveDetails, ""];
                                mailboxInfo => PutMailboxInfo[item, "", giveDetails];
                                ENDCASE => d.out.PutRope["???"];
                            };
                    ENDLOOP;
                };
            c: XNSCH.Conversation Ź XNSCH.InitiateConversation[d.identity, d.conversationAddress];
            pattern: Name Ź XNSCHName.NameFromRope[name
                ! XNSCHName.FieldTooLong => {RESUME;}];
            distingName: Name;
            fullName: ROPE;
            problems: BOOL Ź FALSE;
            firstName: BOOL Ź TRUE;
            count: CARD Ź 0;
            eC: XNSCH.ErrorCode;
            eW: XNSCH.Which;
            fullName Ź XNSCHName.RopeFromName[pattern];
            SELECT cb.what FROM
                members => {
                    prop: Property;
                    atom: ATOM Ź NARROW[d.cmdData];
                    prop Ź PropertyFromAtom[atom, d];
                    IF ~d.firstTime THEN d.out.PutChar['\n];
                    d.out.PutF1["\nMembers of \"%g\":\n", [rope[fullName]]];
                    [] Ź XNSCH.ListMembers[c, pattern, prop, PutOneName
                        ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                    IF ~problems THEN d.out.PutF["\n(%g %g)", [cardinal[count]], [rope[MaintainMisc.Plural["member", "members", count]]]];
                    };
                finks => {
                    start, finish: BasicTime.GMT;
                    startThisFink, finishThisFink: BasicTime.Pulses;
                    membersList: LIST OF Name;
                    allDownList: LIST OF ROPE;
                    AddNameToList: PROC [name: Name] = {
                        membersList Ź CONS[name, membersList];
                        count Ź count + 1;
                        };
                    ReverseList: PROC [original: LIST OF Name] RETURNS[newList: LIST OF Name]= {
                        FOR list: LIST OF Name Ź original, list.rest UNTIL list = NIL DO
                            newList Ź CONS[list.first, newList];
                            ENDLOOP;
                        };
                    IF d.firstTime
                        THEN d.firstTime Ź FALSE
                        ELSE d.out.PutChar['\n];
                    d.out.PutF1["\nFinks in group \"%g\":", [rope[fullName]]];
                    start Ź BasicTime.Now[];
                    IF d.debugSwitch THEN
                        d.out.PutF1[" [%g]", [time[BasicTime.Now[]]]];
                    [] Ź XNSCH.ListMembers[c, pattern, members, AddNameToList
                        ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                    d.out.PutF[" (%g %g)", [cardinal[count]], [rope[MaintainMisc.Plural["member", "members", count]]]];
                    IF ~problems THEN {
                        membersList Ź ReverseList[membersList];
                        FOR m: LIST OF Name Ź membersList, m.rest WHILE m # NIL AND ~d.stop DO
                            IF d.debugSwitch THEN
                                d.out.PutF["\n  ... \"%g\" [%g] ...",
                                    [rope[XNSCHName.RopeFromName[m.first]]],
                                    [time[BasicTime.Now[]]]];
                            startThisFink Ź BasicTime.GetClockPulses[];
                            allDownListŹ PutOneFink[m.first, allDownList, c, d.autoDelete, pattern];
                            finishThisFink Ź BasicTime.GetClockPulses[];
                            IF d.debugSwitch THEN
                                d.out.PutF1[" (took: %g)", [rope[RealSecsToRope[BasicTime.PulsesToSeconds[finishThisFink-startThisFink]]]]];
                            ENDLOOP;
                        finish Ź BasicTime.Now[];
                        IF d.debugSwitch THEN
                            d.out.PutF1["\n  (Total: %g)", [rope[PeriodToRope[BasicTime.Period[start, finish]]]]];
                        };
                    };
                matches => PutOneName[pattern];
                summary => GiveNSInfo[summary];
                details => GiveNSInfo[details];
                domains =>  {
                    orgNotProvided: ROPE = "orgNotProvided";
                    pattern Ź XNSCHName.NameFromRope[name, orgNotProvided
                        ! XNSCHName.FieldTooLong => {RESUME;}];
                    IF ~Rope.Equal[pattern.domain, orgNotProvided] THEN pattern.organization Ź pattern.domain;
                    pattern.domain Ź pattern.object;
                    pattern.object Ź NIL;
                    d.out.PutF1["\nDomains matching \"%g\": ", [rope[name]]];
                    XNSCH.EnumerateDomains[c, pattern, PutOneDomainName
                        ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                    IF ~problems THEN d.out.PutF["\n(%g %g)", [cardinal[count]], [rope[MaintainMisc.Plural["match", "matches", count]]]];
                    };
                organizations =>  {
                    pattern.organization Ź pattern.object;
                    pattern.domain Ź NIL;
                    pattern.object Ź NIL;
                    XNSCH.EnumerateOrganizations[c, pattern, PutOneOrganizationName
                        ! XNSCH.Error => {eC Ź code; eW Ź which; problems Ź TRUE; CONTINUE}];
                    IF ~problems THEN d.out.PutF["\n(%g %g)", [cardinal[count]], [rope[MaintainMisc.Plural["match", "matches", count]]]];
                    };
                domainsServed =>  {
                    n: CARD Ź 0;
                    ce: GluePruneHacks.CacheEntry;
                    d.out.PutF1["\n\nDomains served by \"%g\": ", [rope[name]]];
                    ce Ź GluePruneHacks.DomainsForServer[name];
                    d.out.PutF1["\nKey: \"%g\"", [rope[ce.key]]];
                    d.out.PutF1[", ok: %g", [rope[IF ce.ok THEN "TRUE" ELSE "FALSE"]]];
                    IF ~ce.ok THEN d.out.PutF1[", reason = %g", [rope[GluePruneHacks.ExposeErrorCode[ce.reason]]]];
                    d.out.PutRope["\nValue: "];
                    FOR rl: GluePruneHacks.RopeList Ź ce.value, rl.rest WHILE rl # NIL DO
                        d.out.PutF["%g\"%g\"", [rope[IF n = 0 THEN "" ELSE ", "]], [rope[rl.first]]];
                        n Ź n + 1;
                        ENDLOOP;
                    d.out.PutF1["\nTotal Domains served: %g", [cardinal[n]]];
                    };
                direct, occurrences =>  {
                    FOR argList: LIST OF ROPE Ź d.argList, argList.rest WHILE argList # NIL DO
                        memberRopeToCheck: ROPE Ź argList.first;
                        memberToCheck: Name;
                        yes: BOOL Ź FALSE;
                        <<Notice that we don't automatically distinguish the name...>>
                        memberToCheck Ź XNSCHName.NameFromRope[memberRopeToCheck
                            ! XNSCHName.FieldTooLong => {RESUME;}];
                        problems Ź FALSE;
                        [ , yes] Ź XNSCH.IsMember[c, pattern, members, memberToCheck
                            ! XNSCH.Error => {CONTINUE}];
                        IF ~problems THEN {
                            IF cb.what = direct
                                THEN d.out.PutF["\n\"%g\" IS%g a direct member of \"%g\".",
                                    [rope[memberRopeToCheck]],
                                    IF yes THEN [rope[""]] ELSE [rope[" NOT"]],
                                    [rope[XNSCHName.RopeFromName[pattern]]]]
                                ELSE IF yes THEN {
                                    IF d.firstTime
                                        THEN d.firstTime Ź FALSE
                                        ELSE d.out.PutRope[", "];
                                    d.out.PutF1["\"%g\"", [rope[name]]];
                                    };
                            };
                        ENDLOOP;

                    };
                extended =>  {
                    FOR argList: LIST OF ROPE Ź d.argList, argList.rest WHILE argList # NIL DO
                        memberRopeToCheck: ROPE Ź argList.first;
                        memberToCheck: Name;
                        yes: BOOL Ź FALSE;
                        <<Notice that we don't automatically distinguish the name...>>
                        memberToCheck Ź XNSCHName.NameFromRope[memberRopeToCheck
                            ! XNSCHName.FieldTooLong => {RESUME;}];
                        problems Ź FALSE;
                        [ , yes] Ź XNSCH.IsMemberClosure[c, pattern, members, memberToCheck
                            ! XNSCH.Error => {CONTINUE}];
                        IF ~problems THEN
                            d.out.PutF["\n\"%g\" IS%g a member of \"%g\".", [rope[memberRopeToCheck]], IF yes THEN [rope[""]] ELSE [rope[" NOT"]], 
                            [rope[XNSCHName.RopeFromName[pattern]]]];
                        ENDLOOP;
                    };
                ENDCASE => NotImplementedYet[d];
            IF problems THEN {
                d.out.PutF1["\nError: %g", [rope[ExposeErrorCode[eC, LOOPHOLE[eW]]]]];
                };
            XNSCH.TerminateConversation[c];
            IF d.stop THEN { IO.PutRope[d.out, "\nStopping...\n"]};
            };

        NSTimeFromItem: PROC [item: Item, index: CARD Ź 0] RETURNS [CARD] = {
            RETURN[
                XNSCHItemOps.Card32FromItem[item, index
                    ! XNSCHItemOps.Error => {GOTO OutOfHere}].card
                ];
            EXITS
                OutOfHere => RETURN[BasicTime.ToNSTime[BasicTime.Now[]]];
            };

        GetProperties: PROC [name: Name, c: XNSCH.Conversation Ź NIL] RETURNS [XNSCH.Properties] = {
            newConversation: BOOL Ź c = NIL;
            properties: XNSCH.Properties;
            IF newConversation THEN c Ź XNSCH.InitiateConversation[];
            [, properties] Ź XNSCH.GetProperties[c, name
                ! XNSCH.Error => {CONTINUE}];
            IF newConversation THEN XNSCH.TerminateConversation[c];
            RETURN[properties];
            };

        GetExistingMailboxes: PROC [name: Name, c: XNSCH.Conversation Ź NIL] RETURNS [ropes: LIST OF ROPE] = {
            newConversation: BOOL Ź c = NIL;
            lastRope: LIST OF ROPE;
            names: LIST OF Name;
            item: Item;
            IF newConversation THEN c Ź XNSCH.InitiateConversation[];
            [, item] Ź XNSCH.LookupItemProperty[c, name, mailboxes
                ! XNSCH.Error => {CONTINUE}];
            names Ź XNSCHItemOps.NameListFromItem[item, 2
                ! XNSCHItemOps.Error => {
                    IF newConversation THEN XNSCH.TerminateConversation[c];
                    GOTO OutOfHere;
                    }].names;
            WHILE names # NIL DO
                IF ropes = NIL
                    THEN lastRope Ź ropes Ź LIST[XNSCHName.RopeFromName[name]]
                    ELSE lastRope Ź lastRope.rest Ź LIST[XNSCHName.RopeFromName[name]];
                names Ź names.rest;
                ENDLOOP;
            IF newConversation THEN XNSCH.TerminateConversation[c];
            EXITS
                OutOfHere => RETURN[NIL];
            };

        MailboxItemFromList: PROC [list: LIST OF ROPE, time: CARD Ź BasicTime.ToNSTime[BasicTime.Now[]]] RETURNS [item: Item] = {
            names: CARD16 Ź 0;
            thisName: Name;
            pos: CARD Ź 3;
            FOR l: LIST OF ROPE Ź list, l.rest WHILE l # NIL DO
                thisName Ź XNSCHName.NameFromRope[l.first];
                [item, pos] Ź XNSCHItemOps.ItemFromName[thisName, pos, item];
                names Ź names + 1;
                ENDLOOP;
            [] Ź XNSCHItemOps.Card32IntoItem[item, time, 0];
            [] Ź XNSCHItemOps.Card16IntoItem[item, names, 2];
            };

        ItemFromListOfCard16Rope: PROC [list: ROPE] RETURNS [item: Item] = {
            count: INT Ź 0;
            number: CARD16;
            errors: BOOL Ź FALSE;
            BumpCount: PROC [r: ROPE] = {
                number Ź Convert.CardFromRope[r
                    ! Convert.Error => {errors Ź TRUE; CONTINUE}];
                count Ź count+1;
                };
            FillInItem: PROC [r: ROPE] = {
                number Ź Convert.CardFromRope[r];
                item[count] Ź number;
                count Ź count+1;
                };
            MaintainMisc.CallForItems[NEW[MyDataObject], list, BumpCount];
            IF errors THEN RETURN[NIL];
            item Ź XNSCHItemOps.CreateNewItem[count];
            count Ź 0;
            MaintainMisc.CallForItems[NEW[MyDataObject], list, FillInItem];
            RETURN[item];
            };

        AddressListFromRopeList: PROC [list: ROPE] RETURNS [addresses: LIST OF XNS.Address] = {
            lastAddress: LIST OF XNS.Address;
            AddAddress: PROC [r: ROPE] = {
                address: XNS.Address Ź Convert.XNSAddressFromRope[r];
                IF addresses = NIL
                    THEN lastAddress Ź addresses Ź LIST[address]
                    ELSE lastAddress Ź lastAddress.rest Ź LIST[address];
                };
            MaintainMisc.CallForItems[NEW[MyDataObject], list, AddAddress];
            };

        AddRopesToList: PROC [a, b: LIST OF ROPE] RETURNS [LIST OF ROPE] = {
            new: LIST OF ROPE;
            FOR a Ź a, a.rest WHILE a # NIL DO
                new Ź CONS[a.first, new];
                ENDLOOP;
            FOR b Ź b, b.rest WHILE b # NIL DO
                new Ź CONS[b.first, new];
                ENDLOOP;
            RETURN[new];
            };

        RemoveRopesFromList: PROC [a, b: LIST OF ROPE] RETURNS [LIST OF ROPE] = {
            new: LIST OF ROPE;
            FOR a Ź a, a.rest WHILE a # NIL DO
                IF ~RopeInList[a.first, b] THEN new Ź CONS[a.first, new];
                ENDLOOP;
            RETURN[new];
            };

        PutRopeList: PROC [d: MyData, l: LIST OF ROPE] = {
            first: BOOL Ź TRUE;
            FOR l Ź l, l.rest WHILE l # NIL DO
                IF first
                    THEN first Ź FALSE
                    ELSE d.out.PutRope[", "];
                d.out.PutF1["%g", [rope[l.first]]];
                ENDLOOP;
            };

        PutAddressList: PROC [d: MyData, addressList: LIST OF XNS.Address] = {
            first: BOOL Ź TRUE;
            WHILE addressList # NIL DO
                d.out.PutF["%g%g", [rope[IF first THEN "" ELSE ", "]], [rope[Convert.RopeFromXNSAddress[addressList.first]]]];
                first Ź FALSE;
                addressList Ź addressList.rest;
                ENDLOOP;
            };

        RopeInList: PROC [r: ROPE, l: LIST OF ROPE] RETURNS [BOOL] = {
            FOR l Ź l, l.rest WHILE l # NIL DO
                IF Rope.Equal[r, l.first, FALSE] THEN RETURN[TRUE];
                ENDLOOP;
            RETURN[FALSE];
            };

        DoSetServer: PUBLIC PROC [d: MyData, name: ROPE] = {
            tryCHS: BOOL Ź FALSE;
            adr: XNS.Address Ź XNS.unknownAddress;
            IF name = NIL OR Rope.Length[name] <= 1 THEN {
                d.out.PutRope["\nSetting NS server to ALL servers ... ok.\n"];
                d.conversationAddress Ź XNS.unknownAddress;
                RETURN;
                };
            d.out.PutF1["\nSetting NS server to: %g ... ", [rope[name]]];
            adr Ź Convert.XNSAddressFromRope[name
                ! Convert.Error => {tryCHS Ź TRUE; CONTINUE}];
            IF tryCHS THEN [, adr] Ź XNSCH.LookupAddressFromRope[name];
            d.out.PutF1[" (%g) ok.\n", [rope[Convert.RopeFromXNSAddress[adr]]]];
            d.conversationAddress Ź adr;
            };

        DistinguishedNameFromRope: PROC [name: ROPE, c: XNSCH.Conversation Ź NIL] RETURNS [distingName: Name, problems: BOOL, errorCode: 
        XNSCH.ErrorCode, which: XNSCH.Which, tooLong: BOOL] = {
            [distingName, problems, errorCode, which] Ź DistinguishedName[XNSCHName.NameFromRope[name
                ! XNSCHName.FieldTooLong => {tooLong Ź TRUE; RESUME;}], c];
            RETURN;
            };

        DistinguishedName: PROC [name: Name, c: XNSCH.Conversation Ź NIL] RETURNS [distingName: Name Ź [NIL, NIL, NIL], problems: BOOL Ź 
        FALSE, errorCode: XNSCH.ErrorCode Ź unknown, which: XNSCH.Which Ź first] = {
            newConversation: BOOL Ź c = NIL;
            IF newConversation THEN c Ź XNSCH.InitiateConversation[];
            distingName Ź XNSCH.Lookup[c, name
                ! XNSCH.Error => {errorCode Ź code; which Ź which; problems Ź TRUE; CONTINUE}];
            IF newConversation THEN XNSCH.TerminateConversation[c];
            };

        ExternalMailName: PROC [name: Name, c: XNSCH.Conversation Ź NIL] RETURNS [BOOL] = {
            <<Returns FALSE iff the name could not possibly be a valid ExternalMailName.  In other words, a returned value of TRUE does not 
            guarantee that the name is a valid ExternalMailName.>>
            errorCode: XNSCH.ErrorCode;
            problems: BOOL Ź FALSE;
            newConversation: BOOL Ź c = NIL;
            dots: ROPE = "...";
            obj: ROPE = Rope.Concat[name.domain, name.organization];
            IF Rope.Length[obj] > 40 THEN RETURN[FALSE];
            IF newConversation THEN c Ź XNSCH.InitiateConversation[];
            [] Ź XNSCH.Lookup[c, [dots, dots, obj]
                ! XNSCH.Error => {errorCode Ź code; problems Ź TRUE; CONTINUE}];
            IF newConversation THEN XNSCH.TerminateConversation[c];
            RETURN[~(problems AND errorCode = noSuchObject)];
            };

        IsGVName: PROC [name: ROPE] RETURNS[BOOLEAN] = {
            RETURN[name # NIL AND (Rope.Find[name, "@"] < 0)];
            };

        IsNsName: PROC [name: ROPE] RETURNS [BOOL] = {
            RETURN[name # NIL];
            };

        GetPossibleSubList: PROC [dl: Name] RETURNS [name: Name, nameRope: ROPE, changed: BOOL] = {
            changed Ź FALSE;
            <<IF ~EndsWith[dl.object, "-NS"] THEN {>>
                <<tempName: Name _ dl;>>
                <<tempName.object _ Rope.Cat[dl.object, "-NS"];>>
                <<IF CheckName[tempName] THEN {>>
                    <<dl _ tempName;>>
                    <<changed _ TRUE;>>
                    <<};>>
                <<};>>
            nameRope Ź XNSCHName.RopeFromName[dl];
            RETURN[dl, nameRope, changed];
            };

        NeedsQuotes: PROC [r: ROPE] RETURNS [BOOL] ~ {
            IF Rope.Length[r] = 0 OR (Rope.Find[r, "\""] < 0 AND Rope.Find[r, " "] >= 0) THEN RETURN [TRUE];
            RETURN[FALSE];
            };

        QuoteIfNeeded: PROC [r: ROPE] RETURNS [ROPE] ~ {
            IF NeedsQuotes[r] THEN RETURN [Rope.Cat["\"", r, "\""]];
            RETURN[r];
            };

        EndsWith: PROC [a, b: ROPE] RETURNS [BOOL] = {
            bLength: INT = Rope.Length[b];
            aLength: INT = Rope.Length[a];
            IF aLength < bLength THEN RETURN[FALSE];
            RETURN[Rope.Equal[Rope.Substr[a, aLength - bLength, bLength], b, FALSE]];
            };

        CheckName: PROC [name: Name, c: XNSCH.Conversation Ź NIL] RETURNS[BOOL] = {
            ok: BOOL Ź TRUE;
            checkForeign: BOOL Ź FALSE;
            newConversation: BOOL Ź c = NIL;
            IF newConversation THEN c Ź XNSCH.InitiateConversation[];
            [] Ź XNSCH.Lookup[c, name
                ! XNSCH.Error => {
                    SELECT code FROM
                        illegalOrganizationName, illegalDomainName, illegalObjectName, noSuchObject => ok Ź FALSE;
                        noSuchOrganization, noSuchDomain => checkForeign Ź TRUE;
                        ENDCASE;
                    CONTINUE}];
            IF checkForeign
                THEN ok Ź ExternalMailName[name, c];
            IF newConversation THEN XNSCH.TerminateConversation[c];
            RETURN[ok];
            };

        CheckNameRope: PROC [name: ROPE, c: XNSCH.Conversation Ź NIL] RETURNS[BOOL] = {
            RETURN[CheckName[XNSCHName.NameFromRope[name
                ! XNSCHName.FieldTooLong => {RESUME;}], c]];
            };

        PropertyInfoList: TYPE = LIST OF PropertyInfoObject;
        PropertyInfoObject: TYPE = RECORD [
            prop: Property,
            label: ROPE,
            shortLabel: ROPE,
            codeLabel: ROPE,
            propType: PropType Ź unknown,
            subLabels: BOOL Ź FALSE,
            detailed: BOOL Ź FALSE
            ]; 

        all: Property = 0;
        alias: Property = 1;
        aliases: Property = 2;
        simpleKey: Property = 7;
        server: Property = 10024;
        nullProperty: Property = 37777777777B;

        propertyInfoList: PropertyInfoList Ź LIST[
            [addressList, "Address List", "AddressList", "addressList", addressList],
            [adobeService, "Adobe Service", "Adobe", "adobeService"],
            [alias, "Alias", "Alias", "alias"],
            [aliases, "Aliases", "Aliases", "aliases"],
            [all, "Any Object", "Any", "all"],
            [associatedWorkstation, "Associated Workstation", "AWKS", "associatedWorkstation", name],
            [authenticationLevel, "Authentication Level", "AuthLevel", "authenticationLevel", authenticationLevel, FALSE, TRUE],
            [authenticationService, "Authentication Service", "Auth", "authenticationService"],
            [authKeys, "Auth Keys", "AuthKeys", "authKeys", unknown, FALSE, TRUE],
            [clearinghouseService, "Clearinghouse Service", "CHS", "clearinghouseService"],
            [communicationsInterfaceUnit, "Communications Interface Unit", "CIU", "communicationsInterfaceUnit"],
            [externalCommunicationsService, "External Communications Service", "ECS", "externalCommunicationsService"],
            [fetchService, "Fetch Service", "Fetch", "fetchService"],
            [fileService, "File Service", "FS", "fileService", rope],
            [foreignMailSystemName, "Foreign Mail System Name", "ForeignMailSystemName", "foreignMailSystemName", name],
            [gatewayService, "Gateway Service", "GWS", "gatewayService"],
            [interactiveTerminalService, "Interactive Terminal Service", "ITS", "interactiveTerminalService"],
            [internetworkRoutingService, "Internetwork Routing Service", "IRS", "interactiveTerminalService"],
            [librarianService, "Librarian Service", "Librarian", "librarianService"],
            [mailboxes, "Mailboxes", "MBX", "mailboxes", mailboxInfo, TRUE],
            [mailGateway, "Mail Gateway", "MGW", "mailGateway", rope],
            [mailGatewayRouteData, "Mail Gateway Route Data", "MailGatewayRouteData", "mailGatewayRouteData", group],
            [mailService, "Mail Service", "MS", "mailService"],
            [members, "Members", "Members", "members", group],
            [network, "Network", "Net", "network"],
            [networkServers, "Network Servers", "NetworkServers", "networkServers"],
            [nullProperty, "Null Property", "NullProperty", "nullProperty"],
            [printService, "Print Service", "PS", "printService"],
            [remoteBatchService, "Remote Batch Service", "RBS", "remoteBatchService"],
            [rs232CData, "RS232CData", "RS232CData", "rs232CData"],
            [rs232CPort, "RS232CPort", "RS232CPort", "rs232CPort"],
            [server, "Server", "Server", "server"],
            [services, "Services", "Services", "services"],
            [simpleKey, "Simple Key", "SimpleKey", "simpleKey", unknown, FALSE, TRUE],
            [user, "User Remark", "User", "user", rope],
            [userData, "User Data", "UserData", "userData", userData, TRUE],
            [userGroup, "Group Remark", "Group", "userGroup", rope],
            [userPassword, "User Password", "Password", "userPassword", rope, FALSE, TRUE],
            [workstation, "Workstation", "Workstation", "workstation"]
            ];


        HostAddressFromRope: PROC [r: ROPE] RETURNS[XNS.Host] = {
            RETURN[Convert.XNSHostFromRope[r ! Convert.Error => CONTINUE]];
            RETURN[Convert.XNSAddressFromRope[r ! Convert.Error => CONTINUE].host];
            RETURN[XNS.unknownHost];
            };

        HostAddressFromSelection: PROC [d: MyData] RETURNS[XNS.Host] = {
            sel: ROPE Ź NARROW[d.moreData];
            RETURN[HostAddressFromRope[sel]];
            };

        MatchHostAddressForObject: PROC [host: XNS.Host, obj: Name] RETURNS[BOOL] = {
            item: Item;
            addresses: LIST OF XNS.Address;
            error: BOOL Ź FALSE;
            c: XNSCH.Conversation Ź XNSCH.InitiateConversation[];
            [, item] Ź XNSCH.LookupItemProperty[c, obj, addressList
                ! XNSCH.Error => {error Ź TRUE; CONTINUE}];
            XNSCH.TerminateConversation[c];
            IF error THEN RETURN[FALSE];
            IF item.length > 0 THEN addresses Ź XNSCHItemOps.AddressListFromItem[item
                ! XNSCHItemOps.Error => {error Ź TRUE; CONTINUE}].addresses;
            IF error THEN RETURN[FALSE];
            FOR addresses Ź addresses, addresses.rest WHILE addresses # NIL DO
                IF host = addresses.first.host THEN RETURN[TRUE];
                ENDLOOP;
            RETURN[FALSE];
            };

        PropertyFromRope: PROC [r: ROPE] RETURNS[Property] = {
            prop: Property;
            isNumber: BOOL Ź TRUE;
            prop Ź Convert.CardFromRope[r
                ! Convert.Error => {isNumber Ź FALSE; CONTINUE}];
            IF isNumber THEN RETURN[prop];
            IF HostAddressFromRope[r] # XNS.unknownHost THEN RETURN[addressList];
            FOR pi: PropertyInfoList Ź propertyInfoList, pi.rest WHILE pi # NIL DO
                IF Rope.Equal[pi.first.label, r, FALSE]
                    OR Rope.Equal[pi.first.shortLabel, r, FALSE]
                    OR Rope.Equal[pi.first.codeLabel, r, FALSE]
                    THEN RETURN[pi.first.prop];
                ENDLOOP;
            r Ź ReplaceThisRope[r, " ", ""];
            r Ź Rope.Substr[r, 0, Rope.Index[r, 0, "serv", FALSE]];
            FOR pi: PropertyInfoList Ź propertyInfoList, pi.rest WHILE pi # NIL DO
                IF Rope.Find[pi.first.label, r, 0, FALSE] # -1
                    OR Rope.Find[pi.first.codeLabel, r, 0, FALSE] # -1
                    THEN RETURN[pi.first.prop];
                ENDLOOP;
            RETURN[nullProperty];
            };

        PropertyFromSelection: PROC [d: MyData] RETURNS[Property] = {
            sel: ROPE Ź NARROW[d.moreData];
            RETURN[PropertyFromRope[sel]];
            };

        PropertyFromAtom: PROC [atom: ATOM, d: MyData] RETURNS[Property] = {
            IF atom = $FromSelection THEN RETURN[PropertyFromSelection[d]];
            RETURN[PropertyFromRope[Atom.GetPName[atom]]];
            };

        GetPropertyInfo: PROC [prop: Property] RETURNS [PropertyInfoObject] = {
            FOR pi: PropertyInfoList Ź propertyInfoList, pi.rest WHILE pi # NIL DO
                IF prop = pi.first.prop THEN RETURN[pi.first];
                ENDLOOP;
            RETURN[[prop, Convert.RopeFromCard[prop], Convert.RopeFromCard[prop], NIL, unknown, FALSE, FALSE]];
            };

        ExposePropertyCode: PROC [prop: Property] RETURNS [ROPE] = {
            pi: PropertyInfoObject Ź GetPropertyInfo[prop];
            IF pi.codeLabel # NIL
                THEN RETURN[pi.codeLabel]
                ELSE RETURN[Rope.Concat["property", pi.shortLabel]];
            };

        ExposeAuthCallProblem: PROC [problem: AuthenticationP14V2.CallProblem] RETURNS[ROPE] = {
            RETURN[SELECT problem FROM
                tooBusy => "tooBusy",
                accessRightsInsufficient => "accessRightsInsufficient",
                keysUnavailable => "keysUnavailable",
                strongKeyDoesNotExist => "strongKeyDoesNotExist",
                simpleKeyDoesNotExist => "simpleKeyDoesNotExist",
                strongKeyAlreadyRegistered => "strongKeyAlreadyRegistered",
                simpleKeyAlreadyRegistered => "simpleKeyAlreadyRegistered",
                domainForNewKeyUnavailable => "domainForNewKeyUnavailable",
                domainForNewKeyUnknown => "domainForNewKeyUnknown",
                badKey => "badKey",
                badName => "badName",
                databaseFull => "databaseFull",
                other => "other",
                ENDCASE => "UNKNOWN"
                ];
            };

        ExposeAuthProblem: PROC [problem: AuthenticationP14V2.Problem] RETURNS[ROPE] = {
            RETURN[SELECT problem FROM
                credentialsInvalid => "credentialsInvalid",
                verifierInvalid => "verifierInvalid",
                verifierExpired => "verifierExpired",
                verifierReused => "verifierReused",
                credentialsExpired => "credentialsExpired",
                inappropriateCredentials => "inappropriateCredentials",
                ENDCASE => "UNKNOWN"
                ];
            };

        ExposeErrorCode: PROC [arg: XNSCH.ErrorCode, level: NAT] RETURNS [res: ROPE] ~ {
            SELECT arg FROM
                notAllowed => res Ź "notAllowed";
                allDown => res Ź "allDown";
                wasUpNowDown => res Ź "wasUpNowDown";
                protocolError => res Ź "protocolError";
                cantConnectToServer => res Ź "cantConnectToServer";
                communicationFailure => res Ź "communicationFailure";
                serverTooBusy => res Ź "serverTooBusy";
                serviceNotExported => res Ź "serviceNotExported";
                illegalPropertyID => res Ź "illegalPropertyID";
                illegalOrganizationName => res Ź "illegalOrganizationName";
                illegalDomainName => res Ź "illegalDomainName";
                illegalObjectName => res Ź "illegalObjectName";
                noSuchOrganization => res Ź "noSuchOrganization";
                noSuchDomain => res Ź "noSuchDomain";
                noSuchObject => res Ź "noSuchObject";
                propertyIDNotFound => res Ź "propertyIDNotFound";
                wrongPropertyType => res Ź "wrongPropertyType";
                noChange => res Ź "noChange";
                outOfDate => res Ź "outOfDate";
                overflowOfName => res Ź "overflowOfName";
                overflowOfDataBase => res Ź "overflowOfDataBase";
                credentialsInvalid => res Ź "credentialsInvalid";
                credentialsTooWeak => res Ź "credentialsTooWeak";
                inappropriateConversation => res Ź "inappropriateConversation";
                unknown => res Ź "unknown";
                ENDCASE => ERROR
            };

        ExposeWhich: PROC [arg: XNSCH.Which, level: NAT] RETURNS [res: ROPE] ~ {
            SELECT arg FROM
                first => res Ź "first";
                second => res Ź "second";
                ENDCASE => ERROR
            };

        ReplaceThisRope: PROC [r, d, n: ROPE, all: BOOL Ź TRUE, case: BOOL Ź TRUE, pos: INT Ź 0] RETURNS [ROPE] = {
            ld: INT Ź Rope.Length[d];
            ln: INT Ź Rope.Length[n];
            DO
                l: INT Ź Rope.Length[r];
                fi: INT Ź Rope.Find[r, d, pos, case];
                IF fi = -1 THEN EXIT;
                r Ź Rope.Replace[r, fi, ld, n];
                pos Ź fi + ln;
                IF ~all THEN EXIT;
                ENDLOOP;
            RETURN[r];
            };

        NotImplementedYet: PROC [d: MyData] = {
            d.out.PutRope["\nSorry, that function not implemented yet..."];
            };

        RealSecsToRope: PROC [seconds: REAL] RETURNS [r: ROPE] = {
            intSeconds: INT Ź Real.Fix[seconds];
            mSecs: INT Ź Real.Fix[(seconds - REAL[intSeconds]) * 1000];
            r Ź PeriodToRope[intSeconds];
            r Ź Rope.Cat[
                r,
                ", ",
                Convert.RopeFromInt[mSecs],
                MaintainMisc.Plural[" mSec", " mSecs", mSecs]];
            };

        PeriodToRope: PROC [period: INT] RETURNS [r: ROPE] = {
            up: BasicTime.UnpackedPeriod Ź BasicTime.UnpackPeriod[period];
            IF up.hours > 0 THEN
                r Ź Rope.Concat[
                    Convert.RopeFromInt[up.hours],
                    MaintainMisc.Plural[" hour,", " hours,", up.hours]];
            IF up.hours > 0 OR up.minutes > 0 THEN
                r Ź Rope.Cat[
                    r, 
                    " ",
                    Convert.RopeFromInt[up.minutes],
                    MaintainMisc.Plural[" minute,", " minutes,", up.minutes]];
            r Ź Rope.Cat[
                r, 
                " ",
                Convert.RopeFromInt[up.seconds],
                MaintainMisc.Plural[" second", " seconds", up.seconds]];
            };

    }.