<> <> <

>

    DIRECTORY
        MathExpr USING [AtomClass, CompoundClass, MatrixClass],
        List USING [AList, Assoc, PutAssoc],
        MathDB;


    MathDBImpl: CEDAR PROGRAM 
        IMPORTS List
        EXPORTS MathDB ~

        BEGIN

        < >

            AtomClass: TYPE ~ MathExpr.AtomClass;
            CompoundClass: TYPE ~ MathExpr.CompoundClass;
            MatrixClass: TYPE ~ MathExpr.MatrixClass;


        < >

            GlobalAtomClasses: List.AList _ NIL;
            GlobalCompoundClasses: List.AList _ NIL;
            GlobalMatrixClasses: List.AList _ NIL;


        < >

            AtomClassNames: PUBLIC LIST OF ATOM _ NIL;
            CompoundClassNames: PUBLIC LIST OF ATOM _ NIL;
            MatrixClassNames: PUBLIC LIST OF ATOM _ NIL;



        < >
        <<>>
            ResetAtomClasses: PUBLIC PROC[] ~ {
                < >
                GlobalAtomClasses _ NIL;
                AtomClassNames _ NIL;
                };

            ResetCompoundClasses: PUBLIC PROC[] ~ {
                < >
                GlobalCompoundClasses _ NIL;
                CompoundClassNames _ NIL;
                };

            ResetMatrixClasses: PUBLIC PROC[] ~ {
                < >
                GlobalMatrixClasses _ NIL;
                MatrixClassNames _ NIL;
                };


            InstallAtomClass: PUBLIC PROC[class: AtomClass] ~ {
                < >
                <<>>
                < >
                GlobalAtomClasses _ List.PutAssoc[key: class.name, val: class, aList: GlobalAtomClasses];

                < >
                AtomClassNames _ CONS[class.name, AtomClassNames];
                };

            InstallCompoundClass: PUBLIC PROC[class: CompoundClass] ~ {
                < >
                <<>>
                < >
                GlobalCompoundClasses _ List.PutAssoc[key: class.name, val: class, aList: GlobalCompoundClasses];

                < >
                CompoundClassNames _ CONS[class.name, CompoundClassNames];
                };

            InstallMatrixClass: PUBLIC PROC[class: MatrixClass] ~ {
                < >
                <<>>
                < >
                GlobalMatrixClasses _ List.PutAssoc[key: class.name, val: class, aList: GlobalMatrixClasses];

                < >
                MatrixClassNames _ CONS[class.name, MatrixClassNames];
                };


            LookupAtomClass: PUBLIC PROC[name: ATOM] RETURNS[AtomClass] ~ {
                < >
                <<          SIGNALS notFound if no association exists>>
                <<>>
                atomClass: AtomClass _ NARROW[List.Assoc[key: name, aList: GlobalAtomClasses]];
                IF atomClass = NIL THEN ERROR notFound;
                RETURN[atomClass];
                };

            LookupCompoundClass: PUBLIC PROC[name: ATOM] RETURNS[CompoundClass] ~ {
                < >
                <<          SIGNALS notFound if no association exists>>
                <<>>
                compoundClass: CompoundClass _ NARROW[List.Assoc[key: name, aList: GlobalCompoundClasses]];
                IF compoundClass = NIL THEN ERROR notFound;
                RETURN[compoundClass];
                };

            LookupMatrixClass: PUBLIC PROC[name: ATOM] RETURNS[MatrixClass] ~ {
                < >
                <<          SIGNALS notFound if no association exists>>
                <<>>
                matrixClass: MatrixClass _ NARROW[List.Assoc[key: name, aList: GlobalMatrixClasses]];
                IF matrixClass = NIL THEN ERROR notFound;
                RETURN[matrixClass];
                };


        < >

            notFound: PUBLIC ERROR = CODE;



        END.