-- SSTrapsImpl.Mesa
-- last edited June 17, 1983 12:56 pm by Paul Rovner

DIRECTORY
  PrincOps USING[SD, StateVector, ControlLink, NullLink, zWCDBL, zICDBL, alpha],
  PrincOpsUtils USING[MyLocalFrame],
  RTMicrocode USING
                   [aALLOCATEHEAPNODE, aALTERCOUNT, aCREATEREF, aDUMPINDEX,
                    aFREEOBJECT, aFREEPREFIXEDNODE, aGETCANONICALREFERENTTYPE,
                    aRECLAIMEDREF, aRTMOVESTATUS, aREADREGS],
  RTRefCounts USING[ProbeIndex],
  RTSD USING   [sAllocateHeapNodeTrap, sAssignComposite, sAssignCompositeNew,
                    sAssignRefNewTrap, sAssignRefTrap, sCheckForNarrowRefFault,
                    sClobberedOverflowTable, sGetCanonicalReferentType, sProcCheck,
                    sRaiseNarrowFault, sGCState, sMapStiStd],
  RTTypesBasicPrivate USING[AssignComposite, AssignCompositeNew],
  SafeStorage USING[NarrowFault],
  SSTraps USING[AllocateHeapNodeSDTrap, ALTERCOUNTOutOfOverflowTable, AssignRef,
                    AssignRefNew, AssignRefNewTrap,
                    AssignRefTrap, CheckForNarrowRefFault, ClobberedOverflowTable,
                    CREATEOutOfOverflowTable, CreatePrefixedObjectTrap, FreeObjectTrap,
                    FreePrefixedNodeTrap, GetCanonicalReferentTypeSDTrap,
                    GetCanonicalReferentTypeTrap, ReadUCodeRegsTrap,
                    ReclaimedRefOutOfOverflowTable, RTMOVESTATUSTrap, MapStiStd, GCState],
  TrapSupport USING[BumpPC, opTrapTable];

SSTrapsImpl: PROGRAM
  IMPORTS PrincOpsUtils, RTTypesBasicPrivate, SafeStorage, SSTraps, TrapSupport
  EXPORTS SafeStorage, SSTraps
= BEGIN OPEN PrincOps, RTMicrocode, RTSD, TrapSupport;

-- PUBLIC SIGNALS --
  UnsafeProcAssignment: PUBLIC SAFE SIGNAL[proc: PROC ANY RETURNS ANY] = CODE;

-- PUBLIC PROCEDURES --

  RaiseNarrowFault: PUBLIC PROC =
   { state: StateVector;
     kludge: LONG UNSPECIFIED;
     state _ STATE;   -- incantation to clear the stack
     IF FALSE THEN kludge _ 0;
     ERROR SafeStorage.NarrowFault};

  ProcCheck: PUBLIC PROC[proc: PROC ANY RETURNS ANY]
        RETURNS[PROC ANY RETURNS ANY] = {
    p: ControlLink = LOOPHOLE[proc];
    IF p # NullLink AND ~p.tag THEN SIGNAL UnsafeProcAssignment[proc];
    RETURN[proc]};

 DumpIndexTrap: PUBLIC PROC[pi: RTRefCounts.ProbeIndex] RETURNS[count: CARDINAL] =
   { state: StateVector;
     state _ STATE;   -- incantation
     count _ 0;    -- means no microcode
     BumpPC[2];                -- length of opcode
     state.dest _ LOOPHOLE[PrincOpsUtils.MyLocalFrame[]];
     TRANSFER WITH state;   -- incantation
   };

-- START HERE

opTrapTable.main[zWCDBL] _ LOOPHOLE[SSTraps.AssignRefTrap];
opTrapTable.main[zICDBL] _ LOOPHOLE[SSTraps.AssignRefNewTrap];

opTrapTable.misc[aRECLAIMEDREF] _ LOOPHOLE[SSTraps.ReclaimedRefOutOfOverflowTable];
opTrapTable.misc[aALTERCOUNT] _ LOOPHOLE[SSTraps.ALTERCOUNTOutOfOverflowTable];
opTrapTable.misc[aRTMOVESTATUS] _ LOOPHOLE[SSTraps.RTMOVESTATUSTrap];
opTrapTable.misc[aREADREGS]_ LOOPHOLE[SSTraps.ReadUCodeRegsTrap];
opTrapTable.misc[aCREATEREF] _ LOOPHOLE[SSTraps.CREATEOutOfOverflowTable];
opTrapTable.misc[aDUMPINDEX]_ LOOPHOLE[DumpIndexTrap];
opTrapTable.misc[aGETCANONICALREFERENTTYPE]
                         _ LOOPHOLE[SSTraps.GetCanonicalReferentTypeTrap];
opTrapTable.misc[aALLOCATEHEAPNODE] _ LOOPHOLE[SSTraps.CreatePrefixedObjectTrap];
opTrapTable.misc[aFREEOBJECT] _ LOOPHOLE[SSTraps.FreeObjectTrap];
opTrapTable.misc[aFREEPREFIXEDNODE] _ LOOPHOLE[SSTraps.FreePrefixedNodeTrap];

IF SD[sAssignRefTrap] # 0 THEN ERROR;
SD[sAssignRefTrap] _ LOOPHOLE[SSTraps.AssignRef, CARDINAL];

IF SD[sAssignRefNewTrap] # 0 THEN ERROR;
SD[sAssignRefNewTrap] _ LOOPHOLE[SSTraps.AssignRefNew, CARDINAL];

IF SD[sProcCheck] # 0 THEN ERROR;
SD[sProcCheck] _ LOOPHOLE[ProcCheck, CARDINAL];

IF SD[sCheckForNarrowRefFault] # 0 THEN ERROR;
SD[sCheckForNarrowRefFault] _ LOOPHOLE[SSTraps.CheckForNarrowRefFault, CARDINAL];

IF SD[sRaiseNarrowFault] # 0 THEN ERROR;
SD[sRaiseNarrowFault] _ LOOPHOLE[RaiseNarrowFault, CARDINAL];

IF SD[sGCState] # 0 THEN ERROR;
IF SD[sGCState+1] # 0 THEN ERROR;
LOOPHOLE[LONG[@SD[sGCState]],
             LONG POINTER TO LONG POINTER]^ _ SSTraps.GCState;

IF SD[sGetCanonicalReferentType] # 0 THEN ERROR;
SD[sGetCanonicalReferentType] _ LOOPHOLE[SSTraps.GetCanonicalReferentTypeSDTrap, CARDINAL];

IF SD[sAssignComposite] # 0 THEN ERROR;
SD[sAssignComposite] _ LOOPHOLE[RTTypesBasicPrivate.AssignComposite, CARDINAL];

IF SD[sAssignCompositeNew] # 0 THEN ERROR;
SD[sAssignCompositeNew] _ LOOPHOLE[RTTypesBasicPrivate.AssignCompositeNew, CARDINAL];

IF SD[sClobberedOverflowTable] # 0 THEN ERROR;
SD[sClobberedOverflowTable] _ LOOPHOLE[SSTraps.ClobberedOverflowTable, CARDINAL];

IF SD[sAllocateHeapNodeTrap] # 0 THEN ERROR;
SD[sAllocateHeapNodeTrap] _ LOOPHOLE[SSTraps.AllocateHeapNodeSDTrap, CARDINAL];

IF SD[sMapStiStd] # 0 THEN ERROR;
IF SD[sMapStiStd+1] # 0 THEN ERROR;
LOOPHOLE[LONG[@SD[sMapStiStd]],
             LONG POINTER TO LONG POINTER]^ _ LOOPHOLE[SSTraps.MapStiStd, LONG POINTER];

END.