#ifndef  CLIB_DPKERNEL_PROTOS_H
#define  CLIB_DPKERNEL_PROTOS_H

/*
**  $VER: dpkernel_protos.h V1.0
**
**  C prototypes.
**
**  (C) Copyright 1996-1998 DreamWorld Productions.
**      All Rights Reserved.
*/

#ifndef  DPKERNEL_H
#include <dpkernel/dpkernel.h>
#endif

#ifndef MODULES_DPKBASE_H
#include <modules/dpkbase.h>
#endif

#ifndef _USE_DPKBASE

void yyx0000(void);
void TagInitTags(APTR,APTR);

ECODE  Activate(APTR Object);
struct Event * AddSysEvent(APTR TagList);
struct Event * AddSysEventTags(ULONG tag1Type, ...);
struct SysObject * AddSysObject(WORD ClassID, WORD ObjectID, BYTE *Name, APTR TagList);
struct SysObject * AddSysObjectTags(WORD ClassID, WORD ObjectID, BYTE *Name, ULONG tag1Type, ...);
LONG   AddTrack(LONG Resource, LONG Data, APTR Routine);
APTR   AllocMemBlock(LONG Size, LONG MemType);
void   Armageddon(LONG Key);
ECODE  AttemptExclusive(APTR Object, WORD Ticks);
void   AutoStop(void);
LONG   Awaken(struct DPKTask *);
LONG   CallEventList(LONG ID, APTR Arg1, LONG Arg2);
ECODE  CheckAction(APTR Object, LONG ActionTag);
struct DPKTask * CheckExclusive(APTR Object);
LONG   CheckInit(APTR Object);
LONG   CheckLock(APTR Object);
LONG   Clear(APTR Object);
void   CloseDPK(void);
LONG   Copy(APTR Source, APTR Destination);
LONG   CopyStructure(APTR Source, APTR Destination);
LONG   Deactivate(APTR Object);
void   DeleteTrack(LONG Key);
LONG   Detach(APTR Object1, APTR Object2);
void   DPKForbid(void);
void   DPKPermit(void);
void   DPrintF(BYTE *Header, const BYTE *, ...);
ECODE  Draw(APTR Object);
ECODE  ErrCode(LONG ErrorCode);
ECODE  Exclusive(APTR Object);
LONG   FastRandom(LONG Range);
struct DPKTask *   FindDPKTask(void);
struct SysObject * FindSysObject(WORD ID, struct SysObject *);
LONG   FingerOfDeath(struct DPKTask *);
LONG   Flush(APTR Object);
void   Free(APTR Object);
void   FreeExclusive(APTR Object);
void   FreeMemBlock(APTR MemBlock);
APTR   Get(LONG ID);
LONG   GetMemSize(APTR MemBlock);
LONG   GetMemType(APTR MemBlock);
BYTE * GetExtension(APTR Object);
BYTE * GetFileType(APTR Object);
struct ItemList * GetTypeList(WORD ClassID);
void   Hide(APTR Object);
APTR   Init(APTR Object, APTR Container);
APTR   InitTags(APTR Container, ULONG tag1Type, ...);
APTR   InitTagList(struct TagItem *, APTR Container);
void   InitDestruct(void *DestructCode, APTR DestructStack);
APTR   Load(APTR Source, WORD ID);
APTR   LoadPrefs(struct DPKTask *, BYTE *Name);
LONG   Lock(APTR Object);
LONG   MoveToBack(APTR Object);
LONG   MoveToFront(APTR Object);
struct Module * OpenModule(LONG ID, BYTE *Name);
ECODE  Query(APTR Object);
LONG   Read(APTR Object, APTR Buffer, LONG Length);
APTR   Realloc(APTR Memory, LONG NewSize);
void   RemapKernel(APTR Functions);
void   RemSysEvent(struct Event *);
void   RemSysObject(struct SysObject *);
ECODE  Rename(APTR Object, BYTE *Name);
LONG   Reset(APTR Object);
ECODE  SaveToFile(APTR Object, struct FileName *, BYTE *FileType);
struct DPKTask * SearchForTask(BYTE *Name, struct DPKTask *);
LONG   Seek(APTR Object, LONG Offset, WORD Position);
void   SelfDestruct(void);
ECODE  Show(APTR Object);
LONG   SlowRandom(LONG Range);
void   StepBack(void);
LONG   Stream(APTR SrcObject, APTR DestObject, LONG Length);
void   OldSwitch(void);
LONG   TagInit(APTR Structure, APTR TagList);
LONG   TotalMem(struct DPKTask *, LONG Flags);
LONG   Unhook(APTR Object, APTR Chain);
void   Unlock(APTR Object);
void   WaitTime(WORD MicroSeconds);
LONG   Write(APTR Object, APTR Buffer, LONG Length);

LONG   AllocObjectID(void);
struct Reference * FindReference(LONG ClassID, struct Reference *Reference);
struct SysObject * FindSysObjectName(BYTE *Name);
APTR   GetByName(BYTE *Name);
LONG   SetDebug(APTR DPrintF, APTR DebugMsg);

#else /*** Definition for inline library calls ***/

FNCALL ECODE Activate(APTR Object) {
  return(DPKBase->Activate(Object));
}
FNCALL struct Event * AddSysEvent(APTR TagList) {
  return(DPKBase->AddSysEvent(TagList));
}
FNCALL struct SysObject * AddSysObject(WORD ClassID, WORD ObjectID, BYTE *Name, APTR TagList) {
  return(DPKBase->AddSysObject(ClassID, ObjectID, Name, TagList));
}
FNCALL LONG AddTrack(LONG Resource, LONG Data, APTR Routine) {
  return(DPKBase->AddTrack(Resource, Data, Routine));
}
FNCALL APTR AllocMemBlock(LONG Size, LONG MemType) {
  return(DPKBase->AllocMemBlock(Size, MemType));
}
FNCALL void Armageddon(LONG Key) {
  DPKBase->Armageddon(Key);
}
FNCALL ECODE AttemptExclusive(APTR Object, WORD Ticks) {
  return(DPKBase->AttemptExclusive(Object, Ticks));
}
FNCALL void AutoStop(void) {
  DPKBase->AutoStop();
}
FNCALL LONG Awaken(struct DPKTask *Task) {
  return(DPKBase->Awaken(Task));
}
FNCALL LONG CallEventList(LONG ID, APTR Arg1, LONG Arg2) {
  return(DPKBase->CallEventList(ID, Arg1, Arg2));
}
FNCALL ECODE CheckAction(APTR Object, LONG ActionTag) {
  return(DPKBase->CheckAction(Object, ActionTag));
}
FNCALL struct DPKTask * CheckExclusive(APTR Object) {
  return(DPKBase->CheckExclusive(Object));
}
FNCALL LONG CheckInit(APTR Object) {
  return(DPKBase->CheckInit(Object));
}
FNCALL LONG CheckLock(APTR Object) {
  return(DPKBase->CheckLock(Object));
}
FNCALL LONG Clear(APTR Object) {
  return(DPKBase->Clear(Object));
}
FNCALL void CloseDPK(void) {
  DPKBase->CloseDPK();
}
FNCALL LONG Copy(APTR Source, APTR Destination) {
  return(DPKBase->Copy(Source, Destination));
}
FNCALL LONG CopyStructure(APTR Source, APTR Destination) {
  return(DPKBase->CopyStructure(Source, Destination));
}
FNCALL LONG Deactivate(APTR Object) {
  return(DPKBase->Deactivate(Object));
}
FNCALL void DeleteTrack(LONG Key) {
  DPKBase->DeleteTrack(Key);
}
FNCALL LONG Detach(APTR Object1, APTR Object2) {
  return(DPKBase->Detach(Object1, Object2));
}
FNCALL void DPKForbid(void) {
  DPKBase->DPKForbid();
}
FNCALL void DPKPermit(void) {
  DPKBase->DPKPermit();
}
FNCALL ECODE Draw(APTR Object) {
  return(DPKBase->Draw(Object));
}
FNCALL ECODE ErrCode(LONG ErrorCode) {
  return(DPKBase->ErrCode(ErrorCode));
}
FNCALL ECODE Exclusive(APTR Object) {
  return(DPKBase->Exclusive(Object));
}
FNCALL LONG FastRandom(LONG Range) {
  return(DPKBase->FastRandom(Range));
}
FNCALL struct DPKTask * FindDPKTask(void) {
  return(DPKBase->FindDPKTask());
}
FNCALL struct SysObject * FindSysObject(WORD ID, struct SysObject *SysObject) {
  return(DPKBase->FindSysObject(ID, SysObject));
}
FNCALL LONG FingerOfDeath(struct DPKTask *Task) {
  return(DPKBase->FingerOfDeath(Task));
}
FNCALL LONG Flush(APTR Object) {
  return(DPKBase->Flush(Object));
}
FNCALL void Free(APTR Object) {
  return(DPKBase->Free(Object));
}
FNCALL void FreeExclusive(APTR Object) {
  DPKBase->FreeExclusive(Object);
}
FNCALL void FreeMemBlock(APTR MemBlock) {
  DPKBase->FreeMemBlock(MemBlock);
}
FNCALL APTR Get(LONG ID) {
  return(DPKBase->Get(ID));
}
FNCALL LONG GetMemSize(APTR MemBlock) {
  return(DPKBase->GetMemSize(MemBlock));
}
FNCALL LONG GetMemType(APTR MemBlock) {
  return(DPKBase->GetMemType(MemBlock));
}
FNCALL BYTE * GetExtension(APTR Object) {
  return(DPKBase->GetExtension(Object));
}
FNCALL BYTE * GetFileType(APTR Object) {
  return(DPKBase->GetFileType(Object));
}
FNCALL struct ItemList * GetTypeList(WORD ClassID) {
  return(DPKBase->GetTypeList(ClassID));
}
FNCALL void Hide(APTR Object) {
  DPKBase->Hide(Object);
}
FNCALL APTR Init(APTR Object, APTR Container) {
  return(DPKBase->Init(Object, Container));
}
FNCALL APTR InitTagList(APTR Object, APTR Container) {
  return(DPKBase->Init(Object, Container));
}
FNCALL void InitDestruct(void *DestructCode, APTR DestructStack) {
  DPKBase->InitDestruct(DestructCode, DestructStack);
}
FNCALL APTR Load(APTR Source, WORD ID) {
  return(DPKBase->Load(Source, ID));
}
FNCALL APTR LoadPrefs(struct DPKTask *Task, BYTE *Name) {
  return(DPKBase->LoadPrefs(Task, Name));
}
FNCALL LONG Lock(APTR Object) {
  return(DPKBase->Lock(Object));
}
FNCALL LONG MoveToBack(APTR Object) {
  return(DPKBase->MoveToBack(Object));
}
FNCALL LONG MoveToFront(APTR Object) {
  return(DPKBase->MoveToFront(Object));
}
FNCALL struct Module * OpenModule(LONG ID, BYTE *Name) {
  return(DPKBase->OpenModule(ID, Name));
}
FNCALL ECODE Query(APTR Object) {
  return(DPKBase->Query(Object));
}
FNCALL LONG Read(APTR Object, APTR Buffer, LONG Length) {
  return(DPKBase->Read(Object, Buffer, Length));
}
FNCALL APTR Realloc(APTR Memory, LONG NewSize) {
  return(DPKBase->Realloc(Memory, NewSize));
}
FNCALL void RemapKernel(APTR Functions) {
  DPKBase->RemapKernel(Functions);
}
FNCALL void RemSysEvent(struct Event *Event) {
  DPKBase->RemSysEvent(Event);
}
FNCALL void RemSysObject(struct SysObject *SysObject) {
  DPKBase->RemSysObject(SysObject);
}
FNCALL ECODE Rename(APTR Object, BYTE *Name) {
  return(DPKBase->Rename(Object, Name));
}
FNCALL LONG Reset(APTR Object) {
  return(DPKBase->Reset(Object));
}
FNCALL ECODE SaveToFile(APTR Object, struct FileName *FileName, BYTE *FileType) {
  return(DPKBase->SaveToFile(Object, FileName, FileType));
}
FNCALL struct DPKTask * SearchForTask(BYTE *Name, struct DPKTask *Task) {
  return(DPKBase->SearchForTask(Name, Task));
}
FNCALL LONG Seek(APTR Object, LONG Offset, WORD Position) {
  return(DPKBase->Seek(Object, Offset, Position));
}
FNCALL void SelfDestruct(void) {
  DPKBase->SelfDestruct();
}
FNCALL ECODE Show(APTR Object) {
  return(DPKBase->Show(Object));
}
FNCALL LONG SlowRandom(LONG Range) {
  return(DPKBase->SlowRandom(Range));
}
FNCALL void StepBack(void) {
  DPKBase->StepBack();
}
FNCALL LONG Stream(APTR SrcObject, APTR DestObject, LONG Length) {
  return(DPKBase->Stream(SrcObject, DestObject, Length));
}
FNCALL void OldSwitch(void) {
  DPKBase->OldSwitch();
}
FNCALL LONG TagInit(APTR Structure, APTR TagList) {
  return(DPKBase->TagInit(Structure, TagList));
}
FNCALL LONG TotalMem(struct DPKTask *Task, LONG Flags) {
  return(DPKBase->TotalMem(Task, Flags));
}
FNCALL LONG Unhook(APTR Object, APTR Chain) {
  return(DPKBase->Unhook(Object, Chain));
}
FNCALL void Unlock(APTR Object) {
  DPKBase->Unlock(Object);
}
FNCALL void WaitTime(WORD MicroSeconds) {
  DPKBase->WaitTime(MicroSeconds);
}
FNCALL LONG Write(APTR Object, APTR Buffer, LONG Length) {
  return(DPKBase->Write(Object, Buffer, Length));
}
FNCALL LONG AllocObjectID(void) {
  return(DPKBase->AllocObjectID());
}
FNCALL struct Reference * FindReference(LONG ClassID, struct Reference *Reference) {
  return(DPKBase->FindReference(ClassID, Reference));
}
FNCALL struct SysObject * FindSysObjectName(BYTE *Name) {
  return(DPKBase->FindSysObjectName(Name));
}
FNCALL APTR GetByName(BYTE *Name) {
  return(DPKBase->GetByName(Name));
}
FNCALL LONG SetDebug(APTR DPrintF, APTR DebugMsg) {
  return(DPKBase->SetDebug(DPrintF, DebugMsg));
}

/*** Non-inline calls (necessary for tags) ***/

APTR InitTags(APTR Container, ULONG tag1Type, ...) {
  return(DPKBase->Init(Container, &tag1Type));
}
void DPrintF(BYTE *Header, ULONG String, ...) {
  DPKBase->DPrintF(Header, (BYTE *)&String);
}
struct SysObject * AddSysObjectTags(WORD ClassID, WORD ObjectID, BYTE *Name, ULONG tag1Type, ...) {
  return(DPKBase->AddSysObject(ClassID, ObjectID, Name, &tag1Type));
}
struct Event * AddSysEventTags(ULONG tag1Type, ...) {
  return(DPKBase->AddSysEvent(&tag1Type));
}

#endif /* _USE_DPKBASE */

#endif /* CLIB_DPKERNEL_PROTOS_H */