
    <<EDIFAndCore.Mesa>>
        <<Copyright c 1986 by Xerox Corporation.  All rights reserved.>>
        <<Spreitzer, January 30, 1986 4:14:27 pm PST>>

    DIRECTORY Asserting, BasicTime, Core2, HashTable, Imager, ImagerPixelMap, IO, Rope;

    EDIFAndCore: CEDAR DEFINITIONS = {

        Error: ERROR [msg: ROPE];
        Warning: SIGNAL [msg: ROPE];

        LORA: TYPE = LIST OF REF ANY;
        ATOMList: TYPE = LIST OF ATOM;
        ROPE: TYPE = Rope.ROPE;
        RopeList: TYPE = LIST OF ROPE;
        Dictionary: TYPE = HashTable.Table;
        CoreCellType: TYPE = Core2.CellType;
        Assertions: TYPE = Asserting.Assertions;

        EDIFWhole: TYPE = REF EDIFWholePrivate;
        EDIFWholePrivate: TYPE = RECORD [
            name: NameStuff,
            status: Status,
            designs: Dictionary--of Design--,
            libraries: Dictionary--of Library--,
            externalLibraries: Dictionary--of <don't care>--,
            comments: Comments,
            ues: UserExtensions];

        NameStuff: TYPE = RECORD [
            edif: ROPE _ NIL,
                <<The EDIF Identifier used>>
            rename: ROPE _ NIL
                <<The unrestricted string>>
            ];

        Comment: TYPE = RopeList _ NIL;
        Comments: TYPE = LIST OF Comment _ NIL;
        UserExtensions: TYPE = LIST OF UserExtension _ NIL;
        UserExtension: TYPE = RECORD [
            name: NameStuff,
            stuff: LORA
            ];

        Status: TYPE = REF StatusPrivate;
        StatusPrivate: TYPE = RECORD [
            version: Version _ unspecifiedVersion,
            level: Level _ unspecifiedLevel,
            writtens: WrittenList,
            comments: Comments,
            ues: UserExtensions];

        unspecifiedVersion: Version = [unspecifiedINT, unspecifiedINT, unspecifiedINT];
        Version: TYPE =
            RECORD [major, medium, minor: INT _ 0]
            _ [unspecifiedINT, unspecifiedINT, unspecifiedINT];

        Level: TYPE = INTEGER [-1 .. 2];
        unspecifiedLevel: Level = -1;

        WrittenList: TYPE = LIST OF Written;
        Written: TYPE = REF WrittenPrivate;
        WrittenPrivate: TYPE = RECORD [
            time: BasicTime.GMT _ BasicTime.nullGMT,
            accountings: AccountingList,
            comments: Comments,
            ues: UserExtensions];

        AccountingList: TYPE = LIST OF Accounting;
        Accounting: TYPE = REF AccountingPrivate;
        AccountingPrivate: TYPE = RECORD [
            name: ATOM,
            data: ROPE _ NIL
            ];

        Design: TYPE = REF DesignPrivate;
        DesignPrivate: TYPE = RECORD [
            name: NameStuff,
            rootCellType: CellType,
            status: Status _ NIL,
            comments: Comments,
            ues: UserExtensions];

        CellType: TYPE = REF CellTypePrivate;
        CellTypePrivate: TYPE = RECORD [
            name: NameStuff,
            Apply: PROC [args: LORA, data: REF ANY] RETURNS [cct: CoreCellType],
            data: REF ANY
            ];

        Library: TYPE = REF LibraryPrivate;
        LibraryPrivate: TYPE = RECORD [
            name: NameStuff,
            status: Status _ NIL,
            technology: Technology _ NIL,
            cells: Dictionary--of CellType--,
            comments: Comments,
            ues: UserExtensions];

        Technology: TYPE = REF TechnologyPrivate;
        TechnologyPrivate: TYPE = RECORD [
            figureGroupDefaults: Dictionary--of FigureGroupDefault--,
            units: Units,
            simulationAlgebras: Dictionary--of SimulationAlgebra--,
            comments: Comments,
            ues: UserExtensions];

        Units: TYPE = RECORD [
            systemToScales: Dictionary--of DScales--,
            dimensionToScales: Dictionary--of SScales-- _ NIL
            ];

        DScales: TYPE = REF DScalesPrivate;
        DScalesPrivate: TYPE = RECORD [
            system: ROPE,
            scales: Dictionary--of Scale--,
            comments: Comments,
            ues: UserExtensions];

        SScales: TYPE = REF SScalesPrivate;
        SScalesPrivate: TYPE = RECORD [
            dimension: ROPE,
            scales: Dictionary--of Scale--
            ];

        Scale: TYPE = REF ScalePrivate;
        ScalePrivate: TYPE = RECORD [
            system, dimension: ROPE,
            factor: REAL
            ];
            <<1 in the EDIF file corresponds to factor*name in system.>>

        FigureGroupDefault: TYPE = REF FigureGroupDefaultPrivate;
        FigureGroupDefaultPrivate: TYPE = RECORD [
            name: NameStuff,
            pathType: PathType _ unspecifiedPathType,
            width: INT _ unspecifiedINT,
            color: Imager.ConstantColor _ unspecifiedColor,
            fillPattern: ImagerPixelMap.PixelMap _ unspecifiedPixelMap,
            borderPattern: ImagerPixelMap.PixelMap _ unspecifiedPixelMap,
            comments: Comments,
            ues: UserExtensions];

        unspecifiedPathType: PathType = [];
        PathType: TYPE = RECORD [
            end: EndType _ unspecified,
            corner: CornerType _ unspecified
            ];

        EndType: TYPE = {extend, truncate, round, unspecified};
        CornerType: TYPE = {extend, truncate, round, unspecified};
        unspecifiedINT: INT = FIRST[INT];
        unspecifiedColor: Imager.ConstantColor = NIL;
        unspecifiedPixelMap: ImagerPixelMap.PixelMap = [
            sOrigin: 0, fOrigin: 0, sMin: 0, fMin: 0, sSize: 0, fSize: 0, refRep: NIL
            ];

        SimulationAlgebra: TYPE = REF SimulationAlgebraPrivate;
        SimulationAlgebraPrivate: TYPE = RECORD [
            name: NameStuff,
            values: ATOMSequence,
            combinations: ATOMSequence,
                <<values[i] join values[j] = combinations[c[i, j, values.Length[]]] when i <= j.>>
                <<c[0, j, n] = j.>>
                <<c[i, j, n] = c[i-1, n-1, n] + 1 + j - i>>
            isolated: ATOM,
            simulationMaps: HashTable.Table--from: SimulationAlgebra 
            ];

        ATOMSequence: TYPE = REF ATOMSequencePrivate;
        ATOMSequencePrivate: TYPE = RECORD [atoms: SEQUENCE length: NAT OF ATOM];

        SimulationAlgebraMap: TYPE = REF SimulationAlgebraMapPrivate;
        SimulationAlgebraMapPrivate: TYPE = RECORD [
            from, to: SimulationAlgebra,
            forward: HashTable.Table--from:ATOM 
            comments: Comments,
            ues: UserExtensions];

        EDIFToRope: PROC [ew: EDIFWhole] RETURNS [r: ROPE];
        EDIFToStream: PROC [ew: EDIFWhole, to: IO.STREAM];
        EDIFToFile: PROC [ew: EDIFWhole, fileName: ROPE];

        EDIFFromRope: PROC [r: ROPE] RETURNS [ew: EDIFWhole];
        EDIFFromStream: PROC [from: IO.STREAM] RETURNS [ew: EDIFWhole];
        EDIFFromFile: PROC [fileName: ROPE] RETURNS [ew: EDIFWhole];

        ToEDIFIdentifier: PROC [r: ROPE] RETURNS [id: ROPE];
        FromEDIFIdentifier: PROC [id: ROPE] RETURNS [r: ROPE];

        }.