home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Misc / DC-POS24.LZX / pOS / pOSxA.lzx / pOSxA / clib / dos_protos.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-03-12  |  15.6 KB  |  512 lines
  1. #ifndef __INC_POSA_CLIB_DOS_PROTOS_C
  2. #define __INC_POSA_CLIB_DOS_PROTOS_C
  3. /*******************************************************************
  4.  $CRT 17 Mar 1996 : hb
  5.  
  6.  $AUT Holger Burkarth
  7.  $DAT >>dos_protos.c<<   31 Jan 1997    09:56:14 - (C) ProDAD
  8. *******************************************************************/
  9. #pragma -
  10.  
  11. #define NOMYDEBUG
  12.  
  13.  
  14. #include <exec/types.h>
  15.  
  16. #include <p:pExec/Types.h>
  17. #include <p:proto/pDos2.h>
  18. #include <p:pDos/DosTags.h>
  19.  
  20. // mcpp:cppc -c ci:_Projekte/pOSxA/clib/dos_protos.c -pc
  21.  
  22.  
  23.  
  24. #pragma -
  25. #include <p:pDOS/Process.h>
  26. #include <dos/dos.h>
  27. #include <dos/dosextens.h>
  28.  
  29.  
  30.  
  31. BPTR Open( STRPTR name, long accessMode )
  32.   { return((BPTR)pOS_OpenFile(NULL,(CHAR*)name,accessMode)); }
  33.  
  34. LONG Close( BPTR file )
  35.   {  pOS_CloseFile((APTR)file);  return(0);}
  36.  
  37. LONG Read( BPTR file, APTR buffer, long length )
  38.   { return(pOS_ReadFile((APTR)file,buffer,length)); }
  39.  
  40. LONG Write( BPTR file, APTR buffer, long length )
  41.   {  return(pOS_WriteFile((APTR)file,buffer,length));}
  42.  
  43. BPTR Input( void )
  44.   {  return((BPTR)pOS_GetStdInput()); }
  45.  
  46. BPTR Output( void )
  47.   { return((BPTR)pOS_GetStdInput()); }
  48.  
  49. LONG Seek( BPTR file, long position, long offset )
  50.   { return(pOS_SeekFile((APTR)file,position,offset)); }
  51.  
  52. LONG DeleteFile( STRPTR name )
  53.   {  return(pOS_DeleteObjectName(NULL,(CHAR*)name)); }
  54.  
  55. LONG Rename( STRPTR oldName, STRPTR newName )
  56.   { return( pOS_RenameObjectName(NULL,(CHAR*)oldName,(CHAR*)newName)); }
  57.  
  58. BPTR Lock( STRPTR name, long type )
  59.   { return((BPTR)pOS_LockObject(NULL,(CHAR*)name,type));}
  60.  
  61. VOID UnLock( BPTR lock )
  62.   { pOS_UnlockObject((APTR)lock); }
  63.  
  64. BPTR DupLock( BPTR lock )
  65.   { return((BPTR)pOS_DupObjectLock((APTR)lock)); }
  66.  
  67. LONG Examine( BPTR lock, struct FileInfoBlock *fileInfoBlock )
  68.   {
  69.     SLONG Res=pOS_ExamineObject((APTR)lock,(APTR)fileInfoBlock);
  70.     if(fileInfoBlock->fib_DirEntryType & FINFENTYP_File)
  71.          fileInfoBlock->fib_DirEntryType |=  0x80;
  72.     else fileInfoBlock->fib_DirEntryType &= ~0x80;
  73.     return(Res);
  74.   }
  75.  
  76. LONG ExNext( BPTR lock, struct FileInfoBlock *fileInfoBlock )
  77.   {
  78.     SLONG Res=pOS_ExNextObject((APTR)lock,(APTR)fileInfoBlock);
  79.     if(fileInfoBlock->fib_DirEntryType & FINFENTYP_File)
  80.          fileInfoBlock->fib_DirEntryType |=  0x80;
  81.     else fileInfoBlock->fib_DirEntryType &= ~0x80;
  82.     return(Res);
  83.   }
  84.  
  85. LONG Info( BPTR lock, struct InfoData *parameterBlock )
  86.   {  return(pOS_GetDosInfoData((APTR)lock,(APTR)parameterBlock)); }
  87.  
  88. BPTR CreateDir( STRPTR name )
  89.   { return((BPTR)pOS_CreateDirectory(NULL,(CHAR*)name));}
  90.  
  91. BPTR CurrentDir( BPTR lock )
  92.   { return((BPTR)pOS_SetCurrentDirLock((APTR)lock));}
  93.  
  94. LONG IoErr(void)
  95.   { return(pOS_GetIoErr()); }
  96.  
  97. BPTR LoadSeg( STRPTR name )
  98.   { return((BPTR)pOS_LoadSegmentA((CHAR*)name,NULL));}
  99.  
  100. LONG UnLoadSeg( BPTR seglist )
  101.   { pOS_UnloadSegment((APTR)seglist); return(1);}
  102.  
  103. LONG SetComment( STRPTR name, STRPTR comment )
  104.   { return(pOS_SetObjectCommentName(NULL,(CHAR*)name,(CHAR*)comment)); }
  105.  
  106. LONG SetProtection( STRPTR name, long protect )
  107.   { return(pOS_SetObjectProtectionName(NULL,(CHAR*)name,protect)); }
  108.  
  109. struct DateStamp *DateStamp( struct DateStamp *date )
  110.   { return((APTR)pOS_GetDateStamp((APTR)date));}
  111.  
  112. struct DateStamp *pOS_DateStamp( struct DateStamp *date ) /** pOS **/
  113.   { return((APTR)pOS_GetDateStamp((APTR)date)); }
  114.  
  115. void Delay( long timeout )
  116.   { pOS_DosDelay(timeout); }
  117.  
  118. BPTR ParentDir( BPTR lock )
  119.   { return((BPTR)pOS_ParentObjectDir((APTR)lock)); }
  120.  
  121. LONG IsInteractive( BPTR file )
  122.   { return(pOS_IsFileInteractive((APTR)file)); }
  123.  
  124. APTR AllocDosObject( unsigned long type, struct TagItem *tags )
  125.   {  return(pOS_AllocDosObject(type,0)); }
  126.  
  127. APTR AllocDosObjectTagList( unsigned long type, struct TagItem *tags )
  128.   {  return(pOS_AllocDosObject(type,0)); }
  129.  
  130. APTR AllocDosObjectTags( unsigned long type, unsigned long tag1type, ... )
  131.   {  return(pOS_AllocDosObject(type,0)); }
  132.  
  133. void FreeDosObject( unsigned long type, APTR ptr )
  134.   {  pOS_FreeDosObject(type,ptr);}
  135.  
  136. BPTR SelectInput( BPTR fh )
  137.   { return((BPTR)pOS_SetStdInput((struct pOS_FileHandle*)fh));}
  138.  
  139. BPTR SelectOutput( BPTR fh )
  140.   { return((BPTR)pOS_SetStdOutput((struct pOS_FileHandle*)fh));}
  141.  
  142. LONG FGetC( BPTR fh )
  143.   { return(pOS_FileGetC((APTR)fh)); }
  144.  
  145. LONG FPutC( BPTR fh, long ch )
  146.   { return(pOS_FilePutC((APTR)fh,ch)); }
  147.  
  148. LONG UnGetC( BPTR fh, long ch)
  149.   { return(pOS_FileUnGetC((APTR)fh,ch)); }
  150.  
  151. LONG FRead( BPTR fh, APTR block, unsigned long blocklen,unsigned long number)
  152.   {  return( pOS_FileFRead((APTR)fh,block,blocklen,number));}
  153.  
  154. LONG FWrite( BPTR fh, APTR block, unsigned long blocklen,unsigned long number )
  155.   {  return( pOS_FileFWrite((APTR)fh,(APTR)block,blocklen,number)); }
  156.  
  157. STRPTR FGets( BPTR fh, STRPTR buf, unsigned long buflen )
  158.   { return(pOS_FileGets((APTR)fh,buf,buflen));}
  159.  
  160. LONG FPuts( BPTR fh, STRPTR str )
  161.   {   return(pOS_FilePuts((APTR)fh,str));}
  162.  
  163. void VFWritef( BPTR fh, STRPTR format, LONG *argarray )
  164.   {  pOS_VFWritef((APTR)fh,(CHAR*)format,(APTR)argarray); }
  165.  
  166. LONG Flush( BPTR fh )
  167.   {  return(pOS_FileFlush((APTR)fh)); }
  168.  
  169. LONG SetVBuf( BPTR fh, STRPTR buff, long type, long size )
  170.   {  return(pOS_SetFileHandleBuf((APTR)fh,buff,type,size)); }
  171.  
  172. BPTR OpenFromLock( BPTR lock )
  173.  { return((BPTR)pOS_OpenFileFromLock((APTR)lock));}
  174.  
  175. BOOL ExamineFH( BPTR fh, struct FileInfoBlock *fib )
  176.   {  return(pOS_ExamineFH((APTR)fh,(APTR)fib)); }
  177.  
  178. LONG SetFileDate( STRPTR name, struct DateStamp *date )
  179.   { return(pOS_SetObjectDateName(NULL,(CHAR*)name,(APTR)date));}
  180.  
  181. LONG NameFromLock( BPTR lock, STRPTR buffer, long len )
  182.   { return(pOS_NameFromObjectLock((APTR)lock,(CHAR*)buffer,len)); }
  183.  
  184. LONG NameFromFH( BPTR fh, STRPTR buffer, long len )
  185.   { return(pOS_NameFromFH((APTR)fh,(CHAR*)buffer,len)); }
  186.  
  187. WORD SplitName(STRPTR name,unsigned long seperator,STRPTR buf,long oldpos,long size )
  188.   { return(pOS_SplitName((APTR)name,seperator,(CHAR*)buf,oldpos,size)); }
  189.  
  190. LONG SameLock( BPTR lock1, BPTR lock2 )
  191.   { return(pOS_SameDosObject((APTR)lock1,(APTR)lock2));}
  192.  
  193. LONG SetMode( BPTR fh, long mode )
  194.   { return(pOS_SetDosScreenMode((APTR)fh,mode));}
  195.  
  196. LONG ChangeMode( long type, BPTR fh, long newmode )
  197.   {
  198.     if(type==0) return(pOS_ChangeDosObjectAccess((APTR)fh,newmode));
  199.     else        return(pOS_ChangeDosFileAccess((APTR)fh,newmode));
  200.   }
  201.  
  202. LONG SetIoErr( long result )
  203.   {  return(pOS_SetIoErr(result)); }
  204.  
  205. BOOL PrintFault( long code, STRPTR header )
  206.   {  return(pOS_PrintDosErr(NULL,(CHAR*)header,code)); }
  207.  
  208. struct Process *CreateNewProc( struct TagItem *tags )
  209.   {
  210.     struct pOS_TagItem Tags[]={
  211.       DOSTAG_DefaultProc, FALSE,
  212.       TAG_MORE,           (ULONG)tags
  213.     };
  214.     return((APTR)pOS_CreateProcessA(Tags));
  215.   }
  216.  
  217. struct Process *CreateNewProcTagList( struct TagItem *tags )
  218.   {  return((APTR)CreateNewProc((APTR)tags)); }
  219.  
  220. struct Process *CreateNewProcTags( unsigned long tag1type, ... )
  221.   {  return((APTR)CreateNewProc((APTR)&tag1type)); }
  222.  
  223. BOOL SetCurrentDirName( STRPTR name )
  224.   {  return(pOS_SetCurrentDirName((CHAR*)name));}
  225.  
  226. BOOL GetCurrentDirName( STRPTR buf, long len )
  227.   {  return(pOS_GetCurrentDirName((CHAR*)buf,len));}
  228.  
  229. BOOL SetPrompt( STRPTR name )
  230.   { return(pOS_SetPrompt((CHAR*)name));}
  231.  
  232. BOOL GetPrompt( STRPTR buf, long len )
  233.   { return(pOS_GetPrompt((CHAR*)buf,len));}
  234.  
  235. BPTR SetProgramDir( BPTR lock )
  236.   {return((BPTR)pOS_SetProgDir((APTR)lock)); }
  237.  
  238. BPTR GetProgramDir( void )
  239.   {return((BPTR)pOS_GetProgDir());}
  240.  
  241. LONG SystemTagList( STRPTR command, struct TagItem *tags )
  242.   {  return(pOS_SystemA((CHAR*)command,(APTR)tags)); }
  243.  
  244. LONG System( STRPTR command, struct TagItem *tags )
  245.   {  return(pOS_SystemA((CHAR*)command,(APTR)tags)); }
  246.  
  247. LONG SystemTags( STRPTR command, unsigned long tag1type, ... )
  248.   {  return(pOS_SystemA((CHAR*)command,(APTR)&tag1type)); }
  249.  
  250. BOOL IsFileSystem( STRPTR name )
  251.   { return(pOS_IsFileSystemName(NULL,(CHAR*)name)); }
  252.  
  253. LONG Relabel( STRPTR drive, STRPTR newname )
  254.   { return(pOS_RelabelDosDevice(pOS_GetDosDevice(NULL,(CHAR*)drive),(CHAR*)newname));}
  255.  
  256. LONG Inhibit( STRPTR name, long onoff )
  257.   { return(pOS_InhibitDosDevice(pOS_GetDosDevice(NULL,(CHAR*)name),onoff));}
  258.  
  259. LONG AddBuffers( STRPTR name, long number )
  260.   { return(pOS_AddDosDeviceBuffers(pOS_GetDosDevice(NULL,(CHAR*)name),number*512));}
  261.  
  262. LONG CompareDates( struct DateStamp *date1, struct DateStamp *date2 )
  263.   {  return(pOS_CompareDates((APTR)date1,(APTR)date2)); }
  264.  
  265. LONG DateToStr( struct DateTime *datetime )
  266.   {  return(pOS_DateToStr((APTR)datetime)); }
  267.  
  268. LONG StrToDate( struct DateTime *datetime )
  269.   {   return(pOS_StrToDate((APTR)datetime)); }
  270.  
  271. LONG CheckSignal( long mask )
  272.   { return(pOS_DosCheckSignal(mask));}
  273.  
  274. struct RDArgs *ReadArgs( STRPTR arg_template, LONG *array,struct RDArgs *args )
  275.   { return((APTR)pOS_ReadDosArgsA((CHAR*)arg_template,(APTR)array,-1,NULL));}
  276.  
  277. LONG MatchFirst( STRPTR pat, struct AnchorPath *anchor )
  278.   { return(pOS_PathMatchFirst(NULL,(CHAR*)pat,(APTR)anchor,NULL,0));}
  279.  
  280. LONG MatchNext( struct AnchorPath *anchor )
  281.   { return(pOS_PathMatchNext((APTR)anchor));}
  282.  
  283. void MatchEnd( struct AnchorPath *anchor )
  284.   { pOS_PathMatchEnd((APTR)anchor);}
  285.  
  286. void FreeArgs( struct RDArgs *args )
  287.   { pOS_DeleteDosArgs((APTR)args);}
  288.  
  289. STRPTR FilePart( STRPTR path )
  290.   { return((STRPTR)pOS_FilePart((CHAR*)path));}
  291.  
  292. STRPTR PathPart( STRPTR path )
  293.   { return((STRPTR)pOS_PathPart((CHAR*)path)); }
  294.  
  295. BOOL AddPart( STRPTR dirname, STRPTR filename, unsigned long size )
  296.   { return(pOS_AddPart((CHAR*)dirname,(CHAR*)filename,size)); }
  297.  
  298. BOOL StartNotify( struct NotifyRequest *notify )
  299.   { return(pOS_DosStartNotify((APTR)notify)); }
  300.  
  301. void EndNotify( struct NotifyRequest *notify )
  302.   { pOS_DosEndNotify((APTR)notify); }
  303.  
  304. BOOL SetVar( STRPTR name, STRPTR buffer, long size, long flags )
  305.   { return(pOS_SetVar((CHAR*)name,(UBYTE*)buffer,size,flags,NULL));}
  306.  
  307. LONG GetVar( STRPTR name, STRPTR buffer, long size, long flags )
  308.   { return(pOS_GetVar((CHAR*)name,(UBYTE*)buffer,size,flags,NULL));}
  309.  
  310. LONG DeleteVar( STRPTR name, unsigned long flags )
  311.   { return(pOS_DeleteVar((CHAR*)name,flags,NULL));}
  312.  
  313. struct LocalVar *FindVar( STRPTR name, unsigned long type )
  314.   { return((APTR)pOS_FindVar((CHAR*)name,type,NULL));}
  315.  
  316. BOOL SameDevice( BPTR lock1, BPTR lock2 )
  317.   { return(pOS_SameDosDevice((APTR)lock1,(APTR)lock2));}
  318.  
  319.  
  320. /*MIC*/ void FWritef( BPTR fh, STRPTR format, ... )
  321.   { pOS_VFWritef((struct pOS_FileHandle *)fh,format,(APTR) ((&format)+1)); }
  322.  
  323.  
  324. /*MIC*/ LONG WriteChars( STRPTR buf, unsigned long buflen )
  325.   {
  326.     return( pOS_WriteFile(pOS_GetStdOutput(),buf,buflen) );
  327.   }
  328.  
  329. /*MIC*/ LONG PutStr( STRPTR str )
  330.   {
  331.     return( pOS_FilePuts(pOS_GetStdOutput(),str) );
  332.   }
  333.  
  334. /*MIC*/ LONG VPrintf( STRPTR format, APTR argarray )
  335.   { return( pOS_VFWritef(pOS_GetStdOutput(),format,argarray) ); }
  336.  
  337. /*MIC*/ LONG Printf( STRPTR format, ... )
  338.   { return( pOS_VFWritef(pOS_GetStdOutput(),format,(APTR) ((&format)+1)) ); }
  339.  
  340. LONG Execute( STRPTR string, BPTR file, BPTR file2 )
  341.   {
  342.     return( pOS_System((CHAR*)string,
  343.         DOSTAG_Synchronous, TRUE,
  344.         DOSTAG_InputFH,     (ULONG)file,
  345.         DOSTAG_OutputFH,    (ULONG)file,
  346.         DOSTAG_StackSize,   (ULONG)~0,
  347.         TAG_END)==0);
  348.   }
  349.  
  350. LONG RunCommand( BPTR seg, long stack, STRPTR paramptr, long paramlen )
  351.   {
  352.     return( pOS_RunCommand((struct pOS_SegmentLst*)seg,stack,NULL,NULL,NULL,paramptr) );
  353.   }
  354.  
  355. LONG AssignLock( STRPTR name, BPTR lock )
  356.   {
  357.     return( pOS_CreateDosAssign((CHAR*)name,(struct pOS_FileLock*)lock,
  358.                                 NULL,DDTYP_Assign) != NULL );
  359.   }
  360.  
  361. BOOL AssignLate( STRPTR name, STRPTR path )
  362.   {
  363.     return( pOS_CreateDosAssign((CHAR*)name,NULL,path,DDTYP_LateAssign) != NULL );
  364.   }
  365.  
  366. BOOL AssignPath( STRPTR name, STRPTR path )
  367.   {
  368.     return( pOS_CreateDosAssign((CHAR*)name,NULL,path,DDTYP_NonBindingAssign) != NULL );
  369.   }
  370.  
  371. BOOL AssignAdd( STRPTR name, BPTR lock )
  372.   {
  373.     return( pOS_AddDosAssign((CHAR*)name,(struct pOS_FileLock*)lock,0) != NULL );
  374.   }
  375.  
  376. LONG RemAssignList( STRPTR name, BPTR lock )
  377.   {
  378.     return( pOS_DeleteDosAssign((CHAR*)name,(struct pOS_FileLock*)lock,0) );
  379.   }
  380.  
  381. BPTR NewLoadSeg( STRPTR file, struct TagItem *tags )
  382.   { return((BPTR)pOS_LoadSegmentA((CHAR*)file,(struct pOS_TagItem*)tags));}
  383.  
  384. BPTR NewLoadSegTagList( STRPTR file, struct TagItem *tags )
  385.   { return((BPTR)pOS_LoadSegmentA((CHAR*)file,(struct pOS_TagItem*)tags));}
  386.  
  387. BPTR NewLoadSegTags( STRPTR file, unsigned long tag1type, ... )
  388.   { return((BPTR)pOS_LoadSegmentA((CHAR*)file,(struct pOS_TagItem*)&tag1type));}
  389.  
  390.  
  391.  
  392.  
  393.  
  394. #ifdef __IGNORE_NOT_SUPPORTED__
  395.  
  396. BOOL Fault( long code, STRPTR header, STRPTR buffer, long len )
  397. {return(0);}
  398.  
  399.  
  400.  
  401.  
  402. struct MsgPort *CreateProc( STRPTR name, long pri, BPTR segList,long stackSize )
  403. {return(0);}
  404. void Exit( long returnCode )
  405.   { pOS_SetShellFail(returnCode); }
  406. struct MsgPort *DeviceProc( STRPTR name )
  407. {return(0);}
  408. LONG WaitForChar( BPTR file, long timeout )
  409. {return(0);}
  410. BOOL LockRecord( BPTR fh,ULONG offset,ULONG length,ULONG mode,ULONG timeout )
  411. {return(0);}
  412. BOOL LockRecords( struct RecordLock *recArray, unsigned long timeout )
  413. {return(0);}
  414. BOOL UnLockRecord( BPTR fh, unsigned long offset, unsigned long length )
  415. {return(0);}
  416. BOOL UnLockRecords( struct RecordLock *recArray )
  417. {return(0);}
  418. BPTR ParentOfFH( BPTR fh )
  419. {return(0);}
  420. LONG ExAll(BPTR lock,struct ExAllData *buffer,long size,long data,struct ExAllControl *control)
  421. {return(0);}
  422. LONG ReadLink(struct MsgPort*,BPTR lock,STRPTR path,STRPTR buffer,ULONG size )
  423. {return(0);}
  424. LONG MakeLink( STRPTR name, long dest, long soft )
  425. {return(0);}
  426. LONG SetFileSize( BPTR fh, long pos, long mode )
  427. {return(0);}
  428. LONG ErrorReport( long code, long type, unsigned long arg1,struct MsgPort *device )
  429. {return(0);}
  430. struct CommandLineInterface *Cli( void )
  431. {return(0);}
  432. struct MsgPort *GetConsoleTask( void )
  433. {return(0);}
  434. struct MsgPort *SetConsoleTask( struct MsgPort *task )
  435. {return(0);}
  436. struct MsgPort *GetFileSysTask( void )
  437. {return(0);}
  438. struct MsgPort *SetFileSysTask( struct MsgPort *task )
  439. {return(0);}
  440. STRPTR GetArgStr( void )
  441. {return(0);}
  442. BOOL SetArgStr( STRPTR string )
  443. {return(0);}
  444. struct Process *FindCliProc( unsigned long num )
  445. {return(0);}
  446. ULONG MaxCli( void )
  447. {return(0);}
  448. BOOL SetProgramName( STRPTR name )
  449. {return(0);}
  450. BOOL GetProgramName( STRPTR buf, long len )
  451. {return(0);}
  452. struct DevProc *GetDeviceProc( STRPTR name, struct DevProc *dp )
  453. {return(0);}
  454. void FreeDeviceProc( struct DevProc *dp )
  455. {}
  456. struct DosList *LockDosList( unsigned long flags )
  457. {return(0);}
  458. void UnLockDosList( unsigned long flags )
  459. {}
  460. struct DosList *AttemptLockDosList( unsigned long flags )
  461. {return(0);}
  462. BOOL RemDosEntry( struct DosList *dlist )
  463. {return(0);}
  464. LONG AddDosEntry( struct DosList *dlist )
  465. {return(0);}
  466. struct DosList *FindDosEntry( struct DosList *dlist, STRPTR name,unsigned long flags )
  467. {return(0);}
  468. struct DosList *NextDosEntry( struct DosList *dlist, unsigned long flags )
  469. {return(0);}
  470. struct DosList *MakeDosEntry( STRPTR name, long type )
  471. {return(0);}
  472. void FreeDosEntry( struct DosList *dlist )
  473. {}
  474. BOOL Format( STRPTR filesystem, STRPTR volumename, unsigned long dostype )
  475. {return(0);}
  476. BPTR InternalLoadSeg( BPTR fh, BPTR table, LONG *funcarray, LONG *stack )
  477. {return(0);}
  478. BOOL InternalUnLoadSeg( BPTR seglist, void (*freefunc)() )
  479. {return(0);}
  480. LONG AddSegment( STRPTR name, BPTR seg, long system )
  481. {return(0);}
  482. struct Segment *FindSegment( STRPTR name, struct Segment *seg, long system )
  483. {return(0);}
  484. LONG RemSegment( struct Segment *seg )
  485. {return(0);}
  486. LONG FindArg( STRPTR keyword, STRPTR arg_template )
  487. {return(0);}
  488. LONG ReadItem( STRPTR name, long maxchars, struct CSource *cSource )
  489. {return(0);}
  490. LONG StrToLong( STRPTR string, LONG *value )
  491. {return(0);}
  492. LONG ParsePattern( STRPTR pat, STRPTR buf, long buflen )
  493. {return(0);}
  494. BOOL MatchPattern( STRPTR pat, STRPTR str )
  495. {return(0);}
  496. LONG CliInitNewcli( struct DosPacket *dp )
  497. {return(0);}
  498. LONG CliInitRun( struct DosPacket *dp )
  499. {return(0);}
  500. LONG ParsePatternNoCase( STRPTR pat, STRPTR buf, long buflen )
  501. {return(0);}
  502. BOOL MatchPatternNoCase( STRPTR pat, STRPTR str )
  503. {return(0);}
  504. void ExAllEnd( BPTR lock, struct ExAllData *buffer, long size, long data,struct ExAllControl *control )
  505. {}
  506. BOOL SetOwner( STRPTR name, long owner_info )
  507. {return(0);}
  508.  
  509. #endif  /** __IGNORE_NOT_SUPPORTED__ **/
  510.  
  511. #endif
  512.