<<>>
<<XNSAdobeTestImpl.mesa>>
<<Copyright Ó 1990, 1992 by Xerox Corporation.  All rights reserved.>>
<<Bill Jackson (bj), March 28, 1990 5:45 pm PST>>
<<Philip James, March 20, 1991 9:25 am PST>>
<<Christian Jacobi, April 7, 1992 4:57 pm PDT>>
<<>>
    DIRECTORY
        AdobeP75V2,
            << USING [ARVersion, Database, DatabaseSequence, GetResidentSystems, GetVersion, Target],>>
        AdobeP75V2Aux,
        Basics USING [ ],
        Commander USING [CommandProc, Handle, Register],
        CrRPC USING [BulkDataSink, CreateClientHandle, DestroyClientHandle, Handle],
        IO,
        Rope USING [ROPE],
        XNS USING [Address, unknownAddress],
        XNSAdobeClientOps,
        XNSCH USING [LookupAddressFromRope],
        XNSCHName USING [Name, RopeFromName];

    XNSAdobeTestImpl: CEDAR MONITOR
        IMPORTS AdobeP75V2, AdobeP75V2Aux, Commander, CrRPC, IO, XNSCH, XNSCHName
        EXPORTS XNSAdobeClientOps ~ {
        OPEN Adobe2: AdobeP75V2;
        ROPE: TYPE ~ Rope.ROPE;

        crAtom: ATOM ~ IF ( BYTES[WORD] = 2 ) THEN $SPP ELSE $CMUX;
    <<Errors>>
        UnknownAddress: PUBLIC ERROR ~ CODE;
        StubError: PUBLIC ERROR [whatsUp: ROPE] ~ CODE;

        RemoteOperation: TYPE ~ PROC [crH: CrRPC.Handle];
        Guarded: PROC [server: ROPE, op: RemoteOperation] ~ {
            ENABLE {
                UNWIND => { NULL };
                Adobe2.Error => {
                    whatsUp: ROPE ~ IO.PutFR1["Adobe2.Error[code: (%g)]", IO.card[why.ORD] ];
                    ERROR StubError[whatsUp];
                    };
                };
            qualified: XNSCHName.Name; add: XNS.Address;
            [qualified, add] Ź XNSCH.LookupAddressFromRope[server];
            IF ( add = XNS.unknownAddress ) THEN ERROR UnknownAddress;
            {
                name: ROPE ~ XNSCHName.RopeFromName[qualified];
                address: REF XNS.Address ~ NEW[XNS.Address Ź add];
                crH: CrRPC.Handle ~ CrRPC.CreateClientHandle[crAtom, address];
                    <<realId: XNSAuth.Identity ~ UserCredentials.GetIdentity[];>>
                    <<conversation: XNSAuth.Conversation ~ XNSAuth.Initiate[realId, qualified];>>
                    <<credentials: XNSAuth.Credentials ~ XNSAuth.GetCredentials[conversation];>>
                    <<verifier: XNSAuth.Verifier;>>
                    <<XNSAuth.SetRecipientHostNumber[conversation, address.host];>>
                    <<verifier _ XNSAuth.GetNextVerifier[conversation];>>
                op[crH];
                CrRPC.DestroyClientHandle[crH];
                };
            };
    <<Remote Operations (simple)>>
        ListDatabases: PUBLIC PROC [server: ROPE]
        RETURNS [systems: Adobe2.DatabaseSequence] ~ {
            ListDatabasesOp: RemoteOperation ~ {
                systems Ź Adobe2.GetResidentSystems[crH];
                };
            Guarded[server, ListDatabasesOp];
            };
    <<Remote Operations (system)>>
        GetDatabaseDescription: PUBLIC PROC [server: ROPE, system: Adobe2.Database]
        RETURNS [description: Adobe2.Description] ~ {
            GetDatabaseDescriptionOp: RemoteOperation ~ {
                target: Adobe2.Target ~ [system];
                description Ź Adobe2.GetSystemDescription[crH, target];
                };
            Guarded[server, GetDatabaseDescriptionOp];
            };

        GetLocationOfARs: PUBLIC PROC [server: ROPE, system: Adobe2.Database]
        RETURNS [referenceToARs: Adobe2.NSName] ~ {
            GetLocationOfARsOp: RemoteOperation ~ {
                target: Adobe2.Target ~ [system];
                referenceToARs Ź Adobe2.GetLocationOfARs[crH, target];
                };
            Guarded[server, GetLocationOfARsOp];
            };

        GetVersion: PUBLIC PROC [server: ROPE, system: Adobe2.Database]
        RETURNS [version: Adobe2.ARVersion Ź 0]~ {
            GetVersionOp: RemoteOperation ~ {
                target: Adobe2.Target ~ [system];
                version Ź Adobe2.GetVersion[crH, target];
                };
            Guarded[server, GetVersionOp];
            };

        LookupARs: PUBLIC PROC [server: ROPE, system: Adobe2.Database, 
        version: Adobe2.ARVersion, fieldName: ROPE, value: Adobe2.FieldItemQueryValue, 
        set: Adobe2.SetOfARs] RETURNS [s: Adobe2.SetOfARs] ~ {
            LookupARsOp: RemoteOperation ~ {
                target: Adobe2.Target ~ [system];
                instance: Adobe2.StaticTarget ~ [target, version];
                query: Adobe2.QueryItem Ź [fieldName, value];
                boundSet: Adobe2.SetOfARs Ź set;
                s Ź Adobe2.LookupARs[crH, instance, query, boundSet];
                };
            Guarded[server, LookupARsOp];
            };

        ReadLastARNumber: PUBLIC PROC [server: ROPE, system: Adobe2.Database]
        RETURNS [lastAR: Adobe2.ARNumber Ź 0] ~ {
            ReadLastARNumberOp: RemoteOperation ~ {
                target: Adobe2.Target ~ [system];
                lastAR Ź Adobe2.ReadLastARNumber[crH, target];
                };
            Guarded[server, ReadLastARNumberOp];
            };

        GetAcceleratorInfo: PUBLIC PROC [server: ROPE, system: Adobe2.Database, version: CARD32, arSet: Adobe2.SetOfARs, fieldList: 
        Adobe2.FieldList, to: CrRPC.BulkDataSink] ~ {
            GetAcceleratorInfoOp: RemoteOperation ~ {
                instance: Adobe2.StaticTarget ~ [[system], version];
                Adobe2.GetAcceleratorInfo[crH, instance, arSet, fieldList, to];
                };
            Guarded[server, GetAcceleratorInfoOp];
            };

        GetSystemDefaultUserFile: PUBLIC PROC [server: ROPE, system: Adobe2.Database, to: CrRPC.BulkDataSink] ~ {
            GetSystemDefaultUserFileOp: RemoteOperation ~ {
                target: Adobe2.Target ~ [system];
                Adobe2.GetSystemDefaultUserFile[crH, target, to];
                };
            Guarded[server, GetSystemDefaultUserFileOp];
            };
    <<Remote Operations (more complex)>>
        AboutToStore: PUBLIC PROC [server: ROPE, system: Adobe2.Database, version: CARD32, arNumber: CARD32] ~ {
            AboutToStoreOp: RemoteOperation ~ {
                instance: Adobe2.StaticTarget ~ [[system], version];
                Adobe2.AboutToStore[crH, instance, arNumber];
                };
            Guarded[server, AboutToStoreOp];
            };

        SubmitFailed: PUBLIC PROC [server: ROPE, system: Adobe2.Database, version: CARD32, arNumber: CARD32] ~ {
            SubmitFailedOp: RemoteOperation ~ {
                target: Adobe2.Target ~ [system];
                Adobe2.SubmitFailed[crH, target, version, arNumber];
                };
            Guarded[server, SubmitFailedOp];
            };

        UpdateAcceleratorField: PUBLIC PROC [server: ROPE, system: Adobe2.Database, version: CARD32, arNumber: CARD32, field: 
        Adobe2.FieldItemValue, fieldName: ROPE] ~ {
            UpdateAcceleratorFieldOp: RemoteOperation ~ {
                instance: Adobe2.StaticTarget ~ [[system], version];
                Adobe2.UpdateAcceleratorField[crH, instance, arNumber, field, fieldName];
                };
            Guarded[server, UpdateAcceleratorFieldOp];
            };

        GetNextSubmitNumber: PUBLIC PROC [server: ROPE, system: Adobe2.Database]
        RETURNS [submitNumber: Adobe2.SubmitNumber Ź 0] ~ {
            GetNextSubmitNumberOp: RemoteOperation ~ {
                target: Adobe2.Target ~ [system];
                submitNumber Ź Adobe2.GetNextSubmitNumber[crH, target];
                };
            Guarded[server, GetNextSubmitNumberOp];
            };

        PutSubmitNumber: PUBLIC PROC [server: ROPE, system: Adobe2.Database,
        submitNumber: Adobe2.SubmitNumber] ~ {
            PutSubmitNumberOp: RemoteOperation ~ {
                target: Adobe2.Target ~ [system];
                Adobe2.PutSubmitNumber[crH, target, submitNumber];
                };
            Guarded[server, PutSubmitNumberOp];
            };
    <<Some manifest constants/values>>
        server: PUBLIC ROPE Ź "PCAService:OSBU North:Xerox";
        system: PUBLIC Adobe2.Database Ź "AdobePortTest";
        version: PUBLIC Adobe2.ARVersion Ź 1;
    <<Commander Operations (simple ops)>>
        ListDatabasesCommand: Commander.CommandProc ~ {
            cmd.out.PutF1["server: %g\n", IO.rope[server] ];
            {
                ENABLE {
                    StubError=> { msg Ź whatsUp; GOTO Failed };
                    UnknownAddress => { msg Ź "UnknownAddress"; GOTO Failed };
                    };
                systems: Adobe2.DatabaseSequence Ź ListDatabases[server];
                cmd.out.PutF1[" systems:\n", IO.rope[server] ];
                FOR i: CARDINAL IN [0..systems.length] DO
                    cmd.out.PutF1["  %g\n", IO.rope[systems.body[i]] ];
                    ENDLOOP;
                };
            EXITS Failed => { result Ź $Failure };
            };
    <<Commander Operations (system)>>
        FieldTypeName: ARRAY Adobe2.FieldType OF ROPE Ź
        ["ar(0)", "time(1)", "numeric(2)", "bounded(3)", "enumerated(4)", "string(5)"];

        PrintFieldList: PROC [out: IO.STREAM, fieldList: Adobe2.FieldList] ~ {
            FOR i: CARDINAL IN [0..fieldList.length) DO
                item: Adobe2.FieldItemObject ~ fieldList.flSeq[i];
                type: Adobe2.FieldType ~ item.type;
                rope: ROPE ~ AdobeP75V2Aux.ExposeFieldItem[item, 1];
                out.PutF["(%g) [%g]\n", IO.card[i], IO.rope[rope] ];
                ENDLOOP;
            };

        GetDatabaseDescriptionCommand: Commander.CommandProc ~ {
            cmd.out.PutF1["server: %g\n", IO.rope[server] ];
            cmd.out.PutF1[" system/database: %g\n", IO.rope[system] ];
            {
                ENABLE {
                    StubError=> { msg Ź whatsUp; GOTO Failed };
                    UnknownAddress => { msg Ź "UnknownAddress"; GOTO Failed };
                    };
                description: Adobe2.Description Ź GetDatabaseDescription[server, system];
                cmd.out.PutRope[" Description:\n"];
                cmd.out.PutF1["  name:\t%g\n", IO.rope[description.name] ];
                cmd.out.PutF1["  host:\t%g\n", IO.rope[description.host] ];
                cmd.out.PutF1["  directory:\t%g\n", IO.rope[description.directory] ];
                cmd.out.PutF1["  version:\t%g\n", IO.card[description.version] ];
                cmd.out.PutF1["  fieldList:\t(%g) [\n", IO.card[description.fieldList.length] ];
                    PrintFieldList[cmd.out, description.fieldList];
                    cmd.out.PutRope["\t]\n"];
                };
            EXITS Failed => { result Ź $Failure };
            };

        GetLocationOfARsCommand: Commander.CommandProc ~ {
            cmd.out.PutF1["server: %g\n", IO.rope[server] ];
            cmd.out.PutF1[" system/database: %g\n", IO.rope[system] ];
            {
                ENABLE {
                    StubError=> { msg Ź whatsUp; GOTO Failed };
                    UnknownAddress => { msg Ź "UnknownAddress"; GOTO Failed };
                    };
                referenceToARs: Adobe2.NSName Ź GetLocationOfARs[server, system];
                cmd.out.PutF[" Location of ARs:  %g:%g:%g\n", IO.rope[referenceToARs.local], IO.rope[referenceToARs.domain], 
                IO.rope[referenceToARs.org]];
                };
            EXITS Failed => { result Ź $Failure };
            };

        GetVersionCommand: Commander.CommandProc ~ {
            cmd.out.PutF1["server: %g\n", IO.rope[server] ];
            cmd.out.PutF1[" system/database: %g\n", IO.rope[system] ];
            {
                ENABLE {
                    StubError=> { msg Ź whatsUp; GOTO Failed };
                    UnknownAddress => { msg Ź "UnknownAddress"; GOTO Failed };
                    };
                version: Adobe2.ARVersion Ź GetVersion[server, system];
                cmd.out.PutF1[" version: %g\n", IO.card[version] ];
                };
            EXITS Failed => { result Ź $Failure };
            };

        ReadLastARNumberCommand: Commander.CommandProc ~ {
            cmd.out.PutF1["server: %g\n", IO.rope[server] ];
            cmd.out.PutF1[" system/database: %g\n", IO.rope[system] ];
            {
                ENABLE {
                    StubError=> { msg Ź whatsUp; GOTO Failed };
                    UnknownAddress => { msg Ź "UnknownAddress"; GOTO Failed };
                    };
                lastAR: Adobe2.ARNumber Ź ReadLastARNumber[server, system];
                cmd.out.PutF1[" lastAR: %g\n", IO.card[lastAR] ];
                };
            EXITS Failed => { result Ź $Failure };
            };
    <<Commander Operations (using state)>>
        currentAR: Adobe2.SubmitNumber Ź 11;

    <<cmd.out.PutF[" target/database: %g(%g)\n", IO.rope[system], IO.card[version] ];>>
        <<instance: Adobe2.StaticTarget ~ [target, version];>>
        GetNextSubmitNumberCommand: Commander.CommandProc ~ {
            cmd.out.PutF1["server: %g\n", IO.rope[server] ];
            cmd.out.PutF1[" system/database: %g\n", IO.rope[system] ];
            {
                ENABLE {
                    StubError=> { msg Ź whatsUp; GOTO Failed };
                    UnknownAddress => { msg Ź "UnknownAddress"; GOTO Failed };
                    };
                target: Adobe2.Target ~ [system];
                submitNumber: Adobe2.SubmitNumber Ź GetNextSubmitNumber[server, target];
                cmd.out.PutF1[" NextSubmitNumber: %g\n", IO.card[submitNumber] ];
                currentAR Ź submitNumber;
                };
            EXITS Failed => { result Ź $Failure };
            };

        PutSubmitNumberCommand: Commander.CommandProc ~ {
            cmd.out.PutF1["server: %g\n", IO.rope[server] ];
            cmd.out.PutF1[" system/database: %g\n", IO.rope[system] ];
            {
                ENABLE {
                    StubError=> { msg Ź whatsUp; GOTO Failed };
                    UnknownAddress => { msg Ź "UnknownAddress"; GOTO Failed };
                    };
                submitNumber: Adobe2.SubmitNumber Ź currentAR;
                PutSubmitNumber[server, system, submitNumber];
                cmd.out.PutF1[" PutSubmitNumber: %g\n", IO.card[submitNumber] ];
                };
            currentAR Ź currentAR.PRED; -- why?
            EXITS Failed => { result Ź $Failure };
            };

        NumQueryCommand: Commander.CommandProc ~ {
            cmd.out.PutF1["server: %g\n", IO.rope[server] ];
            cmd.out.PutF1[" system/database: %g\n", IO.rope[system] ];
            {
                ENABLE {
                    StubError=> { msg Ź whatsUp; GOTO Failed };
                    UnknownAddress => { msg Ź "UnknownAddress"; GOTO Failed };
                    };
                value: Adobe2.FieldItemQueryValue Ź [greaterThanOrEqual, 
                    NEW[Adobe2.FieldItemValueRec.numeric Ź [numeric[35]]]];
                arSet: Adobe2.SetOfARs Ź NEW[Adobe2.SetOfARsObject[1]];
                arSet[0] Ź [1,5];
                arSet Ź LookupARs[server, system, version, "Age", value, arSet];
                cmd.out.PutRope[" result: \n"];
                FOR i: CARD IN [0..arSet.len) DO
                    cmd.out.PutF["   %g-%g\n", IO.card[arSet[i].startValue], IO.card[arSet[i].startValue + arSet[i].runLength - 1] ];
                    ENDLOOP;
                };
            EXITS Failed => { result Ź $Failure };
            };

        ARQueryCommand: Commander.CommandProc ~ {
            cmd.out.PutF1["server: %g\n", IO.rope[server] ];
            cmd.out.PutF1[" system/database: %g\n", IO.rope[system] ];
            {
                ENABLE {
                    StubError=> { msg Ź whatsUp; GOTO Failed };
                    UnknownAddress => { msg Ź "UnknownAddress"; GOTO Failed };
                    };
                value: Adobe2.FieldItemQueryValue Ź [greaterThanOrEqual, 
                    NEW[Adobe2.FieldItemValueRec.arId Ź [arId[3]]]];
                arSet: Adobe2.SetOfARs Ź NEW[Adobe2.SetOfARsObject[1]];
                arSet[0] Ź [1,5];
                arSet Ź LookupARs[server, system, version, "Number", value, arSet];
                cmd.out.PutRope[" result: \n"];
                FOR i: CARD IN [0..arSet.len) DO
                    cmd.out.PutF["   %g-%g\n", IO.card[arSet[i].startValue], IO.card[arSet[i].startValue + arSet[i].runLength - 1] ];
                    ENDLOOP;
                };
            EXITS Failed => { result Ź $Failure };
            };

        EnumQueryCommand: Commander.CommandProc ~ {
            cmd.out.PutF1["server: %g\n", IO.rope[server] ];
            cmd.out.PutF1[" system/database: %g\n", IO.rope[system] ];
            {
                ENABLE {
                    StubError=> { msg Ź whatsUp; GOTO Failed };
                    UnknownAddress => { msg Ź "UnknownAddress"; GOTO Failed };
                    };
                value: Adobe2.FieldItemQueryValue Ź [equal, 
                    NEW[Adobe2.FieldItemValueRec.enumerated Ź [enumerated[2]]]];
                arSet: Adobe2.SetOfARs Ź NEW[Adobe2.SetOfARsObject[1]];
                arSet[0] Ź [1,5];
                arSet Ź LookupARs[server, system, version, "System", value, arSet];
                cmd.out.PutRope[" result: \n"];
                FOR i: CARD IN [0..arSet.len) DO
                    cmd.out.PutF["   %g-%g\n", IO.card[arSet[i].startValue], IO.card[arSet[i].startValue + arSet[i].runLength - 1] ];
                    ENDLOOP;
                };
            EXITS Failed => { result Ź $Failure };
            };

        FixQueryCommand: Commander.CommandProc ~ {
            cmd.out.PutF1["server: %g\n", IO.rope[server] ];
            cmd.out.PutF1[" system/database: %g\n", IO.rope[system] ];
            {
                ENABLE {
                    StubError=> { msg Ź whatsUp; GOTO Failed };
                    UnknownAddress => { msg Ź "UnknownAddress"; GOTO Failed };
                    };
                value: Adobe2.FieldItemQueryValue Ź [in, 
                    NEW[Adobe2.FieldItemValueRec.fixedLengthString Ź [fixedLengthString["pj", 60]]]];
                arSet: Adobe2.SetOfARs Ź NEW[Adobe2.SetOfARsObject[1]];
                arSet[0] Ź [1,5];
                arSet Ź LookupARs[server, system, version, "Assigned To", value, arSet];
                cmd.out.PutRope[" result: \n"];
                FOR i: CARD IN [0..arSet.len) DO
                    cmd.out.PutF["   %g-%g\n", IO.card[arSet[i].startValue], IO.card[arSet[i].startValue + arSet[i].runLength - 1] ];
                    ENDLOOP;
                };
            EXITS Failed => { result Ź $Failure };
            };

        PutC: PROCEDURE [c: CHAR] ~ {
            SELECT c FROM
                IN['A..'Z], 
                IN['a..'z],
                IN['0..'9] => globalCmd.out.PutF1["%g ", IO.char[c]];
                ENDCASE => globalCmd.out.PutF1["/%gD ", IO.card[ORD[c]]];
            };

        To: CrRPC.BulkDataSink ~ {
            len, line, field: CARD Ź 0;
            b1, b2: CARD Ź 0;
            IF checkAbort[h] THEN {
                globalCmd.out.PutRope["Instant Abort.\n"];
                RETURN[FALSE];
                };
            IF IO.EndOf[s] THEN  {
                globalCmd.out.PutRope["Empty stream.\n"];
                RETURN[FALSE];
                };
            line Ź 1;
            WHILE NOT IO.EndOf[s] DO
                IF field > 3 THEN {
                    field Ź 0;
                    line Ź line + 1;
                    IO.PutF1[globalCmd.out, "line: %g\n", IO.card[line]];
                    };
                IO.PutF1[globalCmd.out, "\tfield: %g ", IO.card[field]];
                b1 Ź ORD[IO.GetByte[s]];
                b2 Ź ORD[IO.GetByte[s]];
                IO.PutF[globalCmd.out, "\b1: %g b2: %g", IO.card[b1], IO.card[b2]];
                len Ź (b1 * (ORD[LAST[CHAR]] + 1)) + b2;
                IO.PutF1[globalCmd.out, "(len = %g)\n", IO.card[len]];
                FOR i: CARD IN  [0..len) DO
                    PutC[IO.GetChar[s]];
                    ENDLOOP;
                IO.PutRope[globalCmd.out, "\n"];
                IF (len MOD 2) = 1 THEN
                    [] Ź IO.GetChar[s];
                ENDLOOP;
            RETURN[FALSE];
            };

        globalCmd: Commander.Handle Ź NIL;

        GetAccInfoCommand: Commander.CommandProc ~ {
            cmd.out.PutF1["server: %g\n", IO.rope[server] ];
            cmd.out.PutF1[" system/database: %g\n", IO.rope[system] ];
            {
                ENABLE {
                    StubError=> { msg Ź whatsUp; GOTO Failed };
                    UnknownAddress => { msg Ź "UnknownAddress"; GOTO Failed };
                    };
            <<accInfo: Adobe2.AcceleratorInfo _ NIL;>>
                arSet: Adobe2.SetOfARs Ź NEW[Adobe2.SetOfARsObject[1]];
                fieldList: Adobe2.FieldList Ź NEW[Adobe2.FieldListArray[4]];
                globalCmd Ź cmd;
                fieldList[0]Ź NEW[Adobe2.FieldItemObjectRec.arId];
                fieldList[0].name Ź "Number";
                fieldList[1]Ź NEW[Adobe2.FieldItemObjectRec.arId];
                fieldList[1].name Ź "System";
                fieldList[2]Ź NEW[Adobe2.FieldItemObjectRec.arId];
                fieldList[2].name Ź "Subsystem";
                fieldList[3]Ź NEW[Adobe2.FieldItemObjectRec.arId];
                fieldList[3].name Ź "Subject";
                arSet[0] Ź [1,5];

                GetAcceleratorInfo[server, system, version, arSet, fieldList, To];
            <<FOR i: CARD IN [0..accInfo.len) DO>>
            <<IO.PutF[cmd.out, "AR #%g\n", IO.card[i]];>>
            <<FOR j: CARD IN [0..accInfo[i].len) DO>>
            <<IO.PutF[cmd.out, "\tField #%g: %g\n", IO.card[j], IO.rope[accInfo[i][j]]];>>
            <<ENDLOOP;>>
            <<ENDLOOP;>>
                };
            EXITS Failed => { result Ź $Failure };
            };

        GetDefaultUserFileCommand: Commander.CommandProc ~ {
            cmd.out.PutF1["server: %g\n", IO.rope[server] ];
            cmd.out.PutF1[" system/database: %g\n", IO.rope[system] ];
            {
                ENABLE {
                    StubError=> { msg Ź whatsUp; GOTO Failed };
                    UnknownAddress => { msg Ź "UnknownAddress"; GOTO Failed };
                    };
                GDUSink: CrRPC.BulkDataSink = {
                    IF checkAbort[h] THEN {
                        cmd.out.PutRope["Instant Abort.\n"];
                        RETURN[FALSE];
                        };
                    IF IO.EndOf[s] THEN  {
                        cmd.out.PutRope["Empty stream.\n"];
                        RETURN[FALSE];
                        };
                    WHILE NOT IO.EndOf[s] DO
                        cmd.out.PutF1["%g ", IO.char[IO.GetChar[s]]];
                        ENDLOOP;
                    RETURN[FALSE];
                    };

                GetSystemDefaultUserFile[server, system, GDUSink];
                };
            EXITS Failed => { result Ź $Failure };
            };

        Init: PROC ~ {
            Commander.Register["XNSAdobe.GetDatabaseDescription", GetDatabaseDescriptionCommand];
            Commander.Register["XNSAdobe.GetDefaultUserFile", GetDefaultUserFileCommand];
            Commander.Register["XNSAdobe.GetLocationOfARs", GetLocationOfARsCommand];
            Commander.Register["XNSAdobe.GetNextSubmitNumber", GetNextSubmitNumberCommand];
            Commander.Register["XNSAdobe.GetVersion", GetVersionCommand];
            Commander.Register["XNSAdobe.ListDatabases", ListDatabasesCommand];
            Commander.Register["XNSAdobe.PutSubmitNumber", PutSubmitNumberCommand];
            Commander.Register["XNSAdobe.ReadLastARNumber", ReadLastARNumberCommand];
            Commander.Register["XNSAdobe.NumQuery", NumQueryCommand];
            Commander.Register["XNSAdobe.ARQuery", ARQueryCommand];
            Commander.Register["XNSAdobe.EnumQuery", EnumQueryCommand];
            Commander.Register["XNSAdobe.FixQuery", FixQueryCommand];
            Commander.Register["XNSAdobe.GetAccInfo", GetAccInfoCommand];
            };

        Init[];
        }.