
<<ModuleGraphs.Mesa>>
<<Last Edited by: Spreitzer, June 6, 1985 5:24:47 pm PDT>>

    DIRECTORY AMModel, Atom, Graphs, Rope, WorldVM;

    ModuleGraphs: CEDAR PROGRAM
        IMPORTS AMModel, Atom, Rope, WorldVM =

    BEGIN

    ROPE: TYPE = Rope.ROPE;

    vertexKey: ATOM _ Atom.MakeAtom["Spreitzer January 5, 1984 6:48 pm"];

    worldContext: AMModel.Context;

    NewModuleVertex: PROC [moduleName: ROPE] RETURNS [vertex: Graphs.Vertex] =
        BEGIN
        atom: ATOM _ Atom.MakeAtom[moduleName];
        IF (vertex _ NARROW[Atom.GetProp[atom: atom, prop: vertexKey]]) # NIL THEN RETURN;
        Atom.PutProp[
            atom: atom,
            prop: vertexKey,
            val: vertex _ NEW [Graphs.VertexRep _ [
                type: moduleVertexType,
                rep: moduleName]]
            ];
        END;

    ExpandModule: Graphs.ExpandProc --PROC [vertex: Vertex, consume: EdgeConsumer, data: REF ANY _ NIL]-- =
        BEGIN
        moduleName: ROPE _ NARROW[vertex.rep];
        consume.proc[["imports", NewImportsVertex[moduleName]], consume.data];
        consume.proc[["exports", NewExportsVertex[moduleName]], consume.data];
        END;

    NewImportsVertex: PROC [moduleName: ROPE] RETURNS [vertex: Graphs.Vertex] =
        BEGIN
        vertex _ NEW [Graphs.VertexRep _ [
            type: importsVertexType,
            rep: moduleName]]
        END;

    NewExportsVertex: PROC [moduleName: ROPE] RETURNS [vertex: Graphs.Vertex] =
        BEGIN
        vertex _ NEW [Graphs.VertexRep _ [
            type: exportsVertexType,
            rep: moduleName]]
        END;

    ExpandImports: Graphs.ExpandProc --PROC [vertex: Vertex, consume: EdgeConsumer, data: REF ANY _ NIL]-- =
        BEGIN
        moduleName: ROPE _ NARROW[vertex.rep];
        context: AMModel.Context;
        imports: LIST OF AMModel.PartialInterfaceInstance;
        TRUSTED {context _ AMModel.MostRecentNamedContext[name: moduleName, context: worldContext]};
        IF context = NIL THEN RETURN;
        TRUSTED {imports _ AMModel.Imports[context]};
        FOR imports _ imports, imports.rest WHILE imports # NIL DO
            name: ROPE;
            TRUSTED {name _ AMModel.ContextName[imports.first.ir]};
            consume.proc[[name, NewInterfaceVertex[name]], consume.data];
            ENDLOOP;
        END;

    ExpandExports: Graphs.ExpandProc --PROC [vertex: Vertex, consume: EdgeConsumer, data: REF ANY _ NIL]-- =
        BEGIN
        moduleName: ROPE _ NARROW[vertex.rep];
        context: AMModel.Context;
        exports: LIST OF AMModel.PartialInterfaceInstance;
        TRUSTED {context _ AMModel.MostRecentNamedContext[name: moduleName, context: worldContext]};
        IF context = NIL THEN RETURN;
        TRUSTED {exports _ AMModel.Exports[context]};
        FOR exports _ exports, exports.rest WHILE exports # NIL DO
            name: ROPE;
            TRUSTED {name _ AMModel.ContextName[exports.first.ir]};
            consume.proc[[name, NewInterfaceVertex[name]], consume.data];
            ENDLOOP;
        END;

    NewInterfaceVertex: PROC [moduleName: ROPE] RETURNS [vertex: Graphs.Vertex] =
        BEGIN
        atom: ATOM _ Atom.MakeAtom[moduleName];
        IF (vertex _ NARROW[Atom.GetProp[atom: atom, prop: vertexKey]]) # NIL THEN RETURN;
        Atom.PutProp[
            atom: atom,
            prop: vertexKey,
            val: vertex _ NEW [Graphs.VertexRep _ [
                type: interfaceVertexType,
                rep: moduleName]]
            ];
        END;

    ExpandInterface: Graphs.ExpandProc --PROC [vertex: Vertex, consume: EdgeConsumer, data: REF ANY _ NIL]-- =
        BEGIN
        interfaceName: ROPE _ NARROW[vertex.rep];
        consume.proc[["importedBy", NewImportedByVertex[interfaceName]], consume.data];
        consume.proc[["exportedBy", NewExportedByVertex[interfaceName]], consume.data];
        END;

    NewImportedByVertex: PROC [moduleName: ROPE] RETURNS [vertex: Graphs.Vertex] =
        BEGIN
        vertex _ NEW [Graphs.VertexRep _ [
            type: importedByVertexType,
            rep: moduleName]]
        END;

    NewExportedByVertex: PROC [moduleName: ROPE] RETURNS [vertex: Graphs.Vertex] =
        BEGIN
        vertex _ NEW [Graphs.VertexRep _ [
            type: exportedByVertexType,
            rep: moduleName]]
        END;

    ExpandImportedBy: Graphs.ExpandProc --PROC [vertex: Vertex, consume: EdgeConsumer, data: REF ANY _ NIL]-- =
        BEGIN
        interfaceName: ROPE _ NARROW[vertex.rep];
        FindInterface: PROC [prog: AMModel.Context] RETURNS [stop: BOOLEAN] =
            BEGIN
            imports: LIST OF AMModel.PartialInterfaceInstance;
            TRUSTED {imports _ AMModel.Imports[prog]};
            stop _ FALSE;
            FOR imports _ imports, imports.rest WHILE imports # NIL DO
                name: ROPE;
                TRUSTED {name _ AMModel.ContextName[imports.first.ir]};
                IF name.Equal[interfaceName] THEN {
                    consume.proc[[name, NewModuleVertex[name]], consume.data];
                    EXIT};
                ENDLOOP;
            END;
        TRUSTED {[] _ AMModel.ContextChildren[context: worldContext, proc: FindInterface]};
        END;

    ExpandExportedBy: Graphs.ExpandProc --PROC [vertex: Vertex, consume: EdgeConsumer, data: REF ANY _ NIL]-- =
        BEGIN
        interfaceName: ROPE _ NARROW[vertex.rep];
        FindInterface: PROC [prog: AMModel.Context] RETURNS [stop: BOOLEAN] =
            BEGIN
            exports: LIST OF AMModel.PartialInterfaceInstance;
            TRUSTED {exports _ AMModel.Exports[prog]};
            stop _ FALSE;
            FOR exports _ exports, exports.rest WHILE exports # NIL DO
                name: ROPE;
                TRUSTED {name _ AMModel.ContextName[exports.first.ir]};
                IF name.Equal[interfaceName] THEN {
                    consume.proc[[name, NewModuleVertex[name]], consume.data];
                    EXIT};
                ENDLOOP;
            END;
        TRUSTED {[] _ AMModel.ContextChildren[context: worldContext, proc: FindInterface]};
        END;

    moduleVertexType: Graphs.VertexType _ NEW [Graphs.VertexTypeRep _ [
        Expand: ExpandModule
        ]];

    importsVertexType: Graphs.VertexType _ NEW [Graphs.VertexTypeRep _ [
        Expand: ExpandImports
        ]];

    exportsVertexType: Graphs.VertexType _ NEW [Graphs.VertexTypeRep _ [
        Expand: ExpandExports
        ]];

    interfaceVertexType: Graphs.VertexType _ NEW [Graphs.VertexTypeRep _ [
        Expand: ExpandInterface
        ]];

    importedByVertexType: Graphs.VertexType _ NEW [Graphs.VertexTypeRep _ [
        Expand: ExpandImportedBy
        ]];

    exportedByVertexType: Graphs.VertexType _ NEW [Graphs.VertexTypeRep _ [
        Expand: ExpandExportedBy
        ]];

    TRUSTED {worldContext _ AMModel.RootContext[WorldVM.LocalWorld[]]};

    END.

    GraphBrowsers.Browse[vertex: ModuleGraphs.NewModuleVertex["ModuleGraphs"], browserClass: GraphBrowsers.basicBrowserClass, 
    viewerInit: [name: "ModuleGraphs", iconic: FALSE]]