<<>>
<<AdobeP75V2AuxImpl.Mesa>>
<<Copyright Ó 1989, 1992 by Xerox Corporation.  All rights reserved.>>
<<Generated by BJackson.pa at March 27, 1990 2:04:16 pm PST>>
<<using Sirocco [2.0] of February 10, 1989 6:26:26 pm PST>>
<<Philip James, January 30, 1991 1:55 pm PST>>
<<Christian Jacobi, April 7, 1992 4:44 pm PDT>>

    DIRECTORY
        Convert,
        Rope,
        AdobeP75V2,
        AdobeP75V2Aux;

    AdobeP75V2AuxImpl: CEDAR PROGRAM
        IMPORTS Convert, Rope
        EXPORTS AdobeP75V2Aux ~ {
        OPEN AdobeP75V2, AdobeP75V2Aux;

        ROPE: TYPE ~ Rope.ROPE;

        ExposeChangeItem: PUBLIC PROC [arg: ChangeItem, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "[";
            res Ź Rope.Cat[res, "name~", arg.oldFieldName, ", "];
            res Ź Rope.Cat[res, "value~", ExposeChangeItemValue[arg.newItem, (level+1)], "]"];
            };

        ExposeChangeItemValue: PUBLIC PROC [arg: ChangeItemValue, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź Rope.Cat["ChangeItemValue(", ExposeChangeType[arg.type, (level+1)], "): "];
            WITH arg SELECT FROM
                it: REF ChangeItemValueObject.add => {
                    res Ź Rope.Concat[res, ExposeFieldItem[it.newFlItem, (level+1)]] };
                it: REF ChangeItemValueObject.modify => {
                    res Ź Rope.Concat[res, ExposeFieldItem[it.newFlItem, (level+1)]] };
                it: REF ChangeItemValueObject.remove => {
                <<res _ Rope.Concat[res, ExposeEmptyRecord[it.remove, (level+1)]] >>
                    };
                ENDCASE => ERROR
            };

        ExposeDatabaseSequence: PUBLIC PROC [arg: DatabaseSequence, 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, "]"];
            };

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

        ExposeTimeField: PUBLIC PROC [arg: REF FieldItemObjectRec.dateTime, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "[";
            res Ź Rope.Cat[res, "name~", arg.name, ", "];
            res Ź Rope.Cat[res, "tools~", ExposeToolData[arg.defaultInfo, (level+1)], ", "];
        <<res _ Rope.Cat[res, "time~", ExposeEmptyRecord[arg.time, (level+1)], "]"];>>
            res Ź Rope.Concat[res, "]"];
            };

        ExposeToolData: PUBLIC PROC [arg: ToolData, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "[";
            FOR i: ToolType IN ToolType DO
                res Ź Rope.Cat[res, IF i>FIRST[ToolType] THEN ", " ELSE NIL, ExposeInfoStuff[arg[i], (level+1)]];
                ENDLOOP;
            res Ź Rope.Concat[res, "]"];
            };

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

        ExposeProblem: PUBLIC PROC [arg: Problem, level: NAT] RETURNS [res: ROPE] ~ {
            SELECT arg FROM
                communicationError => res Ź "communicationError";
                unknownSystem => res Ź "unknownSystem";
                cantDetermineLocOfARs => res Ź "cantDetermineLocOfARs";
                illegalLogin => res Ź "illegalLogin";
                systemAlreadyExists => res Ź "systemAlreadyExists";
                fileNotFound => res Ź "fileNotFound";
                serverUnreachable => res Ź "serverUnreachable";
                serverDown => res Ź "serverDown";
                noAdobeServiceAtServer => res Ź "noAdobeServiceAtServer";
                courierTimedOut => res Ź "courierTimedOut";
                parameterInconsistency => res Ź "parameterInconsistency";
                obsoleteVersion => res Ź "obsoleteVersion";
                systemNotRegistered => res Ź "systemNotRegistered";
                sysDescChanging => res Ź "sysDescChanging";
                others => res Ź "others";
                tooManyConnections => res Ź "tooManyConnections";
                spare1 => res Ź "spare1";
                spare2 => res Ź "spare2";
                xxx => res Ź "xxx";
                ENDCASE => ERROR
            };

        ExposeRunOfARs: PUBLIC PROC [arg: RunOfARs, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "[";
            res Ź Rope.Cat[res, "ar~", Convert.RopeFromCard[arg.startValue], ", "];
            res Ź Rope.Cat[res, "runLength~", Convert.RopeFromCard[arg.runLength], "]"];
            };

        ExposeFieldItem: PUBLIC PROC [arg: FieldItemObject, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź Rope.Cat["FieldItem(", ExposeFieldType[arg.type, (level+1)], "): "];
            WITH arg SELECT FROM
                it: REF FieldItemObjectRec.arId => {
                    res Ź Rope.Concat[res, ExposeARField[it, (level+1)]] };
                it: REF FieldItemObjectRec.dateTime => {
                    res Ź Rope.Concat[res, ExposeTimeField[it, (level+1)]] };
                it: REF FieldItemObjectRec.numeric => {
                    res Ź Rope.Concat[res, ExposeNumericField[it, (level+1)]] };
                it: REF FieldItemObjectRec.fixedLengthString => {
                    res Ź Rope.Concat[res, ExposeBoundedField[it, (level+1)]] };
                it: REF FieldItemObjectRec.enumerated => {
                    res Ź Rope.Concat[res, ExposeEnumeratedField[it, (level+1)]] };
                it: REF FieldItemObjectRec.string => {
                    res Ź Rope.Concat[res, ExposeStringField[it, (level+1)]] };
                ENDCASE => ERROR
            };

        ExposeFieldItemV: PUBLIC PROC [arg: FieldItemValue, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "FieldItemV: ";
            WITH arg SELECT FROM
                it: REF FieldItemValueRec.arId => {
                    res Ź Rope.Concat[res, Convert.RopeFromCard[it.ar]] };
                it: REF FieldItemValueRec.dateTime => {
                    res Ź Rope.Concat[res, Convert.RopeFromTime[it.time]] };
                it: REF FieldItemValueRec.numeric => {
                    res Ź Rope.Concat[res, Convert.RopeFromCard[it.number]] };
                it: REF FieldItemValueRec.fixedLengthString => {
                    res Ź Rope.Concat[res, it.string] };
                it: REF FieldItemValueRec.enumerated => {
                    res Ź Rope.Cat[res, "enum: ", Convert.RopeFromCard[it.enumVal]] };
                ENDCASE => ERROR
            };

        ExposeReference: PUBLIC PROC [arg: Reference, 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, "]"];
            };

        ExposeTaggedItem: PUBLIC PROC [arg: TaggedItem, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "[";
            res Ź Rope.Cat[res, "tag~", arg.tag, ", "];
            res Ź Rope.Cat[res, "item~", Convert.RopeFromCard[arg.item], "]"];
            };

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

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

        ExposeQueryItemValue: PUBLIC PROC [arg: FieldItemQueryValue, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "[";
            res Ź Rope.Cat[res, "op~", ExposeRelation[arg.relationalOp, (level+1)], ", "];
            res Ź Rope.Cat[res, "value~", ExposeFieldItemV[arg.value, (level+1)], "]"];
            };

        ExposeStartOrStop: PUBLIC PROC [arg: StartOrStop, level: NAT] RETURNS [res: ROPE] ~ {
            SELECT arg FROM
                start => res Ź "start";
                stop => res Ź "stop";
                ENDCASE => ERROR
            };

        ExposeNumericField: PUBLIC PROC [arg: REF FieldItemObjectRec.numeric, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "[";
            res Ź Rope.Cat[res, "name~", arg.name, ", "];
            res Ź Rope.Cat[res, "tools~", ExposeToolData[arg.defaultInfo, (level+1)], ", "];
        <<res _ Rope.Cat[res, "numeric~", ExposeEmptyRecord[arg.numeric, (level+1)], "]"];>>
            res Ź Rope.Concat[res, "]"];
            };

        ExposeEnumeratedField: PUBLIC PROC [arg: REF FieldItemObjectRec.enumerated, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "[";
            res Ź Rope.Cat[res, "name~", arg.name, ", "];
            res Ź Rope.Cat[res, "tools~", ExposeToolData[arg.defaultInfo, (level+1)], ", "];
            res Ź Rope.Cat[res, "field~", Convert.RopeFromCard[arg.field], ", "];
            res Ź Rope.Cat[res, "possibilities~", ExposeKeyedPossibilitiesList[arg.possibilities, (level+1)], "]"];
            };

        ExposeRelation: PUBLIC PROC [arg: Relation, level: NAT] RETURNS [res: ROPE] ~ {
            SELECT arg FROM
                equal => res Ź "equal";
                notEqual => res Ź "notEqual";
                lessThan => res Ź "lessThan";
                lessThanOrEqual => res Ź "lessThanOrEqual";
                greaterThan => res Ź "greaterThan";
                greaterThanOrEqual => res Ź "greaterThanOrEqual";
                in => res Ź "in";
                notIn => res Ź "notIn";
                ENDCASE => ERROR
            };

        ExposeTarget: PUBLIC PROC [arg: Target, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "[";
            res Ź Rope.Cat[res, "system~", arg.system, "]"];
            };

        ExposeBoundedString: PUBLIC PROC [arg: BoundedString, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "[";
            res Ź Rope.Cat[res, "string~", arg.string, ", "];
            res Ź Rope.Cat[res, "max~", Convert.RopeFromCard[arg.max], "]"];
            };

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

        ExposeARField: PUBLIC PROC [arg: REF FieldItemObjectRec.arId, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "[";
            res Ź Rope.Cat[res, "name~", arg.name, ", "];
            res Ź Rope.Cat[res, "tools~", ExposeToolData[arg.defaultInfo, (level+1)], ", "];
        <<res _ Rope.Cat[res, "ar~", ExposeEmptyRecord[arg.ar, (level+1)], "]"];>>
            res Ź Rope.Concat[res, "]"];
            };

        ExposeToolType: PUBLIC PROC [arg: ToolType, level: NAT] RETURNS [res: ROPE] ~ {
            SELECT arg FROM
                edit => res Ź "edit";
                submit => res Ź "submit";
                report => res Ź "report";
                query => res Ź "query";
                sort => res Ź "sort";
                queryList => res Ź "queryList";
                ENDCASE => ERROR
            };

        ExposeDescription: PUBLIC PROC [arg: Description, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "[";
            res Ź Rope.Cat[res, "name~", arg.name, ", "];
            res Ź Rope.Cat[res, "host~", arg.host, ", "];
            res Ź Rope.Cat[res, "directory~", arg.directory, ", "];
            res Ź Rope.Cat[res, "refCount~", Convert.RopeFromCard[arg.refCount], ", "];
            res Ź Rope.Cat[res, "version~", Convert.RopeFromCard[arg.version], ", "];
            res Ź Rope.Cat[res, "fieldList~", ExposeFieldList[arg.fieldList, (level+1)], "]"];
            };

        ExposeCoordinate: PUBLIC PROC [arg: Coordinate, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "[";
            res Ź Rope.Cat[res, "ord~", Convert.RopeFromInt[arg.ord], ", "];
            res Ź Rope.Cat[res, "co~", Convert.RopeFromInt[arg.co], "]"];
            };

        ExposeFieldType: PUBLIC PROC [arg: FieldType, level: NAT] RETURNS [res: ROPE] ~ {
            SELECT arg FROM
                arId => res Ź "ar";
                dateTime => res Ź "time";
                numeric => res Ź "numeric";
                fixedLengthString => res Ź "bounded";
                enumerated => res Ź "enumerated";
                string => res Ź "string";
                ENDCASE => ERROR
            };

        ExposePossibilityList: PUBLIC PROC [arg: Possibilities, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "[";
            res Ź Rope.Cat[res, "keyedDependency~", Convert.RopeFromCard[arg.keyedDependency], ", "];
            res Ź Rope.Cat[res, "enumRecs~", ExposeEnumerationList[arg.enumRecs, (level+1)], "]"];
            };

        ExposeEmptyRecord: PUBLIC PROC [arg: EmptyRecord, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "[]";
            };

        ExposeInfoStuff: PUBLIC PROC [arg: DefaultInfoHandle, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "[";
            res Ź Rope.Cat[res, "default~", arg.default, ", "];
            res Ź Rope.Cat[res, "required~", Convert.RopeFromBool[arg.systemMust], ", "];
            res Ź Rope.Cat[res, "place~", ExposeCoordinate[arg.place, (level+1)], ", "];
            res Ź Rope.Cat[res, "width~", Convert.RopeFromCard[arg.width], "]"];
            };

        ExposeChangeType: PUBLIC PROC [arg: ChangeType, level: NAT] RETURNS [res: ROPE] ~ {
            SELECT arg FROM
                modify => res Ź "modify";
                add => res Ź "add";
                remove => res Ź "remove";
                ENDCASE => ERROR
            };

        ExposeStringField: PUBLIC PROC [arg: REF FieldItemObjectRec.string, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "[";
            res Ź Rope.Cat[res, "name~", arg.name, ", "];
            res Ź Rope.Cat[res, "tools~", ExposeToolData[arg.defaultInfo, (level+1)], ", "];
        <<res _ Rope.Cat[res, "string~", ExposeEmptyRecord[arg.string, (level+1)], "]"];>>
            res Ź Rope.Concat[res, "]"];
            };

        ExposeBoundedField: PUBLIC PROC [arg: REF FieldItemObjectRec.fixedLengthString, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "[";
            res Ź Rope.Cat[res, "name~", arg.name, ", "];
            res Ź Rope.Cat[res, "tools~", ExposeToolData[arg.defaultInfo, (level+1)], ", "];
            res Ź Rope.Cat[res, "bounded~", Convert.RopeFromCard[arg.maxLength], "]"];
            };

        ExposeStaticTarget: PUBLIC PROC [arg: StaticTarget, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "[";
            res Ź Rope.Cat[res, "target~", ExposeTarget[arg.target, (level+1)], ", "];
            res Ź Rope.Cat[res, "version~", Convert.RopeFromCard[arg.version], "]"];
            };

        ExposeLocationTarget: PUBLIC PROC [arg: LocationTarget, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "[";
            res Ź Rope.Cat[res, "host~", arg.host, ", "];
            res Ź Rope.Cat[res, "directory~", arg.directory, "]"];
            };

        ExposeQueryItem: PUBLIC PROC [arg: QueryItem, level: NAT] RETURNS [res: ROPE] ~ {
            res Ź "[";
            res Ź Rope.Cat[res, "name~", arg.name, ", "];
            res Ź Rope.Cat[res, "value~", ExposeQueryItemValue[arg.value, (level+1)], "]"];
            };

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

    }...