home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Misc / DC-POS24.LZX / pOS / pOSxA.lzx / pOSxA / clib / exec_protos.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-03-12  |  11.6 KB  |  407 lines
  1. #ifndef __INC_POSA_CLIB_EXEC_PROTOS_C
  2. #define __INC_POSA_CLIB_EXEC_PROTOS_C
  3. /*******************************************************************
  4.  $CRT 17 Mar 1996 : hb
  5.  
  6.  $AUT Holger Burkarth
  7.  $DAT >>exec_protos.c<<   31 Jan 1997    15:15:09 - (C) ProDAD
  8. *******************************************************************/
  9. #pragma -
  10.  
  11. #define NOMYDEBUG
  12.  
  13. #include <exec/types.h>
  14.  
  15. #define EXEC_TASKS_H
  16.  
  17. #include <p:pExec/Types.h>
  18. #include <p:pExec/Memory.h>
  19. //#undef pOS_CPP
  20. #include <p:proto/pExec2.h>
  21.  
  22.  
  23.  
  24. // mcpp:cppc -c ci:_Projekte/pOSxA/clib/exec_protos.c -pc
  25.  
  26.  
  27.  
  28. #pragma -
  29.  
  30. struct Library *MakeLibrary(APTR funcInit,APTR structInit,
  31.   ULONG (*libInit)(),unsigned long dataSize,unsigned long segList)
  32.   {  return((APTR) pOS_MakeLibrary(funcInit,structInit,(APTR)libInit,dataSize,(APTR)segList) ); }
  33.  
  34. void MakeFunctions( APTR target, APTR functionArray,unsigned long funcDispBase )
  35.   {  pOS_MakeFunctions(target,functionArray,(APTR)funcDispBase,-1); }
  36.  
  37. struct Resident *FindResident( UBYTE *name )
  38.   {   return((APTR) pOS_FindResident((CHAR*)name)); }
  39.  
  40. APTR InitResident( struct Resident *resident, unsigned long segList )
  41.   {   return( pOS_InitResident((APTR)resident,(APTR)segList)); }
  42.  
  43. void Alert( unsigned long alertNum)
  44.   { pOS_DisplayAlert(alertNum); }
  45.  
  46. void Debug( unsigned long flags );
  47.  
  48. void Disable( void )
  49.   {pOS_ForbidIRQ();}
  50.  
  51. void Enable( void )
  52.   {pOS_PermitIRQ();}
  53.  
  54. void Forbid( void )
  55.   {pOS_ForbidSchedul();}
  56.  
  57. void Permit( void )
  58.   {pOS_PermitSchedul();}
  59.  
  60.  
  61. struct Interrupt *SetIntVector( long intNumber, struct Interrupt *interrupt );
  62. void AddIntServer( long intNumber, struct Interrupt *interrupt );
  63. void RemIntServer( long intNumber, struct Interrupt *interrupt );
  64. void Cause( struct Interrupt *interrupt );
  65.  
  66. APTR Allocate( struct MemHeader *freeList, unsigned long byteSize )
  67.   { return( pOS_Allocate((APTR)freeList,byteSize)); }
  68.  
  69. void Deallocate( struct MemHeader *freeList, APTR memoryBlock,unsigned long byteSize )
  70.   {  pOS_Deallocate((APTR)freeList,memoryBlock,byteSize); }
  71.  
  72. APTR AllocMem( unsigned long byteSize, unsigned long requirements )
  73.   {  return( pOS_AllocMem(byteSize,requirements) );}
  74.  
  75. APTR AllocAbs( unsigned long byteSize, APTR location ) ;
  76.  
  77. void FreeMem( APTR memoryBlock, unsigned long byteSize )
  78.   {  pOS_FreeMem(memoryBlock,byteSize); }
  79.  
  80. ULONG AvailMem( unsigned long requirements )
  81.   {  return( pOS_AvailMem(requirements)); }
  82.  
  83. struct MemList *AllocEntry( struct MemList *entry )
  84.   {  return((APTR)pOS_AllocEntry(NULL,(APTR)entry)); }
  85.  
  86. void FreeEntry( struct MemList *entry )
  87.   { pOS_FreeEntry(NULL,(APTR)entry); }
  88.  
  89. void Insert( struct List *list, struct Node *node, struct Node *pred )
  90.   {  pOS_ListInsert((struct pOS_List*)list,(APTR)node,(APTR)pred); }
  91.  
  92. void AddHead( struct List *list, struct Node *node )
  93.   {  pOS_ListAddHead((struct pOS_List*)list,(APTR)node); }
  94.  
  95. void AddTail( struct List *list, struct Node *node )
  96.   { pOS_ListAddTail((struct pOS_List*)list,(APTR)node); }
  97.  
  98. void Remove( struct Node *node )
  99.   {  pOS_ListRemove((struct pOS_Node*)node); }
  100.  
  101. struct Node *RemHead( struct List *list )
  102.   { return((APTR)pOS_ListRemHead((struct pOS_List*)list)); }
  103.  
  104. struct Node *RemTail( struct List *list )
  105.   {  return((APTR)pOS_ListRemTail((struct pOS_List*)list)); }
  106.  
  107. void Enqueue( struct List *list, struct Node *node )
  108.   {  pOS_ListEnqueue((struct pOS_ExList*)list,(APTR)node);}
  109.  
  110. struct Node *FindName( struct List *list, UBYTE *name )
  111.   {  return((APTR)pOS_ListFindName((struct pOS_ExList*)list,name)); }
  112.  
  113. APTR AddTask( struct Task *task, APTR initPC, APTR finalPC )
  114.   {  return((APTR)pOS_AddTask((APTR)task,initPC,finalPC)); }
  115.  
  116. void RemTask( struct Task *task )
  117.   {  pOS_RemTask((APTR)task); }
  118.  
  119. struct Task *FindTask( UBYTE *name )
  120.   {  return((APTR)pOS_FindTask((CHAR*)name)); }
  121.  
  122. BYTE SetTaskPri( struct Task *task, long pri )
  123.   {  return(pOS_SetTaskPriority((APTR)task,pri)); }
  124.  
  125. ULONG SetSignal( unsigned long newSignals, unsigned long signalSet )
  126.   {  return(pOS_SetSignal(newSignals,signalSet)); }
  127.  
  128. ULONG SetExcept( unsigned long newSignals, unsigned long signalSet );
  129.  
  130. ULONG Wait( unsigned long signalSet )
  131.   {  return(pOS_WaitSignal(signalSet)); }
  132.  
  133. void Signal( struct Task *task, unsigned long signalSet )
  134.   {  pOS_SendSignal((APTR)task,signalSet); }
  135.  
  136. BYTE AllocSignal( long signalNum )
  137.   {  return(pOS_AllocSignal(signalNum));}
  138.  
  139. void FreeSignal( long signalNum )
  140.   {  pOS_FreeSignal(signalNum); }
  141.  
  142. LONG AllocTrap( long trapNum );
  143. void FreeTrap( long trapNum );
  144.  
  145. void AddPort( struct MsgPort *port )
  146.   {  pOS_AddPort((APTR)port); }
  147.  
  148. void RemPort( struct MsgPort *port )
  149.   {  pOS_RemPort((APTR)port); }
  150.  
  151. void PutMsg( struct MsgPort *port, struct Message *message )
  152.   {  pOS_PutMsg((APTR)port,(APTR)message); }
  153.  
  154. struct Message *GetMsg( struct MsgPort *port )
  155.   {  return((APTR)pOS_GetMsg((APTR)port)); }
  156.  
  157. void ReplyMsg( struct Message *message )
  158.   { pOS_ReplyMsg((APTR)message);}
  159.  
  160. struct Message *WaitPort( struct MsgPort *port )
  161.   { return((APTR)pOS_WaitPort((APTR)port));}
  162.  
  163. struct MsgPort *FindPort( UBYTE *name )
  164.   {  return((APTR)pOS_FindPort((CHAR*)name)); }
  165.  
  166. void AddLibrary( struct Library *library )
  167.   {  pOS_AddLibrary((APTR)library); }
  168.  
  169. void RemLibrary( struct Library *library )
  170.   {  pOS_RemLibrary((APTR)library); }
  171.  
  172. struct Library *OldOpenLibrary( UBYTE *libName )
  173.   { return((APTR)pOS_OpenLibrary((CHAR*)libName,0));}
  174.  
  175. void CloseLibrary( struct Library *library )
  176.   { pOS_CloseLibrary((APTR)library); }
  177.  
  178. void SumLibrary( struct Library *library )
  179.   { pOS_SumLibrary((APTR)library); }
  180.  
  181. void AddDevice( struct Device *device )
  182.   {  pOS_AddDevice((APTR)device);}
  183.  
  184. void RemDevice( struct Device *device )
  185.   {  pOS_RemDevice((APTR)device); }
  186.  
  187. BYTE OpenDevice(UBYTE *devName,unsigned long unit,struct IORequest *ioRequest,unsigned long flags)
  188.   {  return(pOS_OpenDevice((CHAR*)devName,unit,(APTR)ioRequest,flags,0)); }
  189.  
  190. void CloseDevice( struct IORequest *ioRequest )
  191.   {  pOS_CloseDevice((APTR)ioRequest); }
  192.  
  193. BYTE DoIO( struct IORequest *ioRequest )
  194.   {  return(pOS_DoIO((APTR)ioRequest)); }
  195.  
  196. void SendIO( struct IORequest *ioRequest )
  197.   {  pOS_SendIO((APTR)ioRequest); }
  198.  
  199. struct IORequest *CheckIO( struct IORequest *ioRequest )
  200.   {  return((APTR)pOS_CheckIO((APTR)ioRequest)); }
  201.  
  202. BYTE WaitIO( struct IORequest *ioRequest )
  203.   {  return(pOS_WaitIO((APTR)ioRequest)); }
  204.  
  205. void AbortIO( struct IORequest *ioRequest )
  206.   {  pOS_AbortIO((APTR)ioRequest); }
  207.  
  208. void AddResource( APTR resource )
  209.   {pOS_AddResource(resource);}
  210.  
  211. void RemResource( APTR resource )
  212.   {pOS_RemResource(resource);}
  213.  
  214. APTR OpenResource( UBYTE *resName )
  215.   {return(pOS_OpenResource((CHAR*)resName));}
  216.  
  217. APTR RawDoFmt( UBYTE *formatString, APTR dataStream, void (*putChProc)(),APTR putChData );
  218.  
  219. ULONG GetCC( void );
  220.  
  221. ULONG TypeOfMem(APTR address)
  222.   {return(pOS_TypeOfMem(address,0));}
  223.  
  224. VOID Procure( struct SignalSemaphore *sigSem,struct SemaphoreMessage *bidMsg)
  225.   { pOS_ProcureSemaphore((APTR)sigSem,(APTR)bidMsg); }
  226.  
  227. void Vacate( struct SignalSemaphore *sigSem,struct SemaphoreMessage *bidMsg )
  228.   { pOS_VacateSemaphore((APTR)sigSem,(APTR)bidMsg); }
  229.  
  230. struct Library *OpenLibrary( UBYTE *libName, unsigned long version )
  231.   { return((APTR)pOS_OpenLibrary((CHAR*)libName,version)); }
  232.  
  233. void InitSemaphore( struct SignalSemaphore *sigSem )
  234.   {  pOS_InitSemaphore((APTR)sigSem); }
  235.  
  236. void ObtainSemaphore( struct SignalSemaphore *sigSem )
  237.   {  pOS_ObtainSemaphore((APTR)sigSem); }
  238.  
  239. void ReleaseSemaphore( struct SignalSemaphore *sigSem )
  240.   {  pOS_ReleaseSemaphore((APTR)sigSem); }
  241.  
  242. ULONG AttemptSemaphore( struct SignalSemaphore *sigSem )
  243.   {  return(pOS_AttemptSemaphore((APTR)sigSem)); }
  244.  
  245. void ObtainSemaphoreList( struct List *sigSem )
  246.   { pOS_ObtainSemaphoreList((APTR)sigSem); }
  247.  
  248. void ReleaseSemaphoreList( struct List *sigSem )
  249.   { pOS_ReleaseSemaphoreList((APTR)sigSem); }
  250.  
  251. struct SignalSemaphore *FindSemaphore( UBYTE *sigSem )
  252.   { return((APTR)pOS_FindSemaphore((CHAR*)sigSem));}
  253.  
  254. void AddSemaphore( struct SignalSemaphore *sigSem )
  255.   { pOS_AddSemaphore((APTR)sigSem); }
  256.  
  257. void RemSemaphore( struct SignalSemaphore *sigSem )
  258.   { pOS_RemSemaphore((APTR)sigSem); }
  259.  
  260.  
  261. ULONG SumKickData( void );
  262.  
  263. void AddMemList( unsigned long size, unsigned long attributes, long pri,APTR base, UBYTE *name );
  264.  
  265. void CopyMem( APTR source, APTR dest, unsigned long size )
  266.   { pOS_CopyMem(source,dest,size);}
  267.  
  268. void CopyMemQuick( APTR source, APTR dest, unsigned long size )
  269.   {  pOS_CopyMem(source,dest,size); }
  270.  
  271. void CacheClearU( void )
  272.   { pOS_CacheClearU(); }
  273.  
  274. void CacheClearE( APTR address, unsigned long length, unsigned long caches )
  275.   { pOS_CacheClearE(address,length,caches); }
  276.  
  277. ULONG CacheControl( unsigned long cacheBits, unsigned long cacheMask )
  278.   { return(pOS_CacheControl(cacheBits,cacheMask)); }
  279.  
  280. APTR CreateIORequest( struct MsgPort *port, unsigned long size )
  281.   {  return(pOS_CreateIORequest((APTR)port,size)); }
  282.  
  283. void DeleteIORequest( APTR iorequest )
  284.   {  pOS_DeleteIORequest((APTR)iorequest); }
  285.  
  286. struct MsgPort *CreateMsgPort( void )
  287.   { return((APTR)pOS_CreatePort(0,0)); }
  288.  
  289. void DeleteMsgPort( struct MsgPort *port )
  290.   { pOS_DeletePort((APTR)port); }
  291.  
  292. void ObtainSemaphoreShared( struct SignalSemaphore *sigSem )
  293.   { pOS_ObtainSemaphoreShared((APTR)sigSem); }
  294.  
  295. APTR AllocVec( unsigned long byteSize, unsigned long requirements )
  296.   {  return(pOS_AllocVec(byteSize,requirements)); }
  297.  
  298. void FreeVec( APTR memoryBlock )
  299.   {  pOS_FreeVec(memoryBlock); }
  300.  
  301. APTR CreatePool( ULONG requirements, ULONG puddleSize,ULONG threshSize)
  302.   {
  303.     struct pOS_MemPool *MP=(struct pOS_MemPool*)pOS_AllocMem(sizeof(struct pOS_MemPool),MEMF_PUBLIC);
  304.     if(MP) {
  305.       pOS_InitMemPool(MP,puddleSize,requirements);
  306.     }
  307.     return((APTR)MP);
  308.   }
  309.  
  310. void DeletePool( APTR mp )
  311.   {
  312.     pOS_FreePoolAll( (struct pOS_MemPool*)mp );
  313.     pOS_FreeMem(mp,sizeof(struct pOS_MemPool));
  314.   }
  315.  
  316. APTR AllocPooled( APTR mp, unsigned long memSize )
  317.   {
  318.     /** MEMF_CLEAR => safety **/
  319.     return( pOS_AllocPoolMem((struct pOS_MemPool*)mp,memSize,MEMF_CLEAR) );
  320.   }
  321.  
  322. void FreePooled( APTR mp, APTR memory, unsigned long memSize )
  323.   {
  324.     pOS_FreePoolMem( (struct pOS_MemPool*)mp,memory,memSize);
  325.   }
  326.  
  327. ULONG AttemptSemaphoreShared( struct SignalSemaphore *sigSem );
  328.  
  329. void ColdReboot( void )
  330.   { pOS_ColdReboot(); }
  331.  
  332. void StackSwap( struct StackSwapStruct *newStack )
  333.   {pOS_StackSwap((APTR)newStack); }
  334.  
  335. void ChildFree( APTR tid );
  336. void ChildOrphan( APTR tid );
  337. void ChildStatus( APTR tid );
  338. void ChildWait( APTR tid );
  339.  
  340. APTR CachePreDMA( APTR address, ULONG *length, unsigned long flags );
  341. void CachePostDMA( APTR address, ULONG *length, unsigned long flags );
  342.  
  343. void AddMemHandler( struct Interrupt *memhand )
  344.   { pOS_AddMemHandler((APTR)memhand); }
  345.  
  346. void RemMemHandler( struct Interrupt *memhand )
  347.   { pOS_RemMemHandler((APTR)memhand); }
  348.  
  349. ULONG ObtainQuickVector( APTR interruptCode );
  350.  
  351.  
  352.  
  353.  
  354.  
  355.  
  356.  
  357.  
  358.  
  359.  
  360.  
  361.  
  362.  
  363.  
  364.  
  365. #ifdef __IGNORE_NOT_SUPPORTED__
  366.  
  367. ULONG AttemptSemaphoreShared( struct SignalSemaphore *sigSem )
  368. {return(0);}
  369.  
  370.  
  371.  
  372. void Debug( unsigned long flags )
  373. {}
  374. struct Interrupt *SetIntVector( long intNumber, struct Interrupt *interrupt )
  375. {return(0);}
  376. void AddIntServer( long intNumber, struct Interrupt *interrupt )
  377. {}
  378. void RemIntServer( long intNumber, struct Interrupt *interrupt )
  379. {}
  380. void Cause( struct Interrupt *interrupt )
  381. {}
  382. LONG AllocTrap( long trapNum )
  383. {return(0);}
  384. void FreeTrap( long trapNum );
  385. APTR RawDoFmt(UBYTE *formatString, APTR dataStream, void(*putChProc)(),APTR putChData);
  386. ULONG GetCC( void );
  387. ULONG SumKickData( void );
  388. void AddMemList(ULONG size,ULONG attributes, long pri,APTR base, UBYTE *name );
  389. void ChildFree( APTR tid );
  390. void ChildOrphan( APTR tid );
  391. void ChildStatus( APTR tid );
  392. void ChildWait( APTR tid );
  393. APTR CachePreDMA( APTR address, ULONG *length, unsigned long flags );
  394. void CachePostDMA( APTR address, ULONG *length, unsigned long flags );
  395. ULONG ObtainQuickVector( APTR interruptCode );
  396.  
  397. APTR SetFunction( struct Library *library, long funcOffset,unsigned long (*newFunction)() )
  398. {return(0);}
  399.  
  400.  
  401. #endif  /** __IGNORE_NOT_SUPPORTED__ **/
  402.  
  403.  
  404.  
  405.  
  406. #endif
  407.