<<>>
    <<SameBreakWorldImpl.mesa>>
        <<Copyright Ó 1990 by Xerox Corporation.  All rights reserved.>>
        <<Peter B. Kessler, August 6, 1990 5:10 pm PDT>>
        <<>>
    <<Access to Cirio for the same world.>>
    <<>>
        DIRECTORY
            SameBreakWorld,
            BreakWorldArchitecture,
            CirioBreakAccess,
            CirioNubAccess,
            IO,
            LoadStateAccess,
            NewRMTW,
            PFS,
            Rope,
            SystemInterface;

SameBreakWorldImpl: CEDAR PROGRAM
    IMPORTS 
        SystemInterface, CirioNubAccess, LoadStateAccess, NewRMTW, IO, PFS, CirioBreakAccess
    EXPORTS SameBreakWorld
    ~ {

        Handle: PUBLIC TYPE ~ REF HandleRep _ NIL;
            HandleRep: PUBLIC TYPE ~ RECORD [
                sameWorldNub: CirioNubAccess.Handle _ NIL,
                fileSet: SystemInterface.FileSet _ NIL,
                moduleSet: NewRMTW.CedarModuleSet _ NIL,
                loadState: LoadStateAccess.LoadStateHandle _ NIL,
                breakWorld: BreakWorldArchitecture.BreakWorld _ 
                    BreakWorldArchitecture.nullBreakWorld
                ];

        Create: PUBLIC PROCEDURE [] RETURNS [SameBreakWorld.Handle] ~ {
            handle: Handle _ NEW[HandleRep _ [
                sameWorldNub: , 
                fileSet: , 
                moduleSet: NIL, 
                loadState: NIL, 
                breakWorld: BreakWorldArchitecture.nullBreakWorld]];
            sameWorldServerName: Rope.ROPE ~ "sameWorld";
                <<cf. LocalCirioImpl.InstallNewConnectionComponents.>>
            handle.sameWorldNub _ CirioNubAccess.CreateSameWorldNub[];
            handle.fileSet _ SystemInterface.CreateFileSet[];
            handle.moduleSet _ NewRMTW.CreateCedarModuleSet[fileSet: handle.fileSet];
            handle.loadState _ LoadStateAccess.CreateLoadStateHandle[
                serverName: sameWorldServerName, 
                nub: handle.sameWorldNub, fileSet: handle.fileSet];
            {
                breakSet: CirioBreakAccess.CirioBreakSet _ CirioBreakAccess.CreateCirioBreakSet[
                    nub: handle.sameWorldNub, 
                    fileNameStem: "PopUpDriver2", 
                    breakProcName: "BreakPointPopUp"];
                    <<cf. Cirio/LocalCirioImpl.mesa>>
                handle.breakWorld _ CirioBreakAccess.BreakWorldFromBreakSet[breaks: breakSet];
                };
            RETURN [handle];
            };

        Destroy: PUBLIC PROCEDURE [handle: SameBreakWorld.Handle] RETURNS [] ~ {
            IF handle # NIL THEN {
                IF handle.breakWorld # BreakWorldArchitecture.nullBreakWorld THEN {
                    handle.breakWorld _ BreakWorldArchitecture.nullBreakWorld;
                    };
                IF handle.loadState # NIL THEN {
                    handle.loadState _ NIL;
                    };
                IF handle.moduleSet # NIL THEN {
                    handle.moduleSet _ NIL;
                    };
                IF handle.fileSet # NIL THEN {
                    SystemInterface.CloseFileSet[set: handle.fileSet];
                    handle.fileSet _ NIL;
                    };
                IF handle.sameWorldNub # NIL THEN {
                    CirioNubAccess.DestroyNub[h: handle.sameWorldNub];
                    handle.sameWorldNub _ NIL;
                    };
                };
            RETURN;
            };

        BreakWorld: PUBLIC PROCEDURE [handle: SameBreakWorld.Handle] 
        RETURNS [BreakWorldArchitecture.BreakWorld] ~ {
            breakWorld: BreakWorldArchitecture.BreakWorld _ 
                BreakWorldArchitecture.nullBreakWorld;

            IF handle # SameBreakWorld.nullHandle THEN {
                breakWorld _ handle.breakWorld
                };
            RETURN [breakWorld];
            };

        PCFromFileAndPosition: PUBLIC PROCEDURE [
        handle: SameBreakWorld.Handle,
        mesaFilename: Rope.ROPE, position: INT, report: IO.STREAM] 
        RETURNS [address: CARD _ 0, correspondingPosition: INT _ 0] ~ {
            IF handle # SameBreakWorld.nullHandle THEN { 
                ENABLE {
                    SystemInterface.ShowReport => {
                        report.PutRope[msgText];
                        report.PutChar['\n];
                        RESUME;
                        };
                    };
                mesaFile: NewRMTW.CirioFile _ SystemInterface.GetCirioFile[
                    set: handle.fileSet, name: PFS.PathFromRope[rope: mesaFilename]];
                addr: REF NewRMTW.CedarBreakAddress _ NewRMTW.GetAbsAddressForBreak[
                    modules: handle.moduleSet, 
                    mesa: mesaFile, 
                    loadState: handle.loadState, 
                    sourcePos: position];

                IF addr = NIL THEN ERROR NotFound;
                address _ addr.absPC;
                correspondingPosition _ addr.correspondingMesaPosition;
                };
            RETURN [address: address, correspondingPosition: correspondingPosition];
            };

        NotFound: PUBLIC ERROR ~ CODE;

}.