plx_fs.c

mtk wap和mms代码。。适应mtk 25。26平台

/**************************************************************************\
*
*                      Pollex Mobile Platform
*
* Copyright (c) 2004 by Pollex Mobile Software Co., Ltd.  
*                       All Rights Reserved
*
* Model   :
*
* Purpose :
*  
* Author  : 
*
*-------------------------------------------------------------------------
*
* $Archive::                                                       $
* $Workfile::                                                      $
* $Revision::    $     $Date::                                     $
* 
\**************************************************************************/
#include "..\\..\\plutommi\\mmi\\PlxUI\\Public\\PlxConfig.h"
#if defined(PROJECT_BRANCH_06A)
#include "kal_release.h"
#else
#ifdef MMI_ON_WIN32
#include <windows.h>
#endif
#ifndef MMI_ON_WIN32
#include "kal_release.h"
#endif
#endif // defined(PROJECT_BRANCH_06A)

#include "fs_type.h"
#include "fs_func.h"
#include "fs_errcode.h"

#include "pixteldatatypes.h"
#include "ucs2prot.h"

#ifdef MMI_ON_WIN32
#include "DebugInitDef.h"   /* for PRINT_INFORMATION() */
#endif

#include "plxclib.h"
#include "plxdbg.h"
#include "plxfs.h"


//#define     PLX_FILE_ASCII
//#define     PLX_FILE_UNICODE
#define     PLX_FILE_UTF8

#ifdef PLX_FILE_UTF8
static int  Plx_UTF8ToUnicode( char *strdest, const char *strsrc);
static int  Plx_UnicodeToUTF8( char *strdest, const char *strsrc);
#endif
/*********************************************************************
* Function	   
* Purpose      
* Params	   
* Return	 	   
* Remarks	   
**********************************************************************/


static DWORD plxfs_errno = 0;
void plxfs_SetLastError(DWORD dwErrCode)
{
    plxfs_errno = dwErrCode;
}

DWORD plxfs_GetLastError(void)
{
    return plxfs_errno;
}


FILE * plx_fopen(const char *filename, const char *mode )
{
    UINT flag = 0;
    FS_HANDLE fh;
    WCHAR wFileName[256];
	int append = 0;
	int truncate = 0;

    if( filename == NULL || *filename == 0 )
        return 0;

#ifdef PLX_FILE_ASCII
    AnsiiToUnicodeString((S8 *)wFileName, (S8 *)filename );
#elif defined PLX_FILE_UTF8
    Plx_UTF8ToUnicode( (char*)wFileName, filename);
#endif

#ifdef PLX_FILE_UNICODE
    if ( mode == NULL || *mode == 0 )
        flag = FS_READ_ONLY;	
    else if ( mode[0] == 'r' || mode[0] == 'R') {
        flag = FS_READ_ONLY;
        if ( mode[2] == '+' || ( mode[2] != 0 && mode[4] == '+' ))
            flag = FS_READ_WRITE;
    }
    else if ( mode[0] == 'w' || mode[0] == 'W') {
        flag = FS_READ_WRITE | FS_CREATE;
        if ( mode[2] == '+' || ( mode[2] != 0 && mode[4] == '+' ))
            flag = FS_READ_WRITE | FS_CREATE;
		truncate = 1;
    }else if ( *mode == 'a') {
        flag = FS_READ_WRITE | FS_CREATE;
		append = 1;
	}
#else
    if ( mode == NULL || *mode == 0 )
        flag = FS_READ_ONLY;	
    else if ( *mode == 'r' || *mode == 'R') {
        flag = FS_READ_ONLY;
        if ( mode[1] == '+' || ( mode[1] != 0 && mode[2] == '+' ))
            flag = FS_READ_WRITE;
    }
    else if ( *mode == 'w' || *mode == 'W') {
        flag = FS_READ_WRITE | FS_CREATE;
        if ( mode[1] == '+' || ( mode[1] != 0 && mode[2] == '+' ))
            flag = FS_READ_WRITE | FS_CREATE;
        truncate = 1;
    }else if ( *mode == 'a') {
        flag = FS_READ_WRITE | FS_CREATE;
        append = 1;
    }
#endif

#ifdef PLX_FILE_UNICODE
    fh = FS_Open((WCHAR*)filename, flag);
#else
    fh = FS_Open(wFileName, flag);
#endif

    if ( fh < 0 )
        return NULL;
	if ( append )
		FS_Seek(fh, 0, FS_FILE_END);
	if ( truncate ) {
		FS_Seek(fh, 0, FS_FILE_BEGIN);
		FS_Truncate( fh );
	}

    return (FILE*)fh;
}

int plx_fclose( FILE *stream )
{
    int ret;
    FS_HANDLE fs = (FS_HANDLE)stream;
    if ( fs < 0 )
        return -1;
    ret = FS_Close(fs);
    if ( ret == FS_NO_ERROR)
        return 0;

    return ret;
}

size_t plx_fread( void *buffer, size_t size, size_t count, FILE *stream )
{
    FS_HANDLE fh = (FS_HANDLE)stream;
    unsigned int readnum = size * count;
    unsigned int actnum;
    int ret;

    if ( readnum == 0 )
        return 0;

    ret = FS_Read(fh, buffer,  readnum, &actnum);
    if ( ret == FS_NO_ERROR )
        return actnum;
    plxfs_SetLastError((DWORD)ret);
    return 0;
}

size_t plx_fwrite( const void *buffer, size_t size, size_t count, FILE *stream )
{
    FS_HANDLE fh = (FS_HANDLE)stream;
    unsigned int write = size * count;
    unsigned int written;
    int ret;

    ret = FS_Write(fh, (void*)buffer, write, &written);
    if ( ret == FS_NO_ERROR )
        return written;
    plxfs_SetLastError((DWORD)ret);
    return 0;
}

int	plx_remove(const char * pfilename)
{	
    WCHAR wFileName[256];
    int ret;
    if( pfilename == NULL || *pfilename == 0 )
        return -1;

#ifdef PLX_FILE_ASCII
    AnsiiToUnicodeString((S8 *)wFileName, (S8 *)pfilename );
#elif defined PLX_FILE_UTF8
    Plx_UTF8ToUnicode( (char*)wFileName, pfilename);
#endif

#ifdef PLX_FILE_UNICODE
    ret = FS_Delete( (const WCHAR * )pfilename );
#else    
    ret = FS_Delete( (const WCHAR * )wFileName );
#endif

    if( ret == FS_NO_ERROR )
        return 0;

    plxfs_SetLastError((DWORD)ret);
    
    return ret;
}

int plx_rename( const char *oldname, const char *newname )
{
    WCHAR wOldName[256];
    WCHAR wNewName[256];
    int ret;

    if( oldname == NULL || *oldname == 0 || newname == NULL || *newname == 0)
        return -1;

#ifdef PLX_FILE_ASCII
    AnsiiToUnicodeString((S8 *)wOldName, (S8 *)oldname );
    AnsiiToUnicodeString((S8 *)wNewName, (S8 *)newname );
#elif defined PLX_FILE_UTF8
    Plx_UTF8ToUnicode((char *)wOldName, (char *)oldname );
    Plx_UTF8ToUnicode((char *)wNewName, (char *)newname );
#endif

#ifdef PLX_FILE_UNICODE
    ret =  FS_Rename((const WCHAR*)oldname, (const WCHAR*)newname);
#else
    ret =  FS_Rename(wOldName, wNewName);
#endif

    if (ret == FS_NO_ERROR )
        return 0;
    plxfs_SetLastError((DWORD)ret);
    return ret;
}

/*
typedef enum
{
FS_FILE_BEGIN,
FS_FILE_CURRENT,
FS_FILE_END
}FS_SEEK_POS_ENUM;

#define SEEK_SET    0
#define SEEK_CUR    1
#define SEEK_END    2
*/

int plx_fseek( void *stream, long offset, int origin )
{
    int pointer;
    FS_HANDLE fh = (FS_HANDLE)stream;
    
    pointer = FS_Seek(fh, (int)offset, origin);
    if ( pointer < 0 )
        return -1;
    return 0;
}

long plx_ftell( void *stream )
{
    FS_HANDLE fh = (FS_HANDLE)stream;
    int ret;
	unsigned int position;
	ret = FS_GetFilePosition(fh, &position);
    if ( ret == FS_NO_ERROR )
        return (long)position;

    return -1;
}

int plx_mkdir( const char *dirname )
{
    WCHAR wDirName[256];
    int ret;

    if ( dirname == NULL || *dirname == 0 )
        return -1;

#ifdef PLX_FILE_ASCII
    AnsiiToUnicodeString((S8 *)wDirName, (S8 *)dirname );
#elif defined PLX_FILE_UTF8
    Plx_UTF8ToUnicode((char *)wDirName, (char *)dirname );
#endif    

#ifdef PLX_FILE_UNICODE
    ret = FS_CreateDir((WCHAR*) dirname );
#else
    ret = FS_CreateDir( wDirName );
#endif

    if ( ret == FS_NO_ERROR )
        return 0;

    plxfs_SetLastError((DWORD)ret);    
    return ret;	
}

int plx_rmdir( const char *dirname )
{
    WCHAR wDirName[256];
    int ret;
    
    if ( dirname == NULL || *dirname == 0 )
        return -1;

#ifdef PLX_FILE_ASCII
    AnsiiToUnicodeString((S8 *)wDirName, (S8 *)dirname );
#elif defined PLX_FILE_UTF8
    Plx_UTF8ToUnicode((char *)wDirName, (char *)dirname );
#endif    

#ifdef PLX_FILE_UNICODE
    ret = FS_RemoveDir((const WCHAR *) dirname);
#else
    ret = FS_RemoveDir((const WCHAR *) wDirName);
#endif

    if ( ret == FS_NO_ERROR )
        return 0;

    plxfs_SetLastError((DWORD)ret);    
    return ret;	
}

int plx_fflush( FILE *stream )
{
    FS_HANDLE fh = (FS_HANDLE)stream;
    int ret = 0;
    ret = FS_Commit ( fh );
    if ( ret == FS_NO_ERROR )
        return 0;
    return -1;    
}

long plx_GetFileSize( FILE *stream )
{
	unsigned int filesize;
	FS_HANDLE fh = (FS_HANDLE)stream;
    int ret;

	ret = FS_GetFileSize(fh, &filesize);

    if ( ret == FS_NO_ERROR )
        return (long)filesize;
	
    return -1;
}
/*********************************************************************\
* Function	   
* Purpose      
* Params	   
* Return	 	   
* Remarks	   
**********************************************************************/
typedef struct inter_findhandle {
	PLXFINDENTRY	find;
	int findhandle;
	char findname[64];
}find_handle ;


PLXFINDHANDLE plx_FindFirstFile (const char * filename)
{
    WCHAR NamePattern[128];
    WCHAR FileName[128];
    FS_DOSDirEntry  FileInfo;
    find_handle *pfind;
    BYTE Attr, AttrMask;
    int ret;

    pfind = malloc(sizeof(find_handle));
    if ( pfind == NULL )
        return NULL;

#ifdef PLX_FILE_ASCII
    AnsiiToUnicodeString((S8 *)NamePattern, (S8 *)filename );
#elif defined PLX_FILE_UTF8
    Plx_UTF8ToUnicode((char *)NamePattern, (char *)filename );