
<<///sloop/ReadConnectionImpl.mesa>>
<<Last Edited by: Preas, August 28, 1984 4:10:50 pm PDT>>
<<Last Edited by: CSChow, January 31, 1985 6:08:50 am PST>>
<<>>
<<run by typing run PopupMenuImpl TerminalIOImpl ReadConnectionImpl>>

<<Read Connectivity data>>
DIRECTORY IO USING [STREAM, GetRefAny, SkipWhitespace, EndOf],
FS,
TerminalIO USING [WriteRope],
Rope USING [ROPE, Cat],
ReadConnection;

ReadConnectionImpl: CEDAR PROGRAM
    IMPORTS IO, FS, TerminalIO, Rope
    EXPORTS ReadConnection =

    BEGIN
    OPEN ReadConnection;

    ReadConct: PUBLIC PROCEDURE [file: Rope.ROPE,
        EnumHeader: EnumHeaderProc,
        EnumPorts: EnumPortsProc,
        EnumNets: EnumNetsProc,
        EnumPortNets: EnumPortNetsProc,
        EnumComps: EnumCompsProc] =

        BEGIN
        from: IO.STREAM _ FS.StreamOpen[file];
        DO
            item: LORA;
            [] _ IO.SkipWhitespace[from];
            IF from.EndOf[] THEN EXIT;
            item _ NARROW[from.GetRefAny[]];
            SELECT item.first FROM

                $CellTypeName => BEGIN
                    cellTypeName: Rope.ROPE;
                    cellTypeName _ NARROW[item.rest.first];
                    EnumHeader["CellTypeName", cellTypeName];
                    IF item.rest.rest # NIL THEN
                        TerminalIO.WriteRope[Rope.Cat["Data following CellTypeName ignored: cellTypeName = ", cellTypeName, "\n"]];
                    END;

                $CreatingUser => BEGIN
                    userName: Rope.ROPE;
                    userName _ NARROW[item.rest.first];
                    EnumHeader["CreatingUser", userName];
                    IF item.rest.rest # NIL THEN
                        TerminalIO.WriteRope[Rope.Cat["Data following CreatingUser ignored: CreatingUser = ", userName, "\n"]];
                    END;

                $CreationTime => BEGIN
                    creationTime: Rope.ROPE;
                    creationTime _ NARROW[item.rest.first];
                    EnumHeader["CreationTime", creationTime];
                    IF item.rest.rest # NIL THEN
                        TerminalIO.WriteRope[Rope.Cat["Data following CreationTime ignored: creationTime = ", creationTime, "\n"]];
                    END;

                $CreationSite => BEGIN
                    creationSite: Rope.ROPE;
                    creationSite _ NARROW[item.rest.first];
                    EnumHeader["CreationSite", creationSite];
                    IF item.rest.rest # NIL THEN
                        TerminalIO.WriteRope[Rope.Cat["Data following CreationSite ignored: creationSite = ", creationSite, "\n"]];
                    END;

                $Version => BEGIN
                    versionSpec: Rope.ROPE;
                    versionSpec _ NARROW[item.rest.first];
                    EnumHeader["VersionSpec", versionSpec];
                    IF item.rest.rest # NIL THEN
                        TerminalIO.WriteRope[Rope.Cat["Data following VersionSpec ignored: versionSpec = ", versionSpec, "\n"]];
                    END;

                $DerivingProgram => BEGIN
                    END;

                $Source => BEGIN
                    END;

                $CellTypeEquivalentClass => BEGIN
                    equivalenceClass: Rope.ROPE;
                    equivalenceClass _ NARROW[item.rest.first];
                    EnumHeader["CellTypeEquivalentClass", equivalenceClass];
                    IF item.rest.rest # NIL THEN
                        TerminalIO.WriteRope[Rope.Cat["Data following CellTypeEquivalentClass ignored: CellTypeEquivalentClass = ", equivalenceClass, 
                        "\n"]];
                    END;

                $Ports => BEGIN
                    portIndex: CARDINAL _ 0;
                    portList: LIST OF portEc _ NIL;
                    FOR portSpec: LORA _ item.rest, portSpec.rest WHILE portSpec # NIL DO
                        equivClass: Rope.ROPE _ NIL;
                        direction: Direction _ Unknown;
                        pair: LORA _ NARROW[portSpec.first];
                        portName: Rope.ROPE _ NARROW[pair.first];
                        FOR portAssertion: LORA _ pair.rest, portAssertion.rest
                            WHILE portAssertion # NIL DO
                            assertion: LORA _ NARROW[portAssertion.first];
                            IF assertion.first = $EC THEN equivClass _ NARROW[assertion.rest.first]
                            ELSE IF assertion.first = $IN THEN direction _ Input
                            ELSE IF assertion.first = $OUT THEN direction _ Output
                            ELSE IF assertion.first = $BIDIR THEN direction _ InputOutput;
                            ENDLOOP;
                        portIndex _ portIndex + 1;
                        portList _ CONS[portEc[portIndex, portName, equivClass, direction], portList];
                        ENDLOOP;
                    EnumPorts[portList];
                    END;

                $InsidesUnspecified => BEGIN
                    EnumHeader["InsidesUnspecified"];
                    END;

                $PrivateFollows => BEGIN
                    EnumHeader["PrivateFollows"];
                    END;

                $N => BEGIN
                    netName: Rope.ROPE _ NARROW[item.rest.first];
                    generation: Generation _ Unknown;

                    FOR netAssertion: LORA _ NARROW[item.rest.rest], netAssertion.rest
                        WHILE netAssertion # NIL DO
                        assertion: LORA _ NARROW[netAssertion.first];
                        IF assertion.first = $G THEN
                            BEGIN
                            IF assertion.rest.first = $D THEN generation _ Designer
                            ELSE IF assertion.rest.first = $P THEN generation _ Program;
                            END;
                        ENDLOOP;

                    EnumNets[netName, generation];
                    END;

                $PN => BEGIN
                    portName, netName: Rope.ROPE;
                    portName _ NARROW[item.rest.first];
                    netName _ NARROW[item.rest.rest.first];
                    EnumPortNets[portName, netName];
                    IF item.rest.rest.rest # NIL THEN
                        TerminalIO.WriteRope[Rope.Cat["Data following portName/netName ignored: portName = ", portName, " netName = ", netName, "\n"]];
                    END;

                $CI => BEGIN
                    instName, typeName: Rope.ROPE;
                    pinIndex: CARDINAL _ 1;
                    cicList: LORA;
                    pnList: LIST OF pinNet _ NIL;
                    instName _ NARROW[item.rest.first];
                    typeName _ NARROW[item.rest.rest.first];

                    <<--This is a kludgy fix. A better solution would be to redesign the interface>>
                        <<--CSChow: January 31, 1985 6:03:07 am PST>>
                    cicList _ NARROW[item.rest.rest.rest];
                    UNTIL NARROW[cicList.first, LORA].first = $CIC DO
                        cicList _ cicList.rest;
                        IF cicList = NIL THEN EXIT;
                        ENDLOOP;
                    IF cicList # NIL THEN
                        BEGIN
                        FOR con: LORA _ NARROW[cicList.first, LORA].rest, con.rest WHILE con # NIL DO
                            pair: LORA _ NARROW[con.first];
                            pinName: Rope.ROPE _ NARROW[pair.first];
                            netName: Rope.ROPE _ NARROW[pair.rest.first];
                            pnList _ CONS[pinNet[pinIndex, pinName, netName], pnList];
                            pinIndex _ pinIndex + 1;
                            ENDLOOP;
                        EnumComps[instName, typeName, pnList];
                        END
                    ELSE
                        TerminalIO.WriteRope[Rope.Cat["No CIC data: instName = ", instName, " typeName = ", typeName, "\n"]];
                    END;
                $Leaf => ERROR;
                ENDCASE => ERROR;
            ENDLOOP;
    <<FS.Close[from];>>
        END;

    EchoHeader: PUBLIC EnumHeaderProc =
        BEGIN
        TerminalIO.WriteRope[Rope.Cat["(", key]];
    IF val1 # NIL THEN TerminalIO.WriteRope[Rope.Cat["  """, val1, """"]];
    IF val2 # NIL THEN TerminalIO.WriteRope[Rope.Cat["  """, val2, """"]];
        TerminalIO.WriteRope[")\n"];
    END;

    EchoPorts: PUBLIC EnumPortsProc =
        <<PROCEDURE [portList: LIST OF portEc]>>
        BEGIN
        TerminalIO.WriteRope["(Ports"];
        FOR pList: LIST OF portEc _ portList, pList.rest WHILE pList # NIL DO
            TerminalIO.WriteRope[Rope.Cat["\n  (""", pList.first.portName, """"]];
        IF pList.first.ecName # NIL THEN
        TerminalIO.WriteRope[Rope.Cat["  (EC """, pList.first.ecName, """)"]];
        IF pList.first.portDir = Input THEN
        TerminalIO.WriteRope["  (IN)"]
        ELSE IF pList.first.portDir = Output THEN
        TerminalIO.WriteRope["  (OUT)"]
        ELSE IF pList.first.portDir = InputOutput THEN
        TerminalIO.WriteRope["  (BIDIR)"];
            TerminalIO.WriteRope[")"];
            ENDLOOP;
        TerminalIO.WriteRope[")\n"];
        END;

    EchoNets: PUBLIC EnumNetsProc =
        BEGIN
        TerminalIO.WriteRope[Rope.Cat["(N  """, netName, """ "]];
        IF generation = Designer THEN TerminalIO.WriteRope["(G D)"]
        ELSE IF generation = Program THEN TerminalIO.WriteRope["(G P)"];
        TerminalIO.WriteRope[")\n"];
        END;

    EchoPortNets: PUBLIC EnumPortNetsProc =
        BEGIN
        TerminalIO.WriteRope[Rope.Cat["(PN  """, portName, """  """, netName, """)\n"]];
        END;

    EchoComps: PUBLIC EnumCompsProc =
        BEGIN
        TerminalIO.WriteRope[Rope.Cat["(CI  """, instName, """  """, typeName, """", "\n"]];
        TerminalIO.WriteRope["  (CIC"];
        FOR pnList: LIST OF pinNet _ pinNetList, pnList.rest WHILE pnList # NIL DO
            TerminalIO.WriteRope[Rope.Cat["    (""", pnList.first.pinName, """  """, pnList.first.netName, """)\n"]];
            ENDLOOP;
        TerminalIO.WriteRope["))"];
        END;

    <<ReadConct[file: "///mouse/ShiftCap-9.sch",>>
        <<EnumHeader: EchoHeader,>>
        <<EnumPorts: EchoPorts,>>
        <<EnumNets: EchoNets,>>
        <<EnumPortNets: EchoPortNets,>>
        <<EnumComps: EchoComps];>>

    -- ReadConct[file: "///sloop/TSArbiter-1.sch",
        -- EnumHeader: EchoHeader,
        -- EnumPorts: EchoPorts,
        -- EnumNets: EchoNets,
        -- EnumPortNets: EchoPortNets,
        -- EnumComps: EchoComps];

    END.