files.c

ADAM2 sources (modified by Oleg)

    }         
  _StreamOut(FILER);
  _StreamOut(FOPEN);
  _FilePutString(file_name);
  _FilePutString(mode);
  if (!_FileHandlerResponce(FOPEN)) 
    {
    SioLock(FALSE);
    return(0);   
    }
  if (!_FileGetBit32(&handle)) 
    {
    SioLock(FALSE);
    return(0);   
    }
  if (!handle)
    {
    SioLock(FALSE);
    return(0);   
    }
  pFCB->SubFileSystem=(FFS_FILE *)handle;
  pFCB->_FileState=FILE_OPEN;
  pFCB->_SubSystemType=FILE_SIO;
  SioLock(FALSE);
  return(pFCB);
  }

int _SioFileClose(FFS_FILE *handle)
  {
  char cTmp;
  bit32 lTmp;

  if (!handle->_FileState)
    return(EOF);  
  SioFlush();
  SioLock(TRUE);
  if (!_FileHandlerCheck()) 
    {
    SioLock(FALSE);
    return(EOF);   
    }
  _StreamOut(FILER);
  _StreamOut(FCLOSE);
  _FilePutBit32((bit32)handle->SubFileSystem);
  handle->_FileState=FILE_FREE;
  if (!_FileHandlerResponce(FCLOSE)) 
    {
    SioLock(FALSE);
    return(EOF);   
    }
  if (!_FileGetByte(&cTmp))
    {
    SioLock(FALSE);
    return(EOF);   
    }
  lTmp=((bit32)cTmp)&0x0ffl;
  SioLock(FALSE);
  return(lTmp);
  }

size_t _SioFileRead(void *buf, size_t size, size_t count, FFS_FILE *fp)
  {
  bit32 lLen;
  int i;
  bit8 *TmpBuf;
  
  TmpBuf=(bit8 *)buf;        
  if (!fp->_FileState)
    return(0);
  SioFlush();
  SioLock(TRUE);
  if (!_FileHandlerCheck()) 
    {
    Zap(1);
    SioLock(FALSE);
    return(0);   
    }
  _StreamOut(FILER);
  _StreamOut(FREAD);
  _FilePutBit32((bit32)fp->SubFileSystem);
  _FilePutBit32(count*size);
  if (!_FileHandlerResponce(FREAD)) 
    {
    Zap(2);
    SioLock(FALSE);
    return(0);   
    }
  if (!_FileGetBit32(&lLen))
    {
    Zap(3);
    SioLock(FALSE);
    return(0);   
    }
  for (i=0;i<lLen;i++)
    {
    if (!_FileGetByte((char *)TmpBuf))
      {
      Zap(4);
      SioLock(FALSE);
      return(0);   
      }
    TmpBuf++;
    }
  SioLock(FALSE);
  return(lLen/size);
  }

size_t _SioFileWrite(const void *buf, size_t size, size_t count, FFS_FILE *fp)
  {
  bit32 lLen,lIndex;
  bit8 *TmpBuf=(bit8 *)buf;

  if (!fp->_FileState)
    return(0);
  SioFlush();
  SioLock(TRUE);
  if (!_FileHandlerCheck()) 
    {
    SioLock(FALSE);
    return(0);   
    }
  _StreamOut(FILER);
  _StreamOut(FWRITE);
  _FilePutBit32((bit32)fp->SubFileSystem);
  _FilePutBit32(count*size);
  for (lIndex=0;lIndex<(size*count);lIndex++)
    _StreamOut(*TmpBuf++);
  if (!_FileHandlerResponce(FWRITE)) 
    {
    SioLock(FALSE);
    return(0);   
    }
  if (!_FileGetBit32(&lLen))
    {
    SioLock(FALSE);
    return(0);   
    }
  SioLock(FALSE);
  return(lLen/size);
  }

bit32 fgetc(FFS_FILE *fh)
  {
  char tmp;
  bit32 len;

  len = fread(&tmp,1,1,fh);
  if(len == 0)
    tmp = EOF;
  return(tmp);
  }

int IsFileExist(char *ifile, char *imode)
  {
  FFS_FILE *FilePtr = NULL;
                 
  FilePtr=fopen(ifile,"r");
  if (!FilePtr) return(FALSE); 
  fclose(FilePtr);
  return(TRUE);
  }

int remove(const char *filename)
  {
  int sts = 0;

  if (filename[1]==':')
    sts=_SioFileRemove(filename);
  else
    sts=ffs_remove(filename);
  return(sts);
  }

FFS_FILE *fopen(const char *filename, const char *type)
  {
  FFS_FILE *fptr = NULL;

  if (filename[1]==':')
    fptr=_SioFileOpen(filename,type);
  else
	fptr=ffs_fopen(filename,type);
  return(fptr);
  }

size_t fread(void *ptr, size_t size, size_t nitems, FFS_FILE *stream)
  {
  if (stream->_SubSystemType==FILE_SIO)
    return(_SioFileRead(ptr,size,nitems,stream));
  if (stream->_SubSystemType==FILE_FLASH)
    return(ffs_fread(ptr,size,nitems,stream));
  return(0);
  }

size_t fwrite(const void *ptr, size_t size, size_t nitems, FFS_FILE *stream)
  {
  if (stream->_SubSystemType==FILE_SIO)
    return(_SioFileWrite(ptr,size,nitems,stream));
  if (stream->_SubSystemType==FILE_FLASH)
    return(ffs_fwrite(ptr,size,nitems,stream));
  return(0);
  }

int fseek(FFS_FILE *stream, bit32 offset, int ptrname)
  {
  if (stream->_SubSystemType==FILE_SIO)
    return(_SioFileSeek(stream,offset,ptrname));
  if (stream->_SubSystemType==FILE_FLASH)
    return(ffs_fseek(stream,offset,ptrname));
  return(0);
  }

void rewind(FFS_FILE *stream)
  { 
  fseek(stream,0,FFS_SEEK_SET);
  return;
  }

bit32 ftell(FFS_FILE *stream)
  {
  sys_printf("%stell - not implemented yet!\n", stream->_SubSystemType==FILE_SIO?"_SioFile":"FlashFile");
  return(0);
  }

int fflush(FFS_FILE *stream)
  {
  sys_printf("%sflush - not implemented yet!\n", stream->_SubSystemType==FILE_SIO?"_SioFile":"FlashFile");
  return(0);
  }

int feof(FFS_FILE *stream)
  {
  sys_printf("%sEof - not implemented yet!\n", stream->_SubSystemType==FILE_SIO?"_SioFile":"FlashFile");
  return(0);
  }

int fclose(FFS_FILE *stream)
  {
  if (stream->_SubSystemType==FILE_SIO)
    return(_SioFileClose(stream));
  if (stream->_SubSystemType==FILE_FLASH)
    return(ffs_fclose(stream));
  return(0);
  }  

int  _SioFileSeek(FFS_FILE *stream, bit32 offset, int ptrname)
  {
  char cTmp;
  
  if (!stream->_FileState)
    return(0);
  SioFlush();
  SioLock(TRUE);
  if (!_FileHandlerCheck()) 
    {
    Zap(5);
    SioLock(FALSE);
    return(0);   
    }
  _StreamOut(FILER);
  _StreamOut(FSEEK);
  _FilePutBit32((bit32)stream->SubFileSystem);
  _FilePutBit32(offset);
  _FilePutShort(ptrname);
  if (!_FileHandlerResponce(FSEEK)) 
    {
    Zap(6);
    SioLock(FALSE);
    return(0);   
    }
  if (!_FileGetByte(&cTmp))
    {
    Zap(7);
    SioLock(FALSE);
    return(0);   
    }
  SioLock(FALSE);
  return(cTmp);
  }

#include "_stdarg.h"          
#define MAX_STRING_SIZE 256         
int sys_fprintf(FFS_FILE *fp, const char *format, ...)
  {
  int     count;
  va_list ap;
  char    buffer[MAX_STRING_SIZE];

  va_start(ap, format);
  count = sys_vsprintf(buffer, (char *)format, ap);
  va_end(ap); 
  count=fwrite(buffer,1,count,fp);
  return (count);
  }