file.c

最新版IAR FOR ARM（EWARM）5.11中的代码例子

/*****************************************************************************\
*              efs - General purpose Embedded Filesystem library              *
*          --------------------- -----------------------------------          *
*                                                                             *
* Filename : file.c                                                           *
* Description : This file contains functions dealing with files such as:      *
*               fopen, fread and fwrite.                                      *
*                                                                             *
* This program is free software; you can redistribute it and/or               *
* modify it under the terms of the GNU General Public License                 *
* as published by the Free Software Foundation; version 2                     *
* of the License.                                                             *
                                                                              *
* This program is distributed in the hope that it will be useful,             *
* but WITHOUT ANY WARRANTY; without even the implied warranty of              *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               *
* GNU General Public License for more details.                                *
*                                                                             *
* As a special exception, if other files instantiate templates or             *
* use macros or inline functions from this file, or you compile this          *
* file and link it with other works to produce a work based on this file,     *
* this file does not by itself cause the resulting work to be covered         *
* by the GNU General Public License. However the source code for this         *
* file must still be made available in accordance with section (3) of         *
* the GNU General Public License.                                             *
*                                                                             *
* This exception does not invalidate any other reasons why a work based       *
* on this file might be covered by the GNU General Public License.            *
*                                                                             *
*                                                    (c)2006 Lennart Yseboodt *
*                                                    (c)2006 Michael De Nil   *
\*****************************************************************************/

/*****************************************************************************/
#include "file.h"
/*****************************************************************************/

/* ****************************************************************************
 * euint32 file_fread(File *file,euint32 offset, euint32 size,euint8 *buf)
 * Description: This function reads 'size' bytes from 'file' starting at
 * 'offset' and puts the result in '*buf'.
 * Return value: amount of bytes actually read (can differ from the given
 * size when the file was smaller
*/
euint32 file_fread(File *file,euint32 offset, euint32 size,euint8 *buf)
{
    euint32 bytes_read=0,size_left=size,coffset=offset;
    euint32 cclus,csec,cbyte;
    euint32 rclus,rsec;
    euint32 btr;
    euint8 *tbuf;

    if(!file_getAttr(file,FILE_STATUS_OPEN))return(0);

    if(offset>=file->FileSize)
        size_left=0; /* Offset check */

    if( (offset+size > file->FileSize) && size_left!=0)
        size_left=file->FileSize-offset;

    while(size_left>0){

        cclus = coffset/(512*file->fs->volumeId.SectorsPerCluster);
        csec = (coffset/(512))%file->fs->volumeId.SectorsPerCluster;
        cbyte = coffset%512;

        if(cbyte!=0 || size_left<512){
            btr = 512-(coffset%512)>=size_left?size_left:512-(coffset%512);
        }else{
            btr = 512;
        }

        if((fat_LogicToDiscCluster(file->fs,&(file->Cache),cclus))!=0){
            return(0);
        }
        rclus=file->Cache.DiscCluster;
        rsec=fs_clusterToSector(file->fs,rclus);


        if(btr==512){
            /*part_readBuf(file->fs->part,rsec+csec,buf+bytes_read);*/
            part_directSectorRead(file->fs->part,rsec+csec,buf+bytes_read);
        }else{
            /*part_readBuf(file->fs->part,rsec+csec,tbuf);*/
            tbuf = part_getSect(file->fs->part,rsec+csec,IOM_MODE_READONLY);
            memCpy(tbuf+(coffset%512),buf+bytes_read,btr);
            part_relSect(file->fs->part,tbuf);
        }

        coffset+=btr;
        bytes_read+=btr;
        size_left-=btr;
    }

    return(bytes_read);
}
/*****************************************************************************/

/* ****************************************************************************
 * euint32 file_read (File *file,euint32 size,euint8 *buf)
 * Description: This function reads from a file, taking the FilePtr into account
 * and advancing it according to the freadcall.
 * Return value: Value obtained from fread
*/
euint32 file_read(File *file,euint32 size,euint8 *buf)
{
    euint32 r;

    r=file_fread(file,file->FilePtr,size,buf);
    file->FilePtr+=r;
    return(r);
}
/*****************************************************************************/

/* ****************************************************************************
 * euint32 file_write(File *file, euint32 size,euint8 *buf)
 * Description: This function writes to a file, taking FilePtr into account
 * and advancing it according to the fwritecall.
 * Return value: Value obtained from fread
*/
euint32 file_write(File *file, euint32 size,euint8 *buf)
{
    euint32 r;

    r=file_fwrite(file,file->FilePtr,size,buf);
    file->FilePtr+=r;
    return(r);
}
/*****************************************************************************/

/* ****************************************************************************
 * esint16 file_setpos(File *file,euint32 pos)
 * Description: This function does a sanity check on the requested position
 * and changes the fileptr accordingly.
 * Return value: 0 on success and -1 on failure.
*/
esint16 file_setpos(File *file,euint32 pos)
{
    if(pos<=file->FileSize){
        file->FilePtr=pos;
        return(0);
    }
    return(-1);
}
/*****************************************************************************/

/* ****************************************************************************
 * euint32 file_fwrite(File* file,euint32 offset,euint32 size,euint8* buf)
 * Description: This function writes to a file, at offset 'offset' and size 'size'.
 * It also updates the FileSize in the object, and discstructure.
 * Return value: Bytes actually written.
*/
euint32 file_fwrite(File* file,euint32 offset,euint32 size,euint8* buf)
{
    euint32 need_cluster;
    euint32 cclus,csec,cbyte;
    euint32 size_left=size,bytes_written=0;
    euint32 rclus,rsec;
    euint32 coffset=offset;
    euint16 btr;
    euint8 *tbuf;

    if(!file_getAttr(file,FILE_STATUS_OPEN) || !file_getAttr(file,FILE_STATUS_WRITE))return(0);

    if(offset>file->FileSize){
        offset=file->FileSize;
    }

    need_cluster = file_requiredCluster(file,offset,size);

    if(need_cluster){
        if(fat_allocClusterChain(file->fs,&(file->Cache),need_cluster+CLUSTER_PREALLOC_FILE)!=0){
            return(0);
        }
    }

    while(size_left>0){

        cclus = coffset/(512*file->fs->volumeId.SectorsPerCluster);
        csec = (coffset/(512))%file->fs->volumeId.SectorsPerCluster;
        cbyte = coffset%512;

        if(cbyte!=0 || size_left<512){
            btr = 512-(coffset%512)>=size_left?size_left:512-(coffset%512);
        }else{
            btr = 512;
        }

        if((fat_LogicToDiscCluster(file->fs,&(file->Cache),cclus))!=0){
            file->FileSize+=bytes_written;
            dir_setFileSize(file->fs,&(file->Location),file->FileSize);
            return(bytes_written);
        }
        rclus=file->Cache.DiscCluster;
        rsec=fs_clusterToSector(file->fs,rclus);

        if(btr==512){
            /*part_writeBuf(file->fs->part,rsec+csec,buf+bytes_written);*/
            part_directSectorWrite(file->fs->part,rsec+csec,buf+bytes_written);
        }else{
            /*part_readBuf(file->fs->part,rsec+csec,tbuf);*/
            tbuf = part_getSect(file->fs->part,rsec+csec,IOM_MODE_READWRITE);
            memCpy(buf+bytes_written,tbuf+(coffset%512),btr);
            /*part_writeBuf(file->fs->part,rsec+csec,tbuf);*/
            part_relSect(file->fs->part,tbuf);
        }

        coffset+=btr;
        bytes_written+=btr;
        size_left-=btr;
    }

    if(bytes_written>file->FileSize-offset){
        file->FileSize+=bytes_written-(file->FileSize-offset);
    }

    return(bytes_written);
}

/* ***************************************************************************\
 * signed eint8 file_fopen(FileSystem *fs,File* file,eint8* filename)
 * Description: This functions opens a file.
 * This function is about to be redesigned. No Docs.
 * Return value:
*/
esint8 file_fopen(File* file,FileSystem *fs,eint8* filename,eint8 mode)
{
    FileLocation loc;
    FileRecord wtmp;
    eint8 fatfilename[11];
    euint32 sec;

    dir_getFatFileName(filename,fatfilename);

    switch(mode)
    {
        case MODE_READ:
            if(fs_findFile(fs,filename,&loc,0)==1)
            {
                dir_getFileStructure(fs,&(file->DirEntry), &loc);
                file_initFile(file,fs,&loc);
                file_setAttr(file,FILE_STATUS_OPEN,1);
                file_setAttr(file,FILE_STATUS_WRITE,0);
                return(0);
            }
            return(-1);
        case MODE_WRITE:
            if(fs_findFile(fs,filename,&loc,&sec)) /* File may NOT exist, but parent HAS to exist */
            {