<<>>
<<CHOpsP2V3AuxImpl.Mesa>>
<<Copyright Ó 1989, 1991 by Xerox Corporation.  All rights reserved.>>
<<Generated by Willie-sue.pa at February 13, 1989 2:49:35 pm PST>>
<<using Sirocco [2.0] of February 10, 1989 6:26:26 pm PST>>

    DIRECTORY
        Convert,
        Rope,
        CHOpsP2V3,
        AuthenticationP14V2Aux,
        CHOpsP2V3Aux,
        CHNameP2V0Aux;

    CHOpsP2V3AuxImpl: CEDAR PROGRAM
        IMPORTS Convert, Rope, AuthenticationP14V2Aux, CHNameP2V0Aux
        EXPORTS CHOpsP2V3Aux ~ {
        OPEN CHOpsP2V3, CHOpsP2V3Aux;

        ROPE: TYPE ~ Rope.ROPE;

        ExposeObjectNameSequence: PUBLIC PROC [arg: ObjectNameSequence, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "[";
            FOR i: CARDINAL IN [0..arg.length) DO
                res Ź Rope.Cat[res, IF i>0 THEN ", " ELSE NIL, CHNameP2V0Aux.ExposeThreePartName[arg.body[i], (level+1)]];
                ENDLOOP;
            res Ź Rope.Concat[res, "]"];
            };

        ExposeWhichArgument: PUBLIC PROC [arg: WhichArgument, level: NAT] RETURNS [res: ROPE] ~ {
            SELECT arg FROM
                first => res Ź "first";
                second => res Ź "second";
                ENDCASE => ERROR
            };

        ExposeStreamOfThreePartName: PUBLIC PROC [arg: StreamOfThreePartName, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź Rope.Cat["StreamOfThreePartName(", ExposeStreamKind[arg.type, (level+1)], "): "];
            WITH arg SELECT FROM
                it: REF StreamOfThreePartNameObject.nextSegment => {
                    res Ź Rope.Concat[res, ExposeThreePartNameSequence[it.nextSegment, (level+1)]] };
                it: REF StreamOfThreePartNameObject.lastSegment => {
                    res Ź Rope.Concat[res, ExposeThreePartNameSequence[it.lastSegment, (level+1)]] };
                ENDCASE => ERROR
            };

        ExposeStreamOfDomain: PUBLIC PROC [arg: StreamOfDomain, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź Rope.Cat["StreamOfDomain(", ExposeStreamKind[arg.type, (level+1)], "): "];
            WITH arg SELECT FROM
                it: REF StreamOfDomainObject.nextSegment => {
                    res Ź Rope.Concat[res, ExposeDomainSequence[it.nextSegment, (level+1)]] };
                it: REF StreamOfDomainObject.lastSegment => {
                    res Ź Rope.Concat[res, ExposeDomainSequence[it.lastSegment, (level+1)]] };
                ENDCASE => ERROR
            };

        ExposeDomainNameSequence: PUBLIC PROC [arg: DomainNameSequence, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "[";
            FOR i: CARDINAL IN [0..arg.length) DO
                res Ź Rope.Cat[res, IF i>0 THEN ", " ELSE NIL, CHNameP2V0Aux.ExposeTwoPartName[arg.body[i], (level+1)]];
                ENDLOOP;
            res Ź Rope.Concat[res, "]"];
            };

        ExposeStreamOfOrganization: PUBLIC PROC [arg: StreamOfOrganization, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź Rope.Cat["StreamOfOrganization(", ExposeStreamKind[arg.type, (level+1)], "): "];
            WITH arg SELECT FROM
                it: REF StreamOfOrganizationObject.nextSegment => {
                    res Ź Rope.Concat[res, ExposeOrganizationSequence[it.nextSegment, (level+1)]] };
                it: REF StreamOfOrganizationObject.lastSegment => {
                    res Ź Rope.Concat[res, ExposeOrganizationSequence[it.lastSegment, (level+1)]] };
                ENDCASE => ERROR
            };

        ExposeStreamOfDomainName: PUBLIC PROC [arg: StreamOfDomainName, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź Rope.Cat["StreamOfDomainName(", ExposeStreamKind[arg.type, (level+1)], "): "];
            WITH arg SELECT FROM
                it: REF StreamOfDomainNameObject.nextSegment => {
                    res Ź Rope.Concat[res, ExposeDomainNameSequence[it.nextSegment, (level+1)]] };
                it: REF StreamOfDomainNameObject.lastSegment => {
                    res Ź Rope.Concat[res, ExposeDomainNameSequence[it.lastSegment, (level+1)]] };
                ENDCASE => ERROR
            };

        ExposeArgumentProblem: PUBLIC PROC [arg: ArgumentProblem, level: NAT] RETURNS [res: ROPE] ~ {
            SELECT arg FROM
                illegalProperty => res Ź "illegalProperty";
                illegalOrganizationName => res Ź "illegalOrganizationName";
                illegalDomainName => res Ź "illegalDomainName";
                illegalObjectName => res Ź "illegalObjectName";
                noSuchOrganization => res Ź "noSuchOrganization";
                noSuchDomain => res Ź "noSuchDomain";
                noSuchObject => res Ź "noSuchObject";
                ENDCASE => ERROR
            };

        ExposeDomainSequence: PUBLIC PROC [arg: DomainSequence, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "[";
            FOR i: CARDINAL IN [0..arg.length) DO
                res Ź Rope.Cat[res, IF i>0 THEN ", " ELSE NIL, arg.body[i]];
                ENDLOOP;
            res Ź Rope.Concat[res, "]"];
            };

        ExposeThreePartNameSequence: PUBLIC PROC [arg: ThreePartNameSequence, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "[";
            FOR i: CARDINAL IN [0..arg.length) DO
                res Ź Rope.Cat[res, IF i>0 THEN ", " ELSE NIL, CHNameP2V0Aux.ExposeThreePartName[arg.body[i], (level+1)]];
                ENDLOOP;
            res Ź Rope.Concat[res, "]"];
            };

        ExposeStreamKind: PUBLIC PROC [arg: StreamKind, level: NAT] RETURNS [res: ROPE] ~ {
            SELECT arg FROM
                nextSegment => res Ź "nextSegment";
                lastSegment => res Ź "lastSegment";
                ENDCASE => ERROR
            };

        ExposeNetworkAddress: PUBLIC PROC [arg: NetworkAddress, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "[";
            FOR i: CARDINAL IN [0..6) DO
                res Ź Rope.Cat[res, IF i>0 THEN ", " ELSE NIL, Convert.RopeFromCard[arg[i]]];
                ENDLOOP;
            res Ź Rope.Concat[res, "]"];
            };

        ExposeCallProblem: PUBLIC PROC [arg: CallProblem, level: NAT] RETURNS [res: ROPE] ~ {
            SELECT arg FROM
                accessRightsInsufficient => res Ź "accessRightsInsufficient";
                tooBusy => res Ź "tooBusy";
                serverDown => res Ź "serverDown";
                useCourier => res Ź "useCourier";
                other => res Ź "other";
                ENDCASE => ERROR
            };

        ExposeAuthenticator: PUBLIC PROC [arg: Authenticator, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "[";
            res Ź Rope.Cat[res, "credentials~", AuthenticationP14V2Aux.ExposeCredentials[arg.credentials, (level+1)], ", "];
            res Ź Rope.Cat[res, "verifier~", AuthenticationP14V2Aux.ExposeSeqWords[arg.verifier, (level+1)], "]"];
            };

        ExposeNetworkAddressList: PUBLIC PROC [arg: NetworkAddressList, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "[";
            FOR i: CARDINAL IN [0..arg.length) DO
                res Ź Rope.Cat[res, IF i>0 THEN ", " ELSE NIL, ExposeNetworkAddress[arg.body[i], (level+1)]];
                ENDLOOP;
            res Ź Rope.Concat[res, "]"];
            };

        ExposeStreamOfObject: PUBLIC PROC [arg: StreamOfObject, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź Rope.Cat["StreamOfObject(", ExposeStreamKind[arg.type, (level+1)], "): "];
            WITH arg SELECT FROM
                it: REF StreamOfObjectObject.nextSegment => {
                    res Ź Rope.Concat[res, ExposeObjectSequence[it.nextSegment, (level+1)]] };
                it: REF StreamOfObjectObject.lastSegment => {
                    res Ź Rope.Concat[res, ExposeObjectSequence[it.lastSegment, (level+1)]] };
                ENDCASE => ERROR
            };

        ExposeItem: PUBLIC PROC [arg: Item, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "[";
            FOR i: CARDINAL IN [0..arg.length) DO
                res Ź Rope.Cat[res, IF i>0 THEN ", " ELSE NIL, Convert.RopeFromCard[arg.body[i]]];
                ENDLOOP;
            res Ź Rope.Concat[res, "]"];
            };

        ExposeOrganizationSequence: PUBLIC PROC [arg: OrganizationSequence, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "[";
            FOR i: CARDINAL IN [0..arg.length) DO
                res Ź Rope.Cat[res, IF i>0 THEN ", " ELSE NIL, arg.body[i]];
                ENDLOOP;
            res Ź Rope.Concat[res, "]"];
            };

        ExposeStreamOfObjectName: PUBLIC PROC [arg: StreamOfObjectName, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź Rope.Cat["StreamOfObjectName(", ExposeStreamKind[arg.type, (level+1)], "): "];
            WITH arg SELECT FROM
                it: REF StreamOfObjectNameObject.nextSegment => {
                    res Ź Rope.Concat[res, ExposeObjectNameSequence[it.nextSegment, (level+1)]] };
                it: REF StreamOfObjectNameObject.lastSegment => {
                    res Ź Rope.Concat[res, ExposeObjectNameSequence[it.lastSegment, (level+1)]] };
                ENDCASE => ERROR
            };

        ExposeProperties: PUBLIC PROC [arg: Properties, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "[";
            FOR i: CARDINAL IN [0..arg.length) DO
                res Ź Rope.Cat[res, IF i>0 THEN ", " ELSE NIL, Convert.RopeFromCard[arg.body[i]]];
                ENDLOOP;
            res Ź Rope.Concat[res, "]"];
            };

        ExposePropertyProblem: PUBLIC PROC [arg: PropertyProblem, level: NAT] RETURNS [res: ROPE] ~ {
            SELECT arg FROM
                missing => res Ź "missing";
                wrongType => res Ź "wrongType";
                ENDCASE => ERROR
            };

        ExposeUpdateProblem: PUBLIC PROC [arg: UpdateProblem, level: NAT] RETURNS [res: ROPE] ~ {
            SELECT arg FROM
                noChange => res Ź "noChange";
                outOfDate => res Ź "outOfDate";
                objectOverflow => res Ź "objectOverflow";
                databaseOverflow => res Ź "databaseOverflow";
                ENDCASE => ERROR
            };

        ExposeObjectSequence: PUBLIC PROC [arg: ObjectSequence, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "[";
            FOR i: CARDINAL IN [0..arg.length) DO
                res Ź Rope.Cat[res, IF i>0 THEN ", " ELSE NIL, arg.body[i]];
                ENDLOOP;
            res Ź Rope.Concat[res, "]"];
            };

    }...