<<>>
    <<FinalizeOpsImpl.mesa>>
        <<Copyright Ó 1992 by Xerox Corporation.  All rights reserved.>>
        <<Created by Christian Jacobi, July 17, 1992 1:45:01 pm PDT>>
        <<Christian Jacobi, July 22, 1992 10:50 am PDT>>
        <<>>
    DIRECTORY 
        Finalize, 
        FinalizeOps, 
        Process;

    FinalizeOpsImpl: CEDAR MONITOR
        IMPORTS Finalize, Process
        EXPORTS FinalizeOps
    ~ BEGIN
    <<>>
Handle: TYPE = FinalizeOps.Handle;
    FinalizeProc: TYPE = FinalizeOps.FinalizeProc;
    CallQueue: TYPE = REF CallQueueRep;
    CallQueueRep: PUBLIC TYPE = MONITORED RECORD [
        finalize: FinalizeProc,
        priority: Process.Priority,
        active: BOOL ¬ FALSE,
        front: LIST OF Handle ¬ NIL,
        tail: LIST OF Handle ¬ NIL
        ];

fq: Finalize.FinalizationQueue ~ Finalize.NewFQ[];

    IsCallQueue: PUBLIC PROC [x: REF] RETURNS [BOOL] = {
        RETURN [ISTYPE[x, CallQueue]]
        };
        <<>>
    NarrowCallQueue: PUBLIC PROC [x: REF] RETURNS [CallQueue] = {
        RETURN [NARROW[x, CallQueue]]
        };
        <<>>
    IsFinalizeOpsHandle: PUBLIC PROC [handle: Finalize.Handle] RETURNS [BOOL] = {
    WITH Finalize.GetClientData[handle] SELECT FROM
    cq: CallQueue => RETURN [TRUE];
    ENDCASE => RETURN [FALSE];
    };

    EnableFinalization: PUBLIC PROC [object: REF, callQueue: FinalizeOps.CallQueue] RETURNS [handle: Handle] = {
    handle ¬ Finalize.EnableFinalization[object, fq, callQueue];
    };
    <<>>
    ReenableFinalization: PUBLIC PROC [handle: Handle] RETURNS [oldState: Finalize.FinalizationState] = {
    WITH Finalize.GetClientData[handle] SELECT FROM
    cq: CallQueue => oldState ¬ Finalize.ReenableFinalization[handle, fq];
    ENDCASE => ERROR;
    };
    <<>>
    CreateCallQueue: PUBLIC PROC [finalize: FinalizeProc, priority: Process.Priority ¬ Process.priorityForeground] RETURNS [cq: 
    CallQueue] = {
        cq ¬ NEW[CallQueueRep ¬ [finalize: finalize, priority: priority]];
        };

    HandleToObject: PUBLIC PROC [handle: Handle] RETURNS [object: REF] = {
        RETURN [Finalize.HandleToObject[handle]]
        };
        <<>>
    freeList: LIST OF Handle ¬ NIL;

    DisposeList: INTERNAL PROC [l: LIST OF Handle] = INLINE {
        l.first ¬ NIL;
        l.rest ¬ freeList;
        freeList ¬ l
        };

    NewList: INTERNAL PROC [h: Handle] RETURNS [l: LIST OF Handle] = INLINE {
    l ¬ freeList;
    IF l=NIL THEN l ¬ LIST[h] ELSE {freeList ¬ l.rest; l.first ¬ h; l.rest ¬ NIL}
    };

    Forward: ENTRY PROC [cq: CallQueue, h: Handle] RETURNS [mustFork: BOOL ¬ FALSE] = {
    <<--Assert h#NIL>>
    list: LIST OF Handle ¬ NewList[h];
        IF cq.front=NIL 
            THEN cq.front ¬ list
            ELSE cq.tail.rest ¬ list;
        cq.tail ¬ list;
        IF ~cq.active THEN cq.active ¬ mustFork ¬ TRUE; 
        };

    Fetch: ENTRY PROC [cq: CallQueue] RETURNS [h: Handle ¬ NIL] = {
    <<--If h=NIL the process is terminated>>
        l: LIST OF Handle ¬ cq.front;
        IF l#NIL 
            THEN {h ¬ l.first; cq.front ¬ l.rest; DisposeList[l]}
            ELSE cq.active ¬ FALSE;
        };

    CallQueueProcess: PROC [cq: CallQueue] = {
        Process.SetPriority[cq.priority];
        DO
            ENABLE ABORTED => LOOP;
            DO
            h: Handle ¬ Fetch[cq];
            IF h=NIL THEN RETURN;
            cq.finalize[h, Finalize.HandleToObject[h]];
            ENDLOOP;
        ENDLOOP;
        };

    MainQueueProcess: PROC [] = {
        Process.SetPriority[Process.priorityForeground];
        DO
        handle: Handle ¬ Finalize.FQNextNoAbort[fq];
        IF handle#NIL THEN {
        WITH Finalize.GetClientData[handle] SELECT FROM
        cq: CallQueue => {
        IF Forward[cq, handle].mustFork THEN TRUSTED {
            Process.Detach[FORK CallQueueProcess[cq]];
        };
        };
        ENDCASE => {};
        handle ¬ NIL;
        };
        ENDLOOP;
        };

    TRUSTED {
        Process.Detach[FORK MainQueueProcess[]];
        };
    END.