home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / oper_sys / emerald / emrldsys.lha / Kernel / h / emkDefs.h < prev    next >
Encoding:
C/C++ Source or Header  |  1990-08-17  |  19.4 KB  |  692 lines
  1.  
  2. /*  C O P Y R I G H T   N O T I C E :                                     */
  3. /* Copyright 1986 Eric Jul and Norm Hutchinson.     May not be used for any  */
  4. /* purpose without written permission from the authors.              */
  5.  
  6. /*  Header file for internal kernel data structures                       */
  7.  
  8. /* Messages each consist of an Eden msg hdr and one or more socalled      */
  9. /* items.  Each item consists of a hdr field desribing the type and size  */
  10. /* of the item followed by the data of the item.  This organization       */
  11. /* allows multiple items to be sent in a single message, e.g., an         */
  12. /* request and one or more moves of parameters.                           */
  13. /* It also allows for easy piggybacking of other information.             */
  14.  
  15. #ifndef LMTYPES
  16. #include "Kernel/h/lmTypes.h"
  17. #endif LMTYPES
  18.  
  19. #ifndef map_h
  20. #include "Kernel/h/map.h"
  21. #endif  map_h
  22.  
  23. #ifndef set_h
  24. #include "Kernel/h/set.h"
  25. #endif
  26.  
  27. /************************************************************************/
  28. /*      Stacks are initially allocated STDSTACKSIZE bytes and           */
  29. /*      are allocated up to a maximum of DEFAULTMAXPROCESSSTACKSIZE     */
  30. /*      If this maximum is exceeded, the process is terminated.         */
  31. /************************************************************************/
  32.  
  33. #define DEFAULTMAXSTACKSIZE 10000           /* Max. overall total */
  34. #define STACKSAFETY         300             /* See note below */
  35. #define STDSTACKSIZE        600             /* Usual size */
  36. #define MINSTACKSIZE        200             /* Min. allocation allowed */
  37.  
  38. /* STACKSAFETY must NOT be decreased for two reasons:
  39.    1.   the compiler assumes that there always is room enough to call
  40.         another opertion without having to do a stack check.
  41.         This means that there should be about 20 - 40 bytes extra slop.
  42.    2.   UNIX bashes stuff onto the stack when signals occur.
  43.         Experiments have shown that 200 bytes of safety is INSUFFICIENT
  44.         An attempt has been made to avoid such stack bashing:
  45.         An alternate stack is used for signals, cf. sigstack(2), sigvec(2)
  46.         However, UNIX still bashes a few bytes above (== lower addresses)
  47.         the current stack top so a margin of some bytes is necessary
  48.         and one must consider ALL data beyound the stack top to
  49.         be invalid.  (This is a hard bug to find.)
  50.         Therefore, in theory, about 20 bytes of safety for UNIX signals
  51.         should suffices, but sure enough at some point a signal handler
  52.         was defined to run on the regular stack and wierd behaviour ensued.
  53.         To protect against any recurrence of such bugs, the stack safety
  54.         is defined here to be in excess of 200 bytes.
  55.         ANY REDUCTION in STACKSAFETY should be carefully considered and
  56.         is NOT recommended.
  57.         Thank you for your attention.
  58. */
  59.  
  60.  
  61.  
  62.  
  63.  
  64. /* Tags for inter-node items */
  65.  
  66. typedef enum {
  67.     InvalidITag,
  68.     InvokeITag,
  69.     ReplyITag,
  70.     RemoteLoadReqITag,
  71.     CodeTransferITag,
  72.     ParamTag,
  73.     ConfirmITag,
  74.     ShoutITag,
  75.     SearchITag,
  76.     ConfirmReplyITag,
  77.     ShoutReplyITag,
  78.     SearchReplyITag,
  79.     PingITag,
  80.     PongITag,
  81.     PingTimingITag,
  82.     PongTimingITag,
  83.     MoveITag,
  84.     MoveReplyITag,
  85.                         /* TT*ITag must be contiguous from TTFirst to TTLast*/
  86.     TTFirstITag,        /* This tag must be the first of the TT tags */
  87.     TTGODITag,          
  88.     TTSSODITag,
  89.     TTCodeODITag,
  90.     TTAbConITag,
  91.     TTGODataITag,
  92.     TTLOITag,
  93.     TTROITag,
  94.     TTMoveGODITag,
  95.     TTMoveSSODITag,
  96.     TTMoveCITag,
  97.     TTFetchGODITag,
  98.     TTCodeAddrITag,
  99.     TTInvokeITag,
  100.     TTIncomingIITag,
  101.     TTCondITag,
  102.     TTMoveCondITag,
  103.     TTLastITag,         /* Must be the last TT tag */
  104.     
  105.     LastITag            /* Must be the very last tag */
  106. } ITag;
  107.  
  108. #define MAXTAG ((int) LastITag)
  109.  
  110. typedef struct ItemHdr {
  111.     ITag                itemTag:8;
  112.     unsigned int        size:24;
  113. } ItemHdr, *ItemHdrPtr;
  114.  
  115. typedef HandlerPtr ItemHandlerPtr;
  116. typedef HandlerPtr GenericHandlerPtr;
  117.  
  118. typedef enum {
  119.     RefSent,
  120.     RefMoved
  121. } RefStatus;
  122.  
  123. typedef unsigned int MoveMask;
  124.  
  125. typedef struct InvokeReqItem {
  126.     ItemHdr         hdr;
  127.     OID             callerSSOID;
  128.     EmLocation      callerLoc;
  129.     OID             processOID;
  130.     OID             targetOID;
  131.     EmLocation      targetTryAtLoc;
  132.     OID             opOID;
  133.     int             opNumber;
  134.     ODTag           abConTag;
  135.     OID             abstractTypeOID;
  136.     OID             concreteTypeOID;
  137.     unsigned int    stackAvailable;
  138.     short int       argumentCount;
  139.     short int       resultCount;
  140.     MoveMask        resultMoveMask;
  141.     MoveMask        paramMoveMask;
  142.     /* Now the results and params */
  143. } InvokeReqItem, *InvokeReqItemPtr;
  144.  
  145. typedef enum {
  146.     INVOKEDONE,
  147.     INVOKEUNAVAILABLE,
  148.     INVOKEFAILED
  149. } InvokeResult;
  150.  
  151. typedef struct InvokeReplyItem {
  152.     ItemHdr         hdr;
  153.     OID             callerSSOID;
  154.     InvokeResult    result;
  155.     /* Now the results and params */
  156. } InvokeReplyItem, *InvokeReplyItemPtr;
  157.  
  158. typedef struct RemoteLoadReqItem {
  159.     ItemHdr         hdr;
  160.     OID             theOID;
  161. } RemoteLoadReqItem, *RemoteLoadReqItemPtr;
  162.  
  163. typedef struct TTGenericEntry { /* Generic */
  164.     ItemHdr         hdr;
  165.     ODP             oldODP;
  166.     ODTag           tag;
  167. } TTGenericEntry, *TTGenericEntryPtr;
  168.  
  169. typedef struct TTGODEntry {
  170.     ItemHdr         hdr;
  171.     ODP             oldODP;
  172.     ODTag           tag;
  173.     OID             ownOID;
  174.     EmLocation      ownLoc;
  175.     OID             myCodeOID;    
  176. } TTGODEntry;
  177.  
  178. typedef struct TTCEntry {
  179.     ItemHdr         hdr;
  180.     ODP             oldODP;
  181.     ODTag           tag;
  182.     OID             ownOID;
  183.     EmLocation      ownLoc;
  184. } TTCEntry;
  185.  
  186. typedef struct TTSSODEntry {
  187.     ItemHdr         hdr;
  188.     ODP             oldODP;
  189.     ODTag           tag;
  190.     OID             ownOID;
  191.     EmLocation      ownLoc;
  192.     OID             processOID;
  193. } TTSSODEntry;
  194.  
  195. typedef struct TTAbConEntry {
  196.     ItemHdr         hdr;
  197.     ODP             oldODP;
  198.     ODTag           tag;
  199.     OID             ATOID;
  200.     OID             restrictOID;
  201.     OID             CodeOID;
  202. } TTAbConEntry;
  203.  
  204. typedef struct TTLOEntry {
  205.     ItemHdr         hdr;
  206.     ODP             oldODP;
  207.     ODTag           tag;
  208.     /* and the rest of the data */
  209. } TTLOEntry;
  210.  
  211. typedef struct TTROEntry {
  212.     ItemHdr         hdr;
  213.     ODP             oldODP;
  214.     ODTag           tag;
  215.     /* and the rest of the data */
  216. } TTROEntry;
  217.  
  218. typedef struct TTMoveGODEntry {
  219.     ItemHdr         hdr;
  220.     ODP             oldODP;
  221.     ODTag           tag;
  222.     OID             ownOID;
  223.     EmLocation      ownLoc;
  224.     OID             myCodeOID;
  225.     GODataPtr       oldGODataPtr;
  226. } TTMoveGODEntry;
  227.  
  228. typedef struct TTMoveSSODEntry {
  229.     ItemHdr         hdr;
  230.     ODP             oldODP;
  231.     ODTag           tag;
  232.     OID             ownOID;
  233.     EmLocation      ownLoc;
  234.     OID             processOID;
  235.     SSPtr           oldSSPtr;
  236.     SSPtr           oldReadyQLink;
  237.     SSStatus        status;
  238.     int             availStack;
  239.     int             thisSegmentSize;
  240.     RegisterSave    regs;
  241.     Brand           resultBrand;
  242.     GenericPtr      rPtr;
  243.     GenericPtr      invokePtr;
  244.     /* and now the stack itself */
  245. } TTMoveSSODEntry;
  246.  
  247.  
  248. typedef struct TTMoveCEntry {
  249.     ItemHdr         hdr;
  250.     ODP             oldODP;
  251.     ODTag           tag;
  252.     OID             ownOID;
  253.     EmLocation      ownLoc;
  254. } TTMoveCEntry;
  255.  
  256. typedef struct TTFetchGODEntry {
  257.     ItemHdr         hdr;
  258.     ODP             oldODP;
  259.     ODTag           tag;
  260.     OID             ownOID;
  261.     EmLocation      ownLoc;
  262.     OID             myCodeOID;    
  263. } TTFetchGODEntry;
  264.  
  265. typedef struct TTCodeAddrEntry {
  266.     ItemHdr         hdr;
  267.     ODP             oldODP;         /* Actually the CodeAddr */
  268.     ODTag           dummyTag;       /* For TT compatibility only */
  269.     OID             theCodeOID;     /* OID of code OR NULL for kernel addr */
  270.     Offset          theOffset;      /* Offset from start of Code OR
  271.                                        kernel op number */
  272. } TTCodeAddrEntry;
  273.  
  274. typedef struct TTReqEntry {
  275.     ItemHdr         hdr;
  276.     ODP             oldODP;         /* Actually the addr of the Req */
  277.     ODTag           dummyTag;       /* For TT compatibility only */
  278.     /* Then the Req itself */       /* Variable sized */
  279. } TTReqEntry;
  280.  
  281. typedef struct TTInvokeReqEntry {
  282.     ItemHdr         hdr;
  283.     ODP             oldODP;         /* actually old Req Ptr */
  284.     OID             callerSSOID;
  285.     EmLocation      callerLoc;
  286.     short int       argumentCount;
  287.     short int       resultCount;
  288.     OID             processOID;
  289.     OID             targetOID;
  290.     EmLocation      targetTryAtLoc;
  291. } TTInvokeReqEntry;
  292.  
  293. typedef struct TTIncomingIReqEntry {
  294.     ItemHdr         hdr;
  295.     ODP             oldODP;         /* actually old Req Ptr */
  296.     OID             callerSSOID;
  297.     EmLocation      callerLoc;
  298.     short int       argumentCount;
  299.     short int       resultCount;
  300.     OID             processOID;
  301.     OID             targetOID;
  302.     EmLocation      targetTryAtLoc;
  303. } TTIncomingIReqEntry;
  304.  
  305. typedef struct TTCondEntry {
  306.     ItemHdr         hdr;
  307.     ODP             oldODP;
  308.     ODTag           tag;
  309.     OID             ownOID;
  310.     EmLocation      ownLoc;
  311. } TTCondEntry;
  312.  
  313. typedef struct TTMoveCondEntry {
  314.     ItemHdr         hdr;
  315.     ODP             oldODP;
  316.     ODTag           tag;
  317.     OID             ownOID;
  318.     EmLocation      ownLoc;
  319.     MonitorLockPtr  theLock;
  320.     SSPtr           theWaiting;
  321. } TTMoveCondEntry;
  322.  
  323. #ifdef NOTYET
  324. typedef struct TTVarEntry {
  325.     ItemHdr         hdr;
  326.     ODP             oldODP;
  327.     ODTag           tag;
  328.     OID             ownOID;
  329.     EmLocation      ownLoc;
  330.     OID             ATOID;
  331.     OID             restrictOID;
  332.     OID             CodeOID;
  333. } TTVarEntry;
  334. #endif NOTYET
  335.  
  336. typedef struct TTableEntry {
  337.     union {
  338.     TTGODEntry              GO;
  339.     TTSSODEntry             SS;
  340.         TTCEntry                C;
  341.     TTAbConEntry            AB;
  342.     TTLOEntry               LO;
  343.         TTROEntry               RO;
  344.         TTMoveGODEntry          MGOD;
  345.     TTMoveSSODEntry         MSS;
  346.         TTMoveCEntry            MC;
  347.         TTFetchGODEntry         FGOD;
  348.         TTCodeAddrEntry         CA;
  349.         TTReqEntry              REQ;
  350.         TTInvokeReqEntry        IR;
  351.         TTIncomingIReqEntry     IIR;
  352.         TTCondEntry             CD;
  353.     TTMoveCondEntry         MCD;
  354.     } TT;
  355. } TTableEntry, *TTableEntryPtr;
  356.  
  357. typedef struct TTableItem {
  358.     ItemHdr         hdr;
  359.     TTableEntry     entry;
  360. } TTable, *TTablePtr;
  361.  
  362. typedef struct CodeTransferItem {
  363.     ItemHdr         hdr;
  364.     /* Code dot-o file */
  365. } CodeTransferItem, *CodeTransferItemPtr;
  366.  
  367. typedef struct ParamItem {
  368.     ItemHdr         hdr;
  369.     /* Parameter area */
  370. } ParamItem, *ParamItemPtr;
  371.  
  372. typedef struct LocateInfo {
  373.     OID             theOID;
  374.     EmLocation      theLocation;
  375. } LocateInfo, *LocateInfoPtr;
  376.  
  377. typedef struct LocateItem {
  378.     ItemHdr         hdr;
  379.     LocateInfo      obj[1];
  380. } LocateItem, *LocateItemPtr;
  381.  
  382. typedef struct PingReqItem {
  383.     ItemHdr         hdr;
  384.     int             reqId;
  385.     int             pingLNN;
  386. } PingReqItem, *PingReqItemPtr;
  387.  
  388. typedef struct PongReqItem {
  389.     ItemHdr         hdr;
  390.     int             reqId;
  391.     int             pongLNN;
  392. } PongReqItem, *PongReqItemPtr;
  393.  
  394. typedef struct PingTimingReqItem {
  395.     ItemHdr         hdr;
  396.     int             reqId;
  397.     int             pingLNN;
  398. } PingTimingReqItem, *PingTimingReqItemPtr;
  399.  
  400. typedef struct PongTimingReqItem {
  401.     ItemHdr         hdr;
  402.     int             reqId;
  403.     int             pongLNN;
  404. } PongTimingReqItem, *PongTimingReqItemPtr;
  405.  
  406. typedef struct MoveItem {
  407.     ItemHdr         hdr;
  408.     ODP             oldODP;
  409. } MoveItem, *MoveItemPtr;
  410.  
  411. typedef struct MoveReplyItem {
  412.     ItemHdr         hdr;
  413. } MoveReplyItem, *MoveReplyItemPtr;
  414.  
  415. /************************************************************************/
  416.  
  417. typedef struct EmMsg {
  418.     MessageHeader   msgHdr;
  419.     ItemHdr         itemHdr;
  420.     char            data[MAXMESSAGESIZE];
  421. } EmMsg, *EmMsgPtr;
  422.  
  423. /************************************************************************/
  424. /*      Request data structures.                                        */
  425. /*      These structures are used internally in the Emerald kernel for  */
  426. /*      storing information about long-lived outstanding actions which  */
  427. /*      that require the kernel to give up the CPU during the request.  */
  428. /*      Examples include remote invocation, moves, and object location. */
  429. /*      Typically, the request data structures are tied to processes    */
  430. /*      and be found through the processes topmost stack segment.       */
  431. /************************************************************************/
  432.  
  433. typedef enum {
  434.     InvalidRTag,
  435.     InvokeRTag,
  436.     IncomingIRTag,
  437.     LocateRTag,
  438.     MoveRTag,
  439.     StackBreakRTag,
  440.     CompilerLoadRTag,
  441.     CodeLoadRTag,
  442.     CheatingLoadRTag,
  443.     InitiallyRTag,
  444.     ConformRTag,
  445.     ViewRTag,
  446.     IncomingMoveRTag,
  447.     OwnRTag,
  448.     CondWaitRTag,
  449.     MonWaitRTag,
  450.     TimedWaitRTag,
  451.  
  452.     LastRTag                /* Must be last RTag */
  453. } ReqTag;
  454.  
  455.  
  456. typedef struct ReqHdr {
  457.     ReqTag                  rTag;
  458.     struct GenericReq      *next;
  459.     GenericHandlerPtr       callBack;
  460.     int                     callBackData;
  461.     Map                     reqBy;
  462.     Map                     wantList;
  463. } ReqHdr, *ReqHdrPtr;
  464.  
  465.  
  466. typedef struct GenericReq {
  467.     ReqHdr                  hdr;
  468.     /* Request specific data */
  469. } GenericReq, *GenericReqPtr;
  470.  
  471. typedef enum {
  472.     IRLocatingTarget,
  473.     IRWaitingForInvokeReply,
  474.     IRLoadingCode,
  475.     IRCodeLoadDone
  476. } IRStatus;
  477.  
  478. typedef struct InvokeReq {
  479.     ReqHdr                  hdr;
  480.     IRStatus                status;
  481.     SSPtr                   requestor;      /* the invoker */
  482.     GODP                    targetGODP;     /* the target */
  483.     AbConPtr                theAbConPtr;    /* the abcon used */
  484.     InvokeReqItem           i;              /* the invoke data sent */
  485.     /* the following are only used during the processesing of the return */
  486.     CodeAddr                returnAddr;
  487.     Map                     m;
  488.     Map                     neededMap;
  489.     Set                     newSet;
  490.     AVariablePtr            paramAddr;      /* actually result address */
  491. } InvokeReq, *InvokeReqPtr;
  492.  
  493. typedef enum {
  494.     IHLoadingCode,
  495.     IHCodeLoadDone,
  496.     IHObjectNonFrozen
  497. } IHStatus;
  498.  
  499. typedef struct IncomingIReq {
  500.     ReqHdr                  hdr;
  501.     IHStatus                status;
  502.     InvokeReqItem           i;
  503.     SSPtr                   theProcess;
  504.     GODP                    targetGODP;
  505.     AbConPtr                theAbConPtr;
  506.     MoveMask            returnByMoveMask;
  507.     int                     opNumber;
  508.     Map                     m;
  509.     Map                     neededMap;
  510.     Set                     newSet;
  511.     AVariablePtr            paramAddr;
  512.     Set                     visitorSet;  /* contains OIDs of visiting objs */
  513. } IncomingIReq, *IncomingIReqPtr;
  514.  
  515. #define MAXNODENUMBER  250
  516. #define MAXNODENUMBER1 251 /* +1 version */
  517.  
  518. typedef enum {
  519.     Waiting,
  520.     WaitingForCodeLoad,
  521.     Confirming,
  522.     Shouting,
  523.     Searching
  524. } LocateStatus;
  525.  
  526. typedef struct LocateReq {
  527.     ReqHdr                  hdr;
  528.     LocateStatus            status;
  529.     OID                     theOID;
  530.     EmLocation              theLocation;
  531.     unsigned char           replyList[MAXNODENUMBER1];
  532.     SSPtr                   waiting;
  533.     int                     timerId;
  534. } LocateReq, *LocateReqPtr;
  535.  
  536. typedef enum {
  537.     IMLoadingCode,
  538.     IMCodeLoadDone
  539. } IMStatus;
  540.  
  541. typedef struct IncomingMoveReq {
  542.     ReqHdr                  hdr;
  543.     IMStatus                status;
  544.     ODP                     travellerODP;
  545.     EmLocation              targetLocation;
  546.     Map                     m;
  547.     Map                     neededMap;
  548.     Set                     newSet;
  549. } IncomingMoveReq, *IncomingMoveReqPtr;
  550.  
  551. typedef struct StackBreakReq {
  552.     ReqHdr                  hdr;
  553.     SSPtr                   oldSSPtr;
  554.     short int               argumentCount;
  555.     short int               resultCount;
  556. } StackBreakReq, *StackBreakReqPtr;
  557.  
  558. typedef enum {
  559.     Connected,
  560.     Loading,
  561.     Translating
  562. } CLoadStatus;
  563.  
  564. typedef struct CompilerLoadReq {
  565.     ReqHdr                  hdr;
  566.     int                     sock;
  567.     CLoadStatus             status;
  568.     OID                     createdCTOID;
  569.     GODP                    createdObj;
  570.     GODP                    theInStream, theOutStream;
  571.     SSPtr                   waitingRead, waitingWrite;
  572.     VectorPtr               vectorRead, vectorWrite;
  573.     int                     lengthRead, lengthWrite;
  574.     Boolean                 hangAround;
  575.     char            *MLPInfo;
  576. } CompilerLoadReq, *CompilerLoadReqPtr;
  577.  
  578. typedef struct sMLPMap {
  579.     int                     sock;
  580.     CLoadStatus             status;
  581.     OID                     createdCTOID;
  582.     GODP                    createdObj;
  583.     GODP                    theImport, theExport;
  584. } MLPMap, *MLPMapPtr;
  585.  
  586. typedef enum {
  587.     DoNotKnow,
  588.     FoundSomewhere,
  589.     LoadRequested,
  590.     Transferred,
  591.     Translated
  592. } LoadStatus;
  593.  
  594. typedef struct CodeLoadReq {
  595.     ReqHdr                  hdr;
  596.     OID                     theCodeOID;
  597.     LoadStatus              status;
  598. } CodeLoadReq, *CodeLoadReqPtr;
  599.  
  600. typedef struct CheatingLoadReq {
  601.     ReqHdr                  hdr;
  602.     OID                     theObjOID, theCodeOID;
  603.     LoadStatus              status;
  604. } CheatingLoadReq, *CheatingLoadReqPtr;
  605.  
  606. typedef struct InitiallyReq {
  607.     ReqHdr                  hdr;
  608.     GODP                    calleeGODP;
  609.     SSPtr                   theProcess;
  610.     int                     opNumber;
  611.     AbConPtr                theAbConPtr;
  612. } InitiallyReq, *InitiallyReqPtr;
  613.  
  614. typedef struct ConformReq {
  615.     ReqHdr                  hdr;
  616.     OID                     oid1, oid2;
  617.     SSPtr                   waiting;
  618. } ConformReq, *ConformReqPtr;
  619.  
  620. typedef struct ViewReq {
  621.     ReqHdr                  hdr;
  622.     OID                     restrictOID, newATOID;
  623.     OID                ctOID;
  624.     DataAddr            dataPtr;
  625.     SSPtr                   waiting;
  626. } ViewReq, *ViewReqPtr;
  627.  
  628. typedef struct OwnReq {
  629.     ReqHdr            hdr;
  630.     OID                codeOID, ATOID;
  631.     int                wanted;
  632.     SSPtr            waiting;
  633. } OwnReq, *OwnReqPtr;
  634.  
  635. #ifdef NOTUSEDYET
  636. /*
  637.  * CondWait requests are only used when the process waiting on a condition
  638.  * is to be sent across the net.  Waits are normally performed merely by
  639.  * putting a reference to the process into the condition and setting the
  640.  * process state to waiting -- no CondWaitReq is constructed since it is not
  641.  * needed in the local case -- it is optimized away.  On the other hand,
  642.  * when the process is to move then the CondWaitReq is constructed so that
  643.  * the necessary status information can be sent across the net and translated
  644.  * appropriately.
  645.  */
  646.  
  647. typedef struct CondWaitReq {            
  648.     ReqHdr                  hdr;
  649.     ODP                     condODP;
  650. } CondWaitReq, *CondWaitReqPtr;
  651.  
  652. /*
  653.  * MonWait -- the same comments as for CondWait apply here.
  654.  */
  655.  
  656. typedef struct MonReq {            
  657.     ReqHdr                  hdr;
  658.     ODP                     monODP;
  659. } MonReq, *MonReqPtr;
  660.  
  661. typedef struct TimedWaitReq {
  662.     ReqHdr                  hdr;
  663.     long                    remainSec;
  664.     long                    remainMicroSec;
  665. } TimedWaitReq, *TimedWaitReqPtr;
  666. #endif NOTUSEDYET
  667.  
  668. typedef union GeneralReq {
  669.     GenericReq          GReq;
  670.     InvokeReq           IReq;
  671.     IncomingIReq        IIReq;
  672.     LocateReq           LReq;
  673.     IncomingMoveReq     IMReq;
  674.     StackBreakReq       SBReq;
  675.     CompilerLoadReq     CLReq;
  676. } GeneralReq, *GeneralReqPtr;
  677.  
  678. extern GenericReqPtr MakeNewRequest();
  679. extern void FreeRequest();
  680.  
  681. extern void SetItemHandler();
  682.  
  683. /* mNewRequest takes the tag stripped of the RTag suffix */
  684. #ifdef lint
  685. #define mNewRequest(fKind) 0
  686. #else
  687. #define mNewRequest(fKind) ((fKind/**/ReqPtr) \
  688.     MakeNewRequest(fKind/**/RTag, sizeof(fKind/**/Req)))
  689. #endif lint
  690.  
  691. extern void DoCallBack();
  692.