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

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

#define NOMYDEBUG


#include <exec/types.h>

#include <pExec/Types.h>
#include <pProto/pDos2.h>
#include <pDos/DosTags.h>

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



#pragma -
#include <pDOS/Process.h>
#include <dos/dos.h>
#include <dos/dosextens.h>



BPTR Open( STRPTR name, long accessMode )
  { return((BPTR)pOS_OpenFile(NULL,(CHAR*)name,accessMode)); }

LONG Close( BPTR file )
  {  pOS_CloseFile((APTR)file);  return(0);}

LONG Read( BPTR file, APTR buffer, long length )
  { return(pOS_ReadFile((APTR)file,buffer,length)); }

LONG Write( BPTR file, APTR buffer, long length )
  {  return(pOS_WriteFile((APTR)file,buffer,length));}

BPTR Input( void )
  {  return((BPTR)pOS_GetStdInput()); }

BPTR Output( void )
  { return((BPTR)pOS_GetStdInput()); }

LONG Seek( BPTR file, long position, long offset )
  { return(pOS_SeekFile((APTR)file,position,offset)); }

LONG DeleteFile( STRPTR name )
  {  return(pOS_DeleteObjectName(NULL,(CHAR*)name)); }

LONG Rename( STRPTR oldName, STRPTR newName )
  { return( pOS_RenameObjectName(NULL,(CHAR*)oldName,(CHAR*)newName)); }

BPTR Lock( STRPTR name, long type )
  { return((BPTR)pOS_LockObject(NULL,(CHAR*)name,type));}

VOID UnLock( BPTR lock )
  { pOS_UnlockObject((APTR)lock); }

BPTR DupLock( BPTR lock )
  { return((BPTR)pOS_DupObjectLock((APTR)lock)); }

LONG Examine( BPTR lock, struct FileInfoBlock *fileInfoBlock )
  {
    SLONG Res=pOS_ExamineObject((APTR)lock,(APTR)fileInfoBlock);
    if(fileInfoBlock->fib_DirEntryType & FINFENTYP_File)
         fileInfoBlock->fib_DirEntryType |=  0x80;
    else fileInfoBlock->fib_DirEntryType &= ~0x80;
    return(Res);
  }

LONG ExNext( BPTR lock, struct FileInfoBlock *fileInfoBlock )
  {
    SLONG Res=pOS_ExNextObject((APTR)lock,(APTR)fileInfoBlock);
    if(fileInfoBlock->fib_DirEntryType & FINFENTYP_File)
         fileInfoBlock->fib_DirEntryType |=  0x80;
    else fileInfoBlock->fib_DirEntryType &= ~0x80;
    return(Res);
  }

LONG Info( BPTR lock, struct InfoData *parameterBlock )
  {  return(pOS_GetDosInfoData((APTR)lock,(APTR)parameterBlock)); }

BPTR CreateDir( STRPTR name )
  { return((BPTR)pOS_CreateDirectory(NULL,(CHAR*)name));}

BPTR CurrentDir( BPTR lock )
  { return((BPTR)pOS_SetCurrentDirLock((APTR)lock));}

LONG IoErr(void)
  { return(pOS_GetIoErr()); }

BPTR LoadSeg( STRPTR name )
  { return((BPTR)pOS_LoadSegmentA((CHAR*)name,NULL));}

LONG UnLoadSeg( BPTR seglist )
  { pOS_UnloadSegment((APTR)seglist); return(1);}

LONG SetComment( STRPTR name, STRPTR comment )
  { return(pOS_SetObjectCommentName(NULL,(CHAR*)name,(CHAR*)comment)); }

LONG SetProtection( STRPTR name, long protect )
  { return(pOS_SetObjectProtectionName(NULL,(CHAR*)name,protect)); }

struct DateStamp *DateStamp( struct DateStamp *date )
  { return((APTR)pOS_GetDateStamp((APTR)date));}

struct DateStamp *pOS_DateStamp( struct DateStamp *date ) /** pOS **/
  { return((APTR)pOS_GetDateStamp((APTR)date)); }

void Delay( long timeout )
  { pOS_DosDelay(timeout); }

BPTR ParentDir( BPTR lock )
  { return((BPTR)pOS_ParentObjectDir((APTR)lock)); }

LONG IsInteractive( BPTR file )
  { return(pOS_IsFileInteractive((APTR)file)); }

APTR AllocDosObject( unsigned long type, struct TagItem *tags )
  {  return(pOS_AllocDosObject(type,0)); }

APTR AllocDosObjectTagList( unsigned long type, struct TagItem *tags )
  {  return(pOS_AllocDosObject(type,0)); }

APTR AllocDosObjectTags( unsigned long type, unsigned long tag1type, ... )
  {  return(pOS_AllocDosObject(type,0)); }

void FreeDosObject( unsigned long type, APTR ptr )
  {  pOS_FreeDosObject(type,ptr);}

BPTR SelectInput( BPTR fh )
  { return((BPTR)pOS_SetStdInput((struct pOS_FileHandle*)fh));}

BPTR SelectOutput( BPTR fh )
  { return((BPTR)pOS_SetStdOutput((struct pOS_FileHandle*)fh));}

LONG FGetC( BPTR fh )
  { return(pOS_FileGetC((APTR)fh)); }

LONG FPutC( BPTR fh, long ch )
  { return(pOS_FilePutC((APTR)fh,ch)); }

LONG UnGetC( BPTR fh, long ch)
  { return(pOS_FileUnGetC((APTR)fh,ch)); }

LONG FRead( BPTR fh, APTR block, unsigned long blocklen,unsigned long number)
  {  return( pOS_FileFRead((APTR)fh,block,blocklen,number));}

LONG FWrite( BPTR fh, APTR block, unsigned long blocklen,unsigned long number )
  {  return( pOS_FileFWrite((APTR)fh,(APTR)block,blocklen,number)); }

STRPTR FGets( BPTR fh, STRPTR buf, unsigned long buflen )
  { return(pOS_FileGets((APTR)fh,buf,buflen));}

LONG FPuts( BPTR fh, STRPTR str )
  {   return(pOS_FilePuts((APTR)fh,str));}

void VFWritef( BPTR fh, STRPTR format, LONG *argarray )
  {  pOS_VFWritef((APTR)fh,(CHAR*)format,(APTR)argarray); }

LONG Flush( BPTR fh )
  {  return(pOS_FileFlush((APTR)fh)); }

LONG SetVBuf( BPTR fh, STRPTR buff, long type, long size )
  {  return(pOS_SetFileHandleBuf((APTR)fh,buff,type,size)); }

BPTR OpenFromLock( BPTR lock )
 { return((BPTR)pOS_OpenFileFromLock((APTR)lock));}

BOOL ExamineFH( BPTR fh, struct FileInfoBlock *fib )
  {  return(pOS_ExamineFH((APTR)fh,(APTR)fib)); }

LONG SetFileDate( STRPTR name, struct DateStamp *date )
  { return(pOS_SetObjectDateName(NULL,(CHAR*)name,(APTR)date));}

LONG NameFromLock( BPTR lock, STRPTR buffer, long len )
  { return(pOS_NameFromObjectLock((APTR)lock,(CHAR*)buffer,len)); }

LONG NameFromFH( BPTR fh, STRPTR buffer, long len )
  { return(pOS_NameFromFH((APTR)fh,(CHAR*)buffer,len)); }

WORD SplitName(STRPTR name,unsigned long seperator,STRPTR buf,long oldpos,long size )
  { return(pOS_SplitName((APTR)name,seperator,(CHAR*)buf,oldpos,size)); }

LONG SameLock( BPTR lock1, BPTR lock2 )
  { return(pOS_SameDosObject((APTR)lock1,(APTR)lock2));}

LONG SetMode( BPTR fh, long mode )
  { return(pOS_SetDosScreenMode((APTR)fh,mode));}

LONG ChangeMode( long type, BPTR fh, long newmode )
  {
    if(type==0) return(pOS_ChangeDosObjectAccess((APTR)fh,newmode));
    else        return(pOS_ChangeDosFileAccess((APTR)fh,newmode));
  }

LONG SetIoErr( long result )
  {  return(pOS_SetIoErr(result)); }

BOOL PrintFault( long code, STRPTR header )
  {  return(pOS_PrintDosErr(NULL,(CHAR*)header,code)); }

struct Process *CreateNewProc( struct TagItem *tags )
  {
    struct pOS_TagItem Tags[]={
      DOSTAG_DefaultProc, FALSE,
      TAG_MORE,           (ULONG)tags
    };
    return((APTR)pOS_CreateProcessA(Tags));
  }

struct Process *CreateNewProcTagList( struct TagItem *tags )
  {  return((APTR)CreateNewProc((APTR)tags)); }

struct Process *CreateNewProcTags( unsigned long tag1type, ... )
  {  return((APTR)CreateNewProc((APTR)&tag1type)); }

BOOL SetCurrentDirName( STRPTR name )
  {  return(pOS_SetCurrentDirName((CHAR*)name));}

BOOL GetCurrentDirName( STRPTR buf, long len )
  {  return(pOS_GetCurrentDirName((CHAR*)buf,len));}

BOOL SetPrompt( STRPTR name )
  { return(pOS_SetPrompt((CHAR*)name));}

BOOL GetPrompt( STRPTR buf, long len )
  { return(pOS_GetPrompt((CHAR*)buf,len));}

BPTR SetProgramDir( BPTR lock )
  {return((BPTR)pOS_SetProgDir((APTR)lock)); }

BPTR GetProgramDir( void )
  {return((BPTR)pOS_GetProgDir());}

LONG SystemTagList( STRPTR command, struct TagItem *tags )
  {  return(pOS_SystemA((CHAR*)command,(APTR)tags)); }

LONG System( STRPTR command, struct TagItem *tags )
  {  return(pOS_SystemA((CHAR*)command,(APTR)tags)); }

LONG SystemTags( STRPTR command, unsigned long tag1type, ... )
  {  return(pOS_SystemA((CHAR*)command,(APTR)&tag1type)); }

BOOL IsFileSystem( STRPTR name )
  { return(pOS_IsFileSystemName(NULL,(CHAR*)name)); }

LONG Relabel( STRPTR drive, STRPTR newname )
  { return(pOS_RelabelDosDevice(pOS_GetDosDevice(NULL,(CHAR*)drive),(CHAR*)newname));}

LONG Inhibit( STRPTR name, long onoff )
  { return(pOS_InhibitDosDevice(pOS_GetDosDevice(NULL,(CHAR*)name),onoff));}

LONG AddBuffers( STRPTR name, long number )
  { return(pOS_AddDosDeviceBuffers(pOS_GetDosDevice(NULL,(CHAR*)name),number*512));}

LONG CompareDates( struct DateStamp *date1, struct DateStamp *date2 )
  {  return(pOS_CompareDates((APTR)date1,(APTR)date2)); }

LONG DateToStr( struct DateTime *datetime )
  {  return(pOS_DateToStr((APTR)datetime)); }

LONG StrToDate( struct DateTime *datetime )
  {   return(pOS_StrToDate((APTR)datetime)); }

LONG CheckSignal( long mask )
  { return(pOS_DosCheckSignal(mask));}

struct RDArgs *ReadArgs( STRPTR arg_template, LONG *array,struct RDArgs *args )
  { return((APTR)pOS_ReadDosArgsA((CHAR*)arg_template,(APTR)array,-1,NULL));}

LONG MatchFirst( STRPTR pat, struct AnchorPath *anchor )
  { return(pOS_PathMatchFirst(NULL,(CHAR*)pat,(APTR)anchor,NULL,0));}

LONG MatchNext( struct AnchorPath *anchor )
  { return(pOS_PathMatchNext((APTR)anchor));}

void MatchEnd( struct AnchorPath *anchor )
  { pOS_PathMatchEnd((APTR)anchor);}

void FreeArgs( struct RDArgs *args )
  { pOS_DeleteDosArgs((APTR)args);}

STRPTR FilePart( STRPTR path )
  { return((STRPTR)pOS_FilePart((CHAR*)path));}

STRPTR PathPart( STRPTR path )
  { return((STRPTR)pOS_PathPart((CHAR*)path)); }

BOOL AddPart( STRPTR dirname, STRPTR filename, unsigned long size )
  { return(pOS_AddPart((CHAR*)dirname,(CHAR*)filename,size)); }

BOOL StartNotify( struct NotifyRequest *notify )
  { return(pOS_DosStartNotify((APTR)notify)); }

void EndNotify( struct NotifyRequest *notify )
  { pOS_DosEndNotify((APTR)notify); }

BOOL SetVar( STRPTR name, STRPTR buffer, long size, long flags )
  { return(pOS_SetVar((CHAR*)name,(UBYTE*)buffer,size,flags,NULL));}

LONG GetVar( STRPTR name, STRPTR buffer, long size, long flags )
  { return(pOS_GetVar((CHAR*)name,(UBYTE*)buffer,size,flags,NULL));}

LONG DeleteVar( STRPTR name, unsigned long flags )
  { return(pOS_DeleteVar((CHAR*)name,flags,NULL));}

struct LocalVar *FindVar( STRPTR name, unsigned long type )
  { return((APTR)pOS_FindVar((CHAR*)name,type,NULL));}

BOOL SameDevice( BPTR lock1, BPTR lock2 )
  { return(pOS_SameDosDevice((APTR)lock1,(APTR)lock2));}


/*MIC*/ void FWritef( BPTR fh, STRPTR format, ... )
  { pOS_VFWritef((struct pOS_FileHandle *)fh,format,(APTR) ((&format)+1)); }


/*MIC*/ LONG WriteChars( STRPTR buf, unsigned long buflen )
  {
    return( pOS_WriteFile(pOS_GetStdOutput(),buf,buflen) );
  }

/*MIC*/ LONG PutStr( STRPTR str )
  {
    return( pOS_FilePuts(pOS_GetStdOutput(),str) );
  }

/*MIC*/ LONG VPrintf( STRPTR format, APTR argarray )
  { return( pOS_VFWritef(pOS_GetStdOutput(),format,argarray) ); }

/*MIC*/ LONG Printf( STRPTR format, ... )
  { return( pOS_VFWritef(pOS_GetStdOutput(),format,(APTR) ((&format)+1)) ); }

LONG Execute( STRPTR string, BPTR file, BPTR file2 )
  {
    return( pOS_System((CHAR*)string,
        DOSTAG_Synchronous, TRUE,
        DOSTAG_InputFH,     (ULONG)file,
        DOSTAG_OutputFH,    (ULONG)file,
        DOSTAG_StackSize,   (ULONG)~0,
        TAG_END)==0);
  }

LONG RunCommand( BPTR seg, long stack, STRPTR paramptr, long paramlen )
  {
    return( pOS_RunCommand((struct pOS_SegmentLst*)seg,stack,NULL,NULL,NULL,paramptr) );
  }

LONG AssignLock( STRPTR name, BPTR lock )
  {
    return( pOS_CreateDosAssign((CHAR*)name,(struct pOS_FileLock*)lock,
                                NULL,DDTYP_Assign) != NULL );
  }

BOOL AssignLate( STRPTR name, STRPTR path )
  {
    return( pOS_CreateDosAssign((CHAR*)name,NULL,path,DDTYP_LateAssign) != NULL );
  }

BOOL AssignPath( STRPTR name, STRPTR path )
  {
    return( pOS_CreateDosAssign((CHAR*)name,NULL,path,DDTYP_NonBindingAssign) != NULL );
  }

BOOL AssignAdd( STRPTR name, BPTR lock )
  {
    return( pOS_AddDosAssign((CHAR*)name,(struct pOS_FileLock*)lock,0) != NULL );
  }

LONG RemAssignList( STRPTR name, BPTR lock )
  {
    return( pOS_DeleteDosAssign((CHAR*)name,(struct pOS_FileLock*)lock,0) );
  }

BPTR NewLoadSeg( STRPTR file, struct TagItem *tags )
  { return((BPTR)pOS_LoadSegmentA((CHAR*)file,(struct pOS_TagItem*)tags));}

BPTR NewLoadSegTagList( STRPTR file, struct TagItem *tags )
  { return((BPTR)pOS_LoadSegmentA((CHAR*)file,(struct pOS_TagItem*)tags));}

BPTR NewLoadSegTags( STRPTR file, unsigned long tag1type, ... )
  { return((BPTR)pOS_LoadSegmentA((CHAR*)file,(struct pOS_TagItem*)&tag1type));}





#ifdef __IGNORE_NOT_SUPPORTED__

BOOL Fault( long code, STRPTR header, STRPTR buffer, long len )
{return(0);}




struct MsgPort *CreateProc( STRPTR name, long pri, BPTR segList,long stackSize )
{return(0);}
void Exit( long returnCode )
  { pOS_SetShellFail(returnCode); }
struct MsgPort *DeviceProc( STRPTR name )
{return(0);}
LONG WaitForChar( BPTR file, long timeout )
{return(0);}
BOOL LockRecord( BPTR fh,ULONG offset,ULONG length,ULONG mode,ULONG timeout )
{return(0);}
BOOL LockRecords( struct RecordLock *recArray, unsigned long timeout )
{return(0);}
BOOL UnLockRecord( BPTR fh, unsigned long offset, unsigned long length )
{return(0);}
BOOL UnLockRecords( struct RecordLock *recArray )
{return(0);}
BPTR ParentOfFH( BPTR fh )
{return(0);}
LONG ExAll(BPTR lock,struct ExAllData *buffer,long size,long data,struct ExAllControl *control)
{return(0);}
LONG ReadLink(struct MsgPort*,BPTR lock,STRPTR path,STRPTR buffer,ULONG size )
{return(0);}
LONG MakeLink( STRPTR name, long dest, long soft )
{return(0);}
LONG SetFileSize( BPTR fh, long pos, long mode )
{return(0);}
LONG ErrorReport( long code, long type, unsigned long arg1,struct MsgPort *device )
{return(0);}
struct CommandLineInterface *Cli( void )
{return(0);}
struct MsgPort *GetConsoleTask( void )
{return(0);}
struct MsgPort *SetConsoleTask( struct MsgPort *task )
{return(0);}
struct MsgPort *GetFileSysTask( void )
{return(0);}
struct MsgPort *SetFileSysTask( struct MsgPort *task )
{return(0);}
STRPTR GetArgStr( void )
{return(0);}
BOOL SetArgStr( STRPTR string )
{return(0);}
struct Process *FindCliProc( unsigned long num )
{return(0);}
ULONG MaxCli( void )
{return(0);}
BOOL SetProgramName( STRPTR name )
{return(0);}
BOOL GetProgramName( STRPTR buf, long len )
{return(0);}
struct DevProc *GetDeviceProc( STRPTR name, struct DevProc *dp )
{return(0);}
void FreeDeviceProc( struct DevProc *dp )
{}
struct DosList *LockDosList( unsigned long flags )
{return(0);}
void UnLockDosList( unsigned long flags )
{}
struct DosList *AttemptLockDosList( unsigned long flags )
{return(0);}
BOOL RemDosEntry( struct DosList *dlist )
{return(0);}
LONG AddDosEntry( struct DosList *dlist )
{return(0);}
struct DosList *FindDosEntry( struct DosList *dlist, STRPTR name,unsigned long flags )
{return(0);}
struct DosList *NextDosEntry( struct DosList *dlist, unsigned long flags )
{return(0);}
struct DosList *MakeDosEntry( STRPTR name, long type )
{return(0);}
void FreeDosEntry( struct DosList *dlist )
{}
BOOL Format( STRPTR filesystem, STRPTR volumename, unsigned long dostype )
{return(0);}
BPTR InternalLoadSeg( BPTR fh, BPTR table, LONG *funcarray, LONG *stack )
{return(0);}
BOOL InternalUnLoadSeg( BPTR seglist, void (*freefunc)() )
{return(0);}
LONG AddSegment( STRPTR name, BPTR seg, long system )
{return(0);}
struct Segment *FindSegment( STRPTR name, struct Segment *seg, long system )
{return(0);}
LONG RemSegment( struct Segment *seg )
{return(0);}
LONG FindArg( STRPTR keyword, STRPTR arg_template )
{return(0);}
LONG ReadItem( STRPTR name, long maxchars, struct CSource *cSource )
{return(0);}
LONG StrToLong( STRPTR string, LONG *value )
{return(0);}
LONG ParsePattern( STRPTR pat, STRPTR buf, long buflen )
{return(0);}
BOOL MatchPattern( STRPTR pat, STRPTR str )
{return(0);}
LONG CliInitNewcli( struct DosPacket *dp )
{return(0);}
LONG CliInitRun( struct DosPacket *dp )
{return(0);}
LONG ParsePatternNoCase( STRPTR pat, STRPTR buf, long buflen )
{return(0);}
BOOL MatchPatternNoCase( STRPTR pat, STRPTR str )
{return(0);}
void ExAllEnd( BPTR lock, struct ExAllData *buffer, long size, long data,struct ExAllControl *control )
{}
BOOL SetOwner( STRPTR name, long owner_info )
{return(0);}

#endif  /** __IGNORE_NOT_SUPPORTED__ **/

#endif