home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / fd2inline-1.0-bin.lha / include / inline / exec.h < prev    next >
Encoding:
C/C++ Source or Header  |  1996-10-12  |  14.6 KB  |  485 lines
  1. #ifndef _INLINE_EXEC_H
  2. #define _INLINE_EXEC_H
  3.  
  4. #ifndef __INLINE_MACROS_H
  5. #include <inline/macros.h>
  6. #endif
  7.  
  8. #ifndef EXEC_BASE_NAME
  9. #define EXEC_BASE_NAME SysBase
  10. #endif
  11.  
  12. #define AbortIO(ioRequest) \
  13.     LP1NR(0x1e0, AbortIO, struct IORequest *, ioRequest, a1, \
  14.     , EXEC_BASE_NAME)
  15.  
  16. #define AddDevice(device) \
  17.     LP1NR(0x1b0, AddDevice, struct Device *, device, a1, \
  18.     , EXEC_BASE_NAME)
  19.  
  20. #define AddHead(list, node) \
  21.     LP2NR(0xf0, AddHead, struct List *, list, a0, struct Node *, node, a1, \
  22.     , EXEC_BASE_NAME)
  23.  
  24. #define AddIntServer(intNumber, interrupt) \
  25.     LP2NR(0xa8, AddIntServer, long, intNumber, d0, struct Interrupt *, interrupt, a1, \
  26.     , EXEC_BASE_NAME)
  27.  
  28. #define AddLibrary(library) \
  29.     LP1NR(0x18c, AddLibrary, struct Library *, library, a1, \
  30.     , EXEC_BASE_NAME)
  31.  
  32. #define AddMemHandler(memhand) \
  33.     LP1NR(0x306, AddMemHandler, struct Interrupt *, memhand, a1, \
  34.     , EXEC_BASE_NAME)
  35.  
  36. #define AddMemList(size, attributes, pri, base, name) \
  37.     LP5NR(0x26a, AddMemList, unsigned long, size, d0, unsigned long, attributes, d1, long, pri, d2, APTR, base, a0, UBYTE *, name, a1, \
  38.     , EXEC_BASE_NAME)
  39.  
  40. #define AddPort(port) \
  41.     LP1NR(0x162, AddPort, struct MsgPort *, port, a1, \
  42.     , EXEC_BASE_NAME)
  43.  
  44. #define AddResource(resource) \
  45.     LP1NR(0x1e6, AddResource, APTR, resource, a1, \
  46.     , EXEC_BASE_NAME)
  47.  
  48. #define AddSemaphore(sigSem) \
  49.     LP1NR(0x258, AddSemaphore, struct SignalSemaphore *, sigSem, a1, \
  50.     , EXEC_BASE_NAME)
  51.  
  52. #define AddTail(list, node) \
  53.     LP2NR(0xf6, AddTail, struct List *, list, a0, struct Node *, node, a1, \
  54.     , EXEC_BASE_NAME)
  55.  
  56. #define AddTask(task, initPC, finalPC) \
  57.     LP3(0x11a, APTR, AddTask, struct Task *, task, a1, APTR, initPC, a2, APTR, finalPC, a3, \
  58.     , EXEC_BASE_NAME)
  59.  
  60. #define Alert(alertNum) \
  61.     LP1NR(0x6c, Alert, unsigned long, alertNum, d7, \
  62.     , EXEC_BASE_NAME)
  63.  
  64. #define AllocAbs(byteSize, location) \
  65.     LP2(0xcc, APTR, AllocAbs, unsigned long, byteSize, d0, APTR, location, a1, \
  66.     , EXEC_BASE_NAME)
  67.  
  68. #define AllocEntry(entry) \
  69.     LP1(0xde, struct MemList *, AllocEntry, struct MemList *, entry, a0, \
  70.     , EXEC_BASE_NAME)
  71.  
  72. #define AllocMem(byteSize, requirements) \
  73.     LP2(0xc6, APTR, AllocMem, unsigned long, byteSize, d0, unsigned long, requirements, d1, \
  74.     , EXEC_BASE_NAME)
  75.  
  76. #define AllocPooled(poolHeader, memSize) \
  77.     LP2(0x2c4, APTR, AllocPooled, APTR, poolHeader, a0, unsigned long, memSize, d0, \
  78.     , EXEC_BASE_NAME)
  79.  
  80. #define AllocSignal(signalNum) \
  81.     LP1(0x14a, BYTE, AllocSignal, long, signalNum, d0, \
  82.     , EXEC_BASE_NAME)
  83.  
  84. #define AllocTrap(trapNum) \
  85.     LP1(0x156, LONG, AllocTrap, long, trapNum, d0, \
  86.     , EXEC_BASE_NAME)
  87.  
  88. #define AllocVec(byteSize, requirements) \
  89.     LP2(0x2ac, APTR, AllocVec, unsigned long, byteSize, d0, unsigned long, requirements, d1, \
  90.     , EXEC_BASE_NAME)
  91.  
  92. #define Allocate(freeList, byteSize) \
  93.     LP2(0xba, APTR, Allocate, struct MemHeader *, freeList, a0, unsigned long, byteSize, d0, \
  94.     , EXEC_BASE_NAME)
  95.  
  96. #define AttemptSemaphore(sigSem) \
  97.     LP1(0x240, ULONG, AttemptSemaphore, struct SignalSemaphore *, sigSem, a0, \
  98.     , EXEC_BASE_NAME)
  99.  
  100. #define AttemptSemaphoreShared(sigSem) \
  101.     LP1(0x2d0, ULONG, AttemptSemaphoreShared, struct SignalSemaphore *, sigSem, a0, \
  102.     , EXEC_BASE_NAME)
  103.  
  104. #define AvailMem(requirements) \
  105.     LP1(0xd8, ULONG, AvailMem, unsigned long, requirements, d1, \
  106.     , EXEC_BASE_NAME)
  107.  
  108. #define CacheClearE(address, length, caches) \
  109.     LP3NR(0x282, CacheClearE, APTR, address, a0, unsigned long, length, d0, unsigned long, caches, d1, \
  110.     , EXEC_BASE_NAME)
  111.  
  112. #define CacheClearU() \
  113.     LP0NR(0x27c, CacheClearU, \
  114.     , EXEC_BASE_NAME)
  115.  
  116. #define CacheControl(cacheBits, cacheMask) \
  117.     LP2(0x288, ULONG, CacheControl, unsigned long, cacheBits, d0, unsigned long, cacheMask, d1, \
  118.     , EXEC_BASE_NAME)
  119.  
  120. #define CachePostDMA(address, length, flags) \
  121.     LP3NR(0x300, CachePostDMA, APTR, address, a0, ULONG *, length, a1, unsigned long, flags, d0, \
  122.     , EXEC_BASE_NAME)
  123.  
  124. #define CachePreDMA(address, length, flags) \
  125.     LP3(0x2fa, APTR, CachePreDMA, APTR, address, a0, ULONG *, length, a1, unsigned long, flags, d0, \
  126.     , EXEC_BASE_NAME)
  127.  
  128. #define Cause(interrupt) \
  129.     LP1NR(0xb4, Cause, struct Interrupt *, interrupt, a1, \
  130.     , EXEC_BASE_NAME)
  131.  
  132. #define CheckIO(ioRequest) \
  133.     LP1(0x1d4, struct IORequest *, CheckIO, struct IORequest *, ioRequest, a1, \
  134.     , EXEC_BASE_NAME)
  135.  
  136. #define ChildFree(tid) \
  137.     LP1NR(0x2e2, ChildFree, APTR, tid, d0, \
  138.     , EXEC_BASE_NAME)
  139.  
  140. #define ChildOrphan(tid) \
  141.     LP1NR(0x2e8, ChildOrphan, APTR, tid, d0, \
  142.     , EXEC_BASE_NAME)
  143.  
  144. #define ChildStatus(tid) \
  145.     LP1NR(0x2ee, ChildStatus, APTR, tid, d0, \
  146.     , EXEC_BASE_NAME)
  147.  
  148. #define ChildWait(tid) \
  149.     LP1NR(0x2f4, ChildWait, APTR, tid, d0, \
  150.     , EXEC_BASE_NAME)
  151.  
  152. #define CloseDevice(ioRequest) \
  153.     LP1NR(0x1c2, CloseDevice, struct IORequest *, ioRequest, a1, \
  154.     , EXEC_BASE_NAME)
  155.  
  156. #define CloseLibrary(library) \
  157.     LP1NR(0x19e, CloseLibrary, struct Library *, library, a1, \
  158.     , EXEC_BASE_NAME)
  159.  
  160. #define ColdReboot() \
  161.     LP0NR(0x2d6, ColdReboot, \
  162.     , EXEC_BASE_NAME)
  163.  
  164. #define CopyMem(source, dest, size) \
  165.     LP3NR(0x270, CopyMem, APTR, source, a0, APTR, dest, a1, unsigned long, size, d0, \
  166.     , EXEC_BASE_NAME)
  167.  
  168. #define CopyMemQuick(source, dest, size) \
  169.     LP3NR(0x276, CopyMemQuick, APTR, source, a0, APTR, dest, a1, unsigned long, size, d0, \
  170.     , EXEC_BASE_NAME)
  171.  
  172. #define CreateIORequest(port, size) \
  173.     LP2(0x28e, APTR, CreateIORequest, struct MsgPort *, port, a0, unsigned long, size, d0, \
  174.     , EXEC_BASE_NAME)
  175.  
  176. #define CreateMsgPort() \
  177.     LP0(0x29a, struct MsgPort *, CreateMsgPort, \
  178.     , EXEC_BASE_NAME)
  179.  
  180. #define CreatePool(requirements, puddleSize, threshSize) \
  181.     LP3(0x2b8, APTR, CreatePool, unsigned long, requirements, d0, unsigned long, puddleSize, d1, unsigned long, threshSize, d2, \
  182.     , EXEC_BASE_NAME)
  183.  
  184. #define Deallocate(freeList, memoryBlock, byteSize) \
  185.     LP3NR(0xc0, Deallocate, struct MemHeader *, freeList, a0, APTR, memoryBlock, a1, unsigned long, byteSize, d0, \
  186.     , EXEC_BASE_NAME)
  187.  
  188. #define Debug(flags) \
  189.     LP1NR(0x72, Debug, unsigned long, flags, d0, \
  190.     , EXEC_BASE_NAME)
  191.  
  192. #define DeleteIORequest(iorequest) \
  193.     LP1NR(0x294, DeleteIORequest, APTR, iorequest, a0, \
  194.     , EXEC_BASE_NAME)
  195.  
  196. #define DeleteMsgPort(port) \
  197.     LP1NR(0x2a0, DeleteMsgPort, struct MsgPort *, port, a0, \
  198.     , EXEC_BASE_NAME)
  199.  
  200. #define DeletePool(poolHeader) \
  201.     LP1NR(0x2be, DeletePool, APTR, poolHeader, a0, \
  202.     , EXEC_BASE_NAME)
  203.  
  204. #define Disable() \
  205.     LP0NR(0x78, Disable, \
  206.     , EXEC_BASE_NAME)
  207.  
  208. #define DoIO(ioRequest) \
  209.     LP1(0x1c8, BYTE, DoIO, struct IORequest *, ioRequest, a1, \
  210.     , EXEC_BASE_NAME)
  211.  
  212. #define Enable() \
  213.     LP0NR(0x7e, Enable, \
  214.     , EXEC_BASE_NAME)
  215.  
  216. #define Enqueue(list, node) \
  217.     LP2NR(0x10e, Enqueue, struct List *, list, a0, struct Node *, node, a1, \
  218.     , EXEC_BASE_NAME)
  219.  
  220. #define FindName(list, name) \
  221.     LP2(0x114, struct Node *, FindName, struct List *, list, a0, UBYTE *, name, a1, \
  222.     , EXEC_BASE_NAME)
  223.  
  224. #define FindPort(name) \
  225.     LP1(0x186, struct MsgPort *, FindPort, UBYTE *, name, a1, \
  226.     , EXEC_BASE_NAME)
  227.  
  228. #define FindResident(name) \
  229.     LP1(0x60, struct Resident *, FindResident, UBYTE *, name, a1, \
  230.     , EXEC_BASE_NAME)
  231.  
  232. #define FindSemaphore(sigSem) \
  233.     LP1(0x252, struct SignalSemaphore *, FindSemaphore, UBYTE *, sigSem, a1, \
  234.     , EXEC_BASE_NAME)
  235.  
  236. #define FindTask(name) \
  237.     LP1(0x126, struct Task *, FindTask, UBYTE *, name, a1, \
  238.     , EXEC_BASE_NAME)
  239.  
  240. #define Forbid() \
  241.     LP0NR(0x84, Forbid, \
  242.     , EXEC_BASE_NAME)
  243.  
  244. #define FreeEntry(entry) \
  245.     LP1NR(0xe4, FreeEntry, struct MemList *, entry, a0, \
  246.     , EXEC_BASE_NAME)
  247.  
  248. #define FreeMem(memoryBlock, byteSize) \
  249.     LP2NR(0xd2, FreeMem, APTR, memoryBlock, a1, unsigned long, byteSize, d0, \
  250.     , EXEC_BASE_NAME)
  251.  
  252. #define FreePooled(poolHeader, memory, memSize) \
  253.     LP3NR(0x2ca, FreePooled, APTR, poolHeader, a0, APTR, memory, a1, unsigned long, memSize, d0, \
  254.     , EXEC_BASE_NAME)
  255.  
  256. #define FreeSignal(signalNum) \
  257.     LP1NR(0x150, FreeSignal, long, signalNum, d0, \
  258.     , EXEC_BASE_NAME)
  259.  
  260. #define FreeTrap(trapNum) \
  261.     LP1NR(0x15c, FreeTrap, long, trapNum, d0, \
  262.     , EXEC_BASE_NAME)
  263.  
  264. #define FreeVec(memoryBlock) \
  265.     LP1NR(0x2b2, FreeVec, APTR, memoryBlock, a1, \
  266.     , EXEC_BASE_NAME)
  267.  
  268. #define GetCC() \
  269.     LP0(0x210, ULONG, GetCC, \
  270.     , EXEC_BASE_NAME)
  271.  
  272. #define GetMsg(port) \
  273.     LP1(0x174, struct Message *, GetMsg, struct MsgPort *, port, a0, \
  274.     , EXEC_BASE_NAME)
  275.  
  276. #define InitCode(startClass, version) \
  277.     LP2NR(0x48, InitCode, unsigned long, startClass, d0, unsigned long, version, d1, \
  278.     , EXEC_BASE_NAME)
  279.  
  280. #define InitResident(resident, segList) \
  281.     LP2(0x66, APTR, InitResident, struct Resident *, resident, a1, unsigned long, segList, d1, \
  282.     , EXEC_BASE_NAME)
  283.  
  284. #define InitSemaphore(sigSem) \
  285.     LP1NR(0x22e, InitSemaphore, struct SignalSemaphore *, sigSem, a0, \
  286.     , EXEC_BASE_NAME)
  287.  
  288. #define InitStruct(initTable, memory, size) \
  289.     LP3NR(0x4e, InitStruct, APTR, initTable, a1, APTR, memory, a2, unsigned long, size, d0, \
  290.     , EXEC_BASE_NAME)
  291.  
  292. #define Insert(list, node, pred) \
  293.     LP3NR(0xea, Insert, struct List *, list, a0, struct Node *, node, a1, struct Node *, pred, a2, \
  294.     , EXEC_BASE_NAME)
  295.  
  296. #define MakeFunctions(target, functionArray, funcDispBase) \
  297.     LP3NR(0x5a, MakeFunctions, APTR, target, a0, APTR, functionArray, a1, unsigned long, funcDispBase, a2, \
  298.     , EXEC_BASE_NAME)
  299.  
  300. #define MakeLibrary(funcInit, structInit, libInit, dataSize, segList) \
  301.     LP5FP(0x54, struct Library *, MakeLibrary, APTR, funcInit, a0, APTR, structInit, a1, __fpt, libInit, a2, unsigned long, dataSize, d0, unsigned long, segList, d1, \
  302.     , EXEC_BASE_NAME, unsigned long (*__fpt)())
  303.  
  304. #define ObtainQuickVector(interruptCode) \
  305.     LP1(0x312, ULONG, ObtainQuickVector, APTR, interruptCode, a0, \
  306.     , EXEC_BASE_NAME)
  307.  
  308. #define ObtainSemaphore(sigSem) \
  309.     LP1NR(0x234, ObtainSemaphore, struct SignalSemaphore *, sigSem, a0, \
  310.     , EXEC_BASE_NAME)
  311.  
  312. #define ObtainSemaphoreList(sigSem) \
  313.     LP1NR(0x246, ObtainSemaphoreList, struct List *, sigSem, a0, \
  314.     , EXEC_BASE_NAME)
  315.  
  316. #define ObtainSemaphoreShared(sigSem) \
  317.     LP1NR(0x2a6, ObtainSemaphoreShared, struct SignalSemaphore *, sigSem, a0, \
  318.     , EXEC_BASE_NAME)
  319.  
  320. #define OldOpenLibrary(libName) \
  321.     LP1(0x198, struct Library *, OldOpenLibrary, UBYTE *, libName, a1, \
  322.     , EXEC_BASE_NAME)
  323.  
  324. #define OpenDevice(devName, unit, ioRequest, flags) \
  325.     LP4(0x1bc, BYTE, OpenDevice, UBYTE *, devName, a0, unsigned long, unit, d0, struct IORequest *, ioRequest, a1, unsigned long, flags, d1, \
  326.     , EXEC_BASE_NAME)
  327.  
  328. #define OpenLibrary(libName, version) \
  329.     LP2(0x228, struct Library *, OpenLibrary, UBYTE *, libName, a1, unsigned long, version, d0, \
  330.     , EXEC_BASE_NAME)
  331.  
  332. #define OpenResource(resName) \
  333.     LP1(0x1f2, APTR, OpenResource, UBYTE *, resName, a1, \
  334.     , EXEC_BASE_NAME)
  335.  
  336. #define Permit() \
  337.     LP0NR(0x8a, Permit, \
  338.     , EXEC_BASE_NAME)
  339.  
  340. #define Procure(sigSem, bidMsg) \
  341.     LP2(0x21c, ULONG, Procure, struct SignalSemaphore *, sigSem, a0, struct SemaphoreMessage *, bidMsg, a1, \
  342.     , EXEC_BASE_NAME)
  343.  
  344. #define PutMsg(port, message) \
  345.     LP2NR(0x16e, PutMsg, struct MsgPort *, port, a0, struct Message *, message, a1, \
  346.     , EXEC_BASE_NAME)
  347.  
  348. #define RawDoFmt(formatString, dataStream, putChProc, putChData) \
  349.     LP4FP(0x20a, APTR, RawDoFmt, UBYTE *, formatString, a0, APTR, dataStream, a1, __fpt, putChProc, a2, APTR, putChData, a3, \
  350.     , EXEC_BASE_NAME, void (*__fpt)())
  351.  
  352. #define ReleaseSemaphore(sigSem) \
  353.     LP1NR(0x23a, ReleaseSemaphore, struct SignalSemaphore *, sigSem, a0, \
  354.     , EXEC_BASE_NAME)
  355.  
  356. #define ReleaseSemaphoreList(sigSem) \
  357.     LP1NR(0x24c, ReleaseSemaphoreList, struct List *, sigSem, a0, \
  358.     , EXEC_BASE_NAME)
  359.  
  360. #define RemDevice(device) \
  361.     LP1NR(0x1b6, RemDevice, struct Device *, device, a1, \
  362.     , EXEC_BASE_NAME)
  363.  
  364. #define RemHead(list) \
  365.     LP1(0x102, struct Node *, RemHead, struct List *, list, a0, \
  366.     , EXEC_BASE_NAME)
  367.  
  368. #define RemIntServer(intNumber, interrupt) \
  369.     LP2NR(0xae, RemIntServer, long, intNumber, d0, struct Interrupt *, interrupt, a1, \
  370.     , EXEC_BASE_NAME)
  371.  
  372. #define RemLibrary(library) \
  373.     LP1NR(0x192, RemLibrary, struct Library *, library, a1, \
  374.     , EXEC_BASE_NAME)
  375.  
  376. #define RemMemHandler(memhand) \
  377.     LP1NR(0x30c, RemMemHandler, struct Interrupt *, memhand, a1, \
  378.     , EXEC_BASE_NAME)
  379.  
  380. #define RemPort(port) \
  381.     LP1NR(0x168, RemPort, struct MsgPort *, port, a1, \
  382.     , EXEC_BASE_NAME)
  383.  
  384. #define RemResource(resource) \
  385.     LP1NR(0x1ec, RemResource, APTR, resource, a1, \
  386.     , EXEC_BASE_NAME)
  387.  
  388. #define RemSemaphore(sigSem) \
  389.     LP1NR(0x25e, RemSemaphore, struct SignalSemaphore *, sigSem, a1, \
  390.     , EXEC_BASE_NAME)
  391.  
  392. #define RemTail(list) \
  393.     LP1(0x108, struct Node *, RemTail, struct List *, list, a0, \
  394.     , EXEC_BASE_NAME)
  395.  
  396. #define RemTask(task) \
  397.     LP1NR(0x120, RemTask, struct Task *, task, a1, \
  398.     , EXEC_BASE_NAME)
  399.  
  400. #define Remove(node) \
  401.     LP1NR(0xfc, Remove, struct Node *, node, a1, \
  402.     , EXEC_BASE_NAME)
  403.  
  404. #define ReplyMsg(message) \
  405.     LP1NR(0x17a, ReplyMsg, struct Message *, message, a1, \
  406.     , EXEC_BASE_NAME)
  407.  
  408. #define SendIO(ioRequest) \
  409.     LP1NR(0x1ce, SendIO, struct IORequest *, ioRequest, a1, \
  410.     , EXEC_BASE_NAME)
  411.  
  412. #define SetExcept(newSignals, signalSet) \
  413.     LP2(0x138, ULONG, SetExcept, unsigned long, newSignals, d0, unsigned long, signalSet, d1, \
  414.     , EXEC_BASE_NAME)
  415.  
  416. #define SetFunction(library, funcOffset, newFunction) \
  417.     LP3FP(0x1a4, APTR, SetFunction, struct Library *, library, a1, long, funcOffset, a0, __fpt, newFunction, d0, \
  418.     , EXEC_BASE_NAME, unsigned long (*__fpt)())
  419.  
  420. #define SetIntVector(intNumber, interrupt) \
  421.     LP2(0xa2, struct Interrupt *, SetIntVector, long, intNumber, d0, struct Interrupt *, interrupt, a1, \
  422.     , EXEC_BASE_NAME)
  423.  
  424. #define SetSR(newSR, mask) \
  425.     LP2(0x90, ULONG, SetSR, unsigned long, newSR, d0, unsigned long, mask, d1, \
  426.     , EXEC_BASE_NAME)
  427.  
  428. #define SetSignal(newSignals, signalSet) \
  429.     LP2(0x132, ULONG, SetSignal, unsigned long, newSignals, d0, unsigned long, signalSet, d1, \
  430.     , EXEC_BASE_NAME)
  431.  
  432. #define SetTaskPri(task, priority) \
  433.     LP2(0x12c, BYTE, SetTaskPri, struct Task *, task, a1, long, priority, d0, \
  434.     , EXEC_BASE_NAME)
  435.  
  436. #define Signal(task, signalSet) \
  437.     LP2NR(0x144, Signal, struct Task *, task, a1, unsigned long, signalSet, d0, \
  438.     , EXEC_BASE_NAME)
  439.  
  440. #define StackSwap(newStack) \
  441.     LP1NR(0x2dc, StackSwap, struct StackSwapStruct *, newStack, a0, \
  442.     , EXEC_BASE_NAME)
  443.  
  444. #define SumKickData() \
  445.     LP0(0x264, ULONG, SumKickData, \
  446.     , EXEC_BASE_NAME)
  447.  
  448. #define SumLibrary(library) \
  449.     LP1NR(0x1aa, SumLibrary, struct Library *, library, a1, \
  450.     , EXEC_BASE_NAME)
  451.  
  452. #define SuperState() \
  453.     LP0(0x96, APTR, SuperState, \
  454.     , EXEC_BASE_NAME)
  455.  
  456. #define Supervisor(userFunction) \
  457.     LP1A5FP(0x1e, ULONG, Supervisor, __fpt, userFunction, d7, \
  458.     , EXEC_BASE_NAME, unsigned long (*__fpt)())
  459.  
  460. #define TypeOfMem(address) \
  461.     LP1(0x216, ULONG, TypeOfMem, APTR, address, a1, \
  462.     , EXEC_BASE_NAME)
  463.  
  464. #define UserState(sysStack) \
  465.     LP1NR(0x9c, UserState, APTR, sysStack, d0, \
  466.     , EXEC_BASE_NAME)
  467.  
  468. #define Vacate(sigSem, bidMsg) \
  469.     LP2NR(0x222, Vacate, struct SignalSemaphore *, sigSem, a0, struct SemaphoreMessage *, bidMsg, a1, \
  470.     , EXEC_BASE_NAME)
  471.  
  472. #define Wait(signalSet) \
  473.     LP1(0x13e, ULONG, Wait, unsigned long, signalSet, d0, \
  474.     , EXEC_BASE_NAME)
  475.  
  476. #define WaitIO(ioRequest) \
  477.     LP1(0x1da, BYTE, WaitIO, struct IORequest *, ioRequest, a1, \
  478.     , EXEC_BASE_NAME)
  479.  
  480. #define WaitPort(port) \
  481.     LP1(0x180, struct Message *, WaitPort, struct MsgPort *, port, a0, \
  482.     , EXEC_BASE_NAME)
  483.  
  484. #endif /* _INLINE_EXEC_H */
  485.