#ifndef __INC_POSA_CLIB_EXEC_PROTOS_C
#define __INC_POSA_CLIB_EXEC_PROTOS_C
/*******************************************************************
 Includes Release 24
 (C) Copyright 1995-1997 proDAD
     All Rights Reserved

 $AUT Holger Burkarth
 $DAT >>exec_protos.c<<   31 Jan 1997    15:15:09 - (C) ProDAD
*******************************************************************/
#pragma -

#define NOMYDEBUG

#include <exec/types.h>

#define EXEC_TASKS_H

#include <pExec/Types.h>
#include <pExec/Memory.h>
#include <pProto/pExec2.h>



/* mcpp:cppc -c ci:_Projekte/pOSxA/clib/exec_protos.c -pc */



#pragma -

struct Library *MakeLibrary(APTR funcInit,APTR structInit,
  ULONG (*libInit)(),unsigned long dataSize,unsigned long segList)
  {  return((APTR) pOS_MakeLibrary(funcInit,structInit,(APTR)libInit,dataSize,(APTR)segList) ); }

void MakeFunctions( APTR target, APTR functionArray,unsigned long funcDispBase )
  {  pOS_MakeFunctions(target,functionArray,(APTR)funcDispBase,-1); }

struct Resident *FindResident( UBYTE *name )
  {   return((APTR) pOS_FindResident((CHAR*)name)); }

APTR InitResident( struct Resident *resident, unsigned long segList )
  {   return( pOS_InitResident((APTR)resident,(APTR)segList)); }

void Alert( unsigned long alertNum)
  { pOS_DisplayAlert(alertNum); }

void Debug( unsigned long flags );

void Disable( void )
  {pOS_ForbidIRQ();}

void Enable( void )
  {pOS_PermitIRQ();}

void Forbid( void )
  {pOS_ForbidSchedul();}

void Permit( void )
  {pOS_PermitSchedul();}


struct Interrupt *SetIntVector( long intNumber, struct Interrupt *interrupt );
void AddIntServer( long intNumber, struct Interrupt *interrupt );
void RemIntServer( long intNumber, struct Interrupt *interrupt );
void Cause( struct Interrupt *interrupt );

APTR Allocate( struct MemHeader *freeList, unsigned long byteSize )
  { return( pOS_Allocate((APTR)freeList,byteSize)); }

void Deallocate( struct MemHeader *freeList, APTR memoryBlock,unsigned long byteSize )
  {  pOS_Deallocate((APTR)freeList,memoryBlock,byteSize); }

APTR AllocMem( unsigned long byteSize, unsigned long requirements )
  {  return( pOS_AllocMem(byteSize,requirements) );}

APTR AllocAbs( unsigned long byteSize, APTR location ) ;

void FreeMem( APTR memoryBlock, unsigned long byteSize )
  {  pOS_FreeMem(memoryBlock,byteSize); }

ULONG AvailMem( unsigned long requirements )
  {  return( pOS_AvailMem(requirements)); }

struct MemList *AllocEntry( struct MemList *entry )
  {  return((APTR)pOS_AllocEntry(NULL,(APTR)entry)); }

void FreeEntry( struct MemList *entry )
  { pOS_FreeEntry(NULL,(APTR)entry); }

void Insert( struct List *list, struct Node *node, struct Node *pred )
  {  pOS_ListInsert((struct pOS_List*)list,(APTR)node,(APTR)pred); }

void AddHead( struct List *list, struct Node *node )
  {  pOS_ListAddHead((struct pOS_List*)list,(APTR)node); }

void AddTail( struct List *list, struct Node *node )
  { pOS_ListAddTail((struct pOS_List*)list,(APTR)node); }

void Remove( struct Node *node )
  {  pOS_ListRemove((struct pOS_Node*)node); }

struct Node *RemHead( struct List *list )
  { return((APTR)pOS_ListRemHead((struct pOS_List*)list)); }

struct Node *RemTail( struct List *list )
  {  return((APTR)pOS_ListRemTail((struct pOS_List*)list)); }

void Enqueue( struct List *list, struct Node *node )
  {  pOS_ListEnqueue((struct pOS_ExList*)list,(APTR)node);}

struct Node *FindName( struct List *list, UBYTE *name )
  {  return((APTR)pOS_ListFindName((struct pOS_ExList*)list,name)); }

APTR AddTask( struct Task *task, APTR initPC, APTR finalPC )
  {  return((APTR)pOS_AddTask((APTR)task,initPC,finalPC)); }

void RemTask( struct Task *task )
  {  pOS_RemTask((APTR)task); }

struct Task *FindTask( UBYTE *name )
  {  return((APTR)pOS_FindTask((CHAR*)name)); }

BYTE SetTaskPri( struct Task *task, long pri )
  {  return(pOS_SetTaskPriority((APTR)task,pri)); }

ULONG SetSignal( unsigned long newSignals, unsigned long signalSet )
  {  return(pOS_SetSignal(newSignals,signalSet)); }

ULONG SetExcept( unsigned long newSignals, unsigned long signalSet );

ULONG Wait( unsigned long signalSet )
  {  return(pOS_WaitSignal(signalSet)); }

void Signal( struct Task *task, unsigned long signalSet )
  {  pOS_SendSignal((APTR)task,signalSet); }

BYTE AllocSignal( long signalNum )
  {  return(pOS_AllocSignal(signalNum));}

void FreeSignal( long signalNum )
  {  pOS_FreeSignal(signalNum); }

LONG AllocTrap( long trapNum );
void FreeTrap( long trapNum );

void AddPort( struct MsgPort *port )
  {  pOS_AddPort((APTR)port); }

void RemPort( struct MsgPort *port )
  {  pOS_RemPort((APTR)port); }

void PutMsg( struct MsgPort *port, struct Message *message )
  {  pOS_PutMsg((APTR)port,(APTR)message); }

struct Message *GetMsg( struct MsgPort *port )
  {  return((APTR)pOS_GetMsg((APTR)port)); }

void ReplyMsg( struct Message *message )
  { pOS_ReplyMsg((APTR)message);}

struct Message *WaitPort( struct MsgPort *port )
  { return((APTR)pOS_WaitPort((APTR)port));}

struct MsgPort *FindPort( UBYTE *name )
  {  return((APTR)pOS_FindPort((CHAR*)name)); }

void AddLibrary( struct Library *library )
  {  pOS_AddLibrary((APTR)library); }

void RemLibrary( struct Library *library )
  {  pOS_RemLibrary((APTR)library); }

struct Library *OldOpenLibrary( UBYTE *libName )
  { return((APTR)pOS_OpenLibrary((CHAR*)libName,0));}

void CloseLibrary( struct Library *library )
  { pOS_CloseLibrary((APTR)library); }

void SumLibrary( struct Library *library )
  { pOS_SumLibrary((APTR)library); }

void AddDevice( struct Device *device )
  {  pOS_AddDevice((APTR)device);}

void RemDevice( struct Device *device )
  {  pOS_RemDevice((APTR)device); }

BYTE OpenDevice(UBYTE *devName,unsigned long unit,struct IORequest *ioRequest,unsigned long flags)
  {  return(pOS_OpenDevice((CHAR*)devName,unit,(APTR)ioRequest,flags,0)); }

void CloseDevice( struct IORequest *ioRequest )
  {  pOS_CloseDevice((APTR)ioRequest); }

BYTE DoIO( struct IORequest *ioRequest )
  {  return(pOS_DoIO((APTR)ioRequest)); }

void SendIO( struct IORequest *ioRequest )
  {  pOS_SendIO((APTR)ioRequest); }

struct IORequest *CheckIO( struct IORequest *ioRequest )
  {  return((APTR)pOS_CheckIO((APTR)ioRequest)); }

BYTE WaitIO( struct IORequest *ioRequest )
  {  return(pOS_WaitIO((APTR)ioRequest)); }

void AbortIO( struct IORequest *ioRequest )
  {  pOS_AbortIO((APTR)ioRequest); }

void AddResource( APTR resource )
  {pOS_AddResource(resource);}

void RemResource( APTR resource )
  {pOS_RemResource(resource);}

APTR OpenResource( UBYTE *resName )
  {return(pOS_OpenResource((CHAR*)resName));}

APTR RawDoFmt( UBYTE *formatString, APTR dataStream, void (*putChProc)(),APTR putChData );

ULONG GetCC( void );

ULONG TypeOfMem(APTR address)
  {return(pOS_TypeOfMem(address,0));}

VOID Procure( struct SignalSemaphore *sigSem,struct SemaphoreMessage *bidMsg)
  { pOS_ProcureSemaphore((APTR)sigSem,(APTR)bidMsg); }

void Vacate( struct SignalSemaphore *sigSem,struct SemaphoreMessage *bidMsg )
  { pOS_VacateSemaphore((APTR)sigSem,(APTR)bidMsg); }

struct Library *OpenLibrary( UBYTE *libName, unsigned long version )
  { return((APTR)pOS_OpenLibrary((CHAR*)libName,version)); }

void InitSemaphore( struct SignalSemaphore *sigSem )
  {  pOS_InitSemaphore((APTR)sigSem); }

void ObtainSemaphore( struct SignalSemaphore *sigSem )
  {  pOS_ObtainSemaphore((APTR)sigSem); }

void ReleaseSemaphore( struct SignalSemaphore *sigSem )
  {  pOS_ReleaseSemaphore((APTR)sigSem); }

ULONG AttemptSemaphore( struct SignalSemaphore *sigSem )
  {  return(pOS_AttemptSemaphore((APTR)sigSem)); }

void ObtainSemaphoreList( struct List *sigSem )
  { pOS_ObtainSemaphoreList((APTR)sigSem); }

void ReleaseSemaphoreList( struct List *sigSem )
  { pOS_ReleaseSemaphoreList((APTR)sigSem); }

struct SignalSemaphore *FindSemaphore( UBYTE *sigSem )
  { return((APTR)pOS_FindSemaphore((CHAR*)sigSem));}

void AddSemaphore( struct SignalSemaphore *sigSem )
  { pOS_AddSemaphore((APTR)sigSem); }

void RemSemaphore( struct SignalSemaphore *sigSem )
  { pOS_RemSemaphore((APTR)sigSem); }


ULONG SumKickData( void );

void AddMemList( unsigned long size, unsigned long attributes, long pri,APTR base, UBYTE *name );

void CopyMem( APTR source, APTR dest, unsigned long size )
  { pOS_CopyMem(source,dest,size);}

void CopyMemQuick( APTR source, APTR dest, unsigned long size )
  {  pOS_CopyMem(source,dest,size); }

void CacheClearU( void )
  { pOS_CacheClearU(); }

void CacheClearE( APTR address, unsigned long length, unsigned long caches )
  { pOS_CacheClearE(address,length,caches); }

ULONG CacheControl( unsigned long cacheBits, unsigned long cacheMask )
  { return(pOS_CacheControl(cacheBits,cacheMask)); }

APTR CreateIORequest( struct MsgPort *port, unsigned long size )
  {  return(pOS_CreateIORequest((APTR)port,size)); }

void DeleteIORequest( APTR iorequest )
  {  pOS_DeleteIORequest((APTR)iorequest); }

struct MsgPort *CreateMsgPort( void )
  { return((APTR)pOS_CreatePort(0,0)); }

void DeleteMsgPort( struct MsgPort *port )
  { pOS_DeletePort((APTR)port); }

void ObtainSemaphoreShared( struct SignalSemaphore *sigSem )
  { pOS_ObtainSemaphoreShared((APTR)sigSem); }

APTR AllocVec( unsigned long byteSize, unsigned long requirements )
  {  return(pOS_AllocVec(byteSize,requirements)); }

void FreeVec( APTR memoryBlock )
  {  pOS_FreeVec(memoryBlock); }

APTR CreatePool( ULONG requirements, ULONG puddleSize,ULONG threshSize)
  {
    struct pOS_MemPool *MP=(struct pOS_MemPool*)pOS_AllocMem(sizeof(struct pOS_MemPool),MEMF_PUBLIC);
    if(MP) {
      pOS_InitMemPool(MP,puddleSize,requirements);
    }
    return((APTR)MP);
  }

void DeletePool( APTR mp )
  {
    pOS_FreePoolAll( (struct pOS_MemPool*)mp );
    pOS_FreeMem(mp,sizeof(struct pOS_MemPool));
  }

APTR AllocPooled( APTR mp, unsigned long memSize )
  {
    /** MEMF_CLEAR => safety **/
    return( pOS_AllocPoolMem((struct pOS_MemPool*)mp,memSize,MEMF_CLEAR) );
  }

void FreePooled( APTR mp, APTR memory, unsigned long memSize )
  {
    pOS_FreePoolMem( (struct pOS_MemPool*)mp,memory,memSize);
  }

ULONG AttemptSemaphoreShared( struct SignalSemaphore *sigSem );

void ColdReboot( void )
  { pOS_ColdReboot(); }

void StackSwap( struct StackSwapStruct *newStack )
  {pOS_StackSwap((APTR)newStack); }

void ChildFree( APTR tid );
void ChildOrphan( APTR tid );
void ChildStatus( APTR tid );
void ChildWait( APTR tid );

APTR CachePreDMA( APTR address, ULONG *length, unsigned long flags );
void CachePostDMA( APTR address, ULONG *length, unsigned long flags );

void AddMemHandler( struct Interrupt *memhand )
  { pOS_AddMemHandler((APTR)memhand); }

void RemMemHandler( struct Interrupt *memhand )
  { pOS_RemMemHandler((APTR)memhand); }

ULONG ObtainQuickVector( APTR interruptCode );















#ifdef __IGNORE_NOT_SUPPORTED__

ULONG AttemptSemaphoreShared( struct SignalSemaphore *sigSem )
{return(0);}



void Debug( unsigned long flags )
{}
struct Interrupt *SetIntVector( long intNumber, struct Interrupt *interrupt )
{return(0);}
void AddIntServer( long intNumber, struct Interrupt *interrupt )
{}
void RemIntServer( long intNumber, struct Interrupt *interrupt )
{}
void Cause( struct Interrupt *interrupt )
{}
LONG AllocTrap( long trapNum )
{return(0);}
void FreeTrap( long trapNum );
APTR RawDoFmt(UBYTE *formatString, APTR dataStream, void(*putChProc)(),APTR putChData);
ULONG GetCC( void );
ULONG SumKickData( void );
void AddMemList(ULONG size,ULONG attributes, long pri,APTR base, UBYTE *name );
void ChildFree( APTR tid );
void ChildOrphan( APTR tid );
void ChildStatus( APTR tid );
void ChildWait( APTR tid );
APTR CachePreDMA( APTR address, ULONG *length, unsigned long flags );
void CachePostDMA( APTR address, ULONG *length, unsigned long flags );
ULONG ObtainQuickVector( APTR interruptCode );

APTR SetFunction( struct Library *library, long funcOffset,unsigned long (*newFunction)() )
{return(0);}


#endif  /** __IGNORE_NOT_SUPPORTED__ **/




#endif