348 lines
7.3 KiB
C
348 lines
7.3 KiB
C
/*
|
|
* File : filerw.c
|
|
* This file is part of RT-Thread RTOS
|
|
* COPYRIGHT (C) 2006 - 2009, RT-Thread Development Team
|
|
*
|
|
* The license and distribution terms for this file may be
|
|
* found in the file LICENSE in this distribution or at
|
|
* http://www.rt-thread.org/license/LICENSE
|
|
*
|
|
* Change Logs:
|
|
* Date Author Notes
|
|
* 2009-10-16 Bernard first version
|
|
*/
|
|
#include <rtgui/rtgui_system.h>
|
|
#include <rtgui/filerw.h>
|
|
|
|
#ifdef RTGUI_USING_DFS_FILERW
|
|
|
|
/* standard file read/write */
|
|
struct rtgui_filerw_stdio
|
|
{
|
|
/* inherit from rtgui_filerw */
|
|
struct rtgui_filerw parent;
|
|
|
|
int fd;
|
|
rt_bool_t eof;
|
|
};
|
|
|
|
static int stdio_seek(struct rtgui_filerw *context, rt_off_t offset, int whence)
|
|
{
|
|
struct rtgui_filerw_stdio* stdio_filerw = (struct rtgui_filerw_stdio *)context;
|
|
int stdio_whence[3] = {SEEK_SET, SEEK_CUR, SEEK_END};
|
|
|
|
if (whence < RTGUI_FILE_SEEK_SET || whence > RTGUI_FILE_SEEK_END)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
return lseek(stdio_filerw->fd, offset, stdio_whence[whence]);
|
|
}
|
|
|
|
static int stdio_read(struct rtgui_filerw *context, void *ptr, rt_size_t size, rt_size_t maxnum)
|
|
{
|
|
int result;
|
|
|
|
struct rtgui_filerw_stdio* stdio_filerw = (struct rtgui_filerw_stdio *)context;
|
|
|
|
/* end of file */
|
|
if (stdio_filerw->eof == RT_TRUE) return -1;
|
|
|
|
result = read(stdio_filerw->fd, ptr, size * maxnum);
|
|
if (result == 0) stdio_filerw->eof = RT_TRUE;
|
|
|
|
return result;
|
|
}
|
|
|
|
static int stdio_write(struct rtgui_filerw *context, const void *ptr, rt_size_t size, rt_size_t num)
|
|
{
|
|
struct rtgui_filerw_stdio* stdio_filerw = (struct rtgui_filerw_stdio *)context;
|
|
|
|
return write(stdio_filerw->fd, (char*)ptr, size * num);
|
|
}
|
|
|
|
static int stdio_tell(struct rtgui_filerw* context)
|
|
{
|
|
struct rtgui_filerw_stdio* stdio_filerw = (struct rtgui_filerw_stdio *)context;
|
|
|
|
return lseek(stdio_filerw->fd, 0, SEEK_CUR);
|
|
}
|
|
|
|
static int stdio_eof(struct rtgui_filerw* context)
|
|
{
|
|
int result;
|
|
struct rtgui_filerw_stdio* stdio_filerw = (struct rtgui_filerw_stdio *)context;
|
|
|
|
if (stdio_filerw->eof == RT_TRUE) result = 1;
|
|
else result = -1;
|
|
|
|
return result;
|
|
}
|
|
|
|
static int stdio_close(struct rtgui_filerw *context)
|
|
{
|
|
struct rtgui_filerw_stdio* stdio_filerw = (struct rtgui_filerw_stdio *)context;
|
|
|
|
if (stdio_filerw)
|
|
{
|
|
close(stdio_filerw->fd);
|
|
rtgui_free(stdio_filerw);
|
|
|
|
return 0;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
#endif
|
|
|
|
/* memory file read/write */
|
|
struct rtgui_filerw_mem
|
|
{
|
|
/* inherit from rtgui_filerw */
|
|
struct rtgui_filerw parent;
|
|
|
|
const rt_uint8_t *mem_base, *mem_position, *mem_end;
|
|
};
|
|
|
|
static int mem_seek(struct rtgui_filerw *context, rt_off_t offset, int whence)
|
|
{
|
|
const rt_uint8_t* newpos;
|
|
struct rtgui_filerw_mem* mem = (struct rtgui_filerw_mem*)context;
|
|
|
|
RT_ASSERT(mem != RT_NULL);
|
|
|
|
switch (whence) {
|
|
case RTGUI_FILE_SEEK_SET:
|
|
newpos = mem->mem_base + offset;
|
|
break;
|
|
|
|
case RTGUI_FILE_SEEK_CUR:
|
|
newpos = mem->mem_position + offset;
|
|
break;
|
|
|
|
case RTGUI_FILE_SEEK_END:
|
|
newpos = mem->mem_end + offset;
|
|
break;
|
|
|
|
default:
|
|
return -1;
|
|
}
|
|
|
|
if ( newpos < mem->mem_base )
|
|
newpos = mem->mem_base;
|
|
|
|
if ( newpos > mem->mem_end )
|
|
newpos = mem->mem_end;
|
|
|
|
mem->mem_position = newpos;
|
|
return mem->mem_position- mem->mem_base;
|
|
}
|
|
|
|
static int mem_read(struct rtgui_filerw *context, void *ptr, rt_size_t size, rt_size_t maxnum)
|
|
{
|
|
int total_bytes;
|
|
int mem_available;
|
|
struct rtgui_filerw_mem* mem = (struct rtgui_filerw_mem*)context;
|
|
|
|
total_bytes = (maxnum * size);
|
|
if ( (maxnum <= 0) || (size <= 0) || ((total_bytes / maxnum) != size) )
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
mem_available = mem->mem_end - mem->mem_position;
|
|
if (total_bytes > mem_available)
|
|
total_bytes = mem_available;
|
|
|
|
rt_memcpy(ptr, mem->mem_position, total_bytes);
|
|
mem->mem_position += total_bytes;
|
|
|
|
return (total_bytes / size);
|
|
}
|
|
|
|
static int mem_write(struct rtgui_filerw *context, const void *ptr, rt_size_t size, rt_size_t num)
|
|
{
|
|
return 0; /* not support memory write */
|
|
}
|
|
|
|
static int mem_tell(struct rtgui_filerw* context)
|
|
{
|
|
struct rtgui_filerw_mem* mem = (struct rtgui_filerw_mem*)context;
|
|
|
|
return mem->mem_position - mem->mem_base;
|
|
}
|
|
|
|
static int mem_eof(struct rtgui_filerw* context)
|
|
{
|
|
struct rtgui_filerw_mem* mem = (struct rtgui_filerw_mem*)context;
|
|
|
|
return mem->mem_position >= mem->mem_end;
|
|
}
|
|
|
|
static int mem_close(struct rtgui_filerw *context)
|
|
{
|
|
struct rtgui_filerw_mem* mem = (struct rtgui_filerw_mem*)context;
|
|
|
|
if (mem != RT_NULL)
|
|
{
|
|
rtgui_free(mem);
|
|
return 0;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
const rt_uint8_t* rtgui_filerw_mem_getdata(struct rtgui_filerw* context)
|
|
{
|
|
struct rtgui_filerw_mem* mem = (struct rtgui_filerw_mem*)context;
|
|
|
|
/* check whether it's a memory filerw */
|
|
if (mem->parent.read != mem_read) return RT_NULL;
|
|
|
|
return mem->mem_base;
|
|
}
|
|
|
|
/* file read/write public interface */
|
|
#ifdef RTGUI_USING_DFS_FILERW
|
|
static int parse_mode(const char *mode)
|
|
{
|
|
int f=0;
|
|
|
|
for (;;)
|
|
{
|
|
switch (*mode)
|
|
{
|
|
case 0: return f;
|
|
case 'b': f|=O_BINARY;break;
|
|
case 'r': f=O_RDONLY; break;
|
|
case 'w': f=O_WRONLY|O_CREAT|O_TRUNC; break;
|
|
case 'a': f=O_WRONLY|O_CREAT|O_APPEND; break;
|
|
case '+': f=(f&(~O_WRONLY))|O_RDWR; break;
|
|
}
|
|
|
|
++mode;
|
|
}
|
|
}
|
|
|
|
struct rtgui_filerw* rtgui_filerw_create_file(const char* filename, const char* mode)
|
|
{
|
|
int fd;
|
|
struct rtgui_filerw_stdio *rw;
|
|
|
|
RT_ASSERT(filename != RT_NULL);
|
|
|
|
rw = RT_NULL;
|
|
#ifdef _WIN32
|
|
fd = _open(filename, parse_mode(mode), 0);
|
|
#else
|
|
fd = open(filename, parse_mode(mode), 0);
|
|
#endif
|
|
|
|
if ( fd >= 0 )
|
|
{
|
|
rw = (struct rtgui_filerw_stdio*) rtgui_malloc(sizeof(struct rtgui_filerw_stdio));
|
|
if (rw != RT_NULL)
|
|
{
|
|
rw->parent.seek = stdio_seek;
|
|
rw->parent.read = stdio_read;
|
|
rw->parent.write = stdio_write;
|
|
rw->parent.tell = stdio_tell;
|
|
rw->parent.close = stdio_close;
|
|
rw->parent.eof = stdio_eof;
|
|
|
|
rw->fd = fd;
|
|
rw->eof = RT_FALSE;
|
|
}
|
|
}
|
|
|
|
return &(rw->parent);
|
|
}
|
|
|
|
int rtgui_filerw_unlink(const char *filename)
|
|
{
|
|
#ifdef _WIN32
|
|
return _unlink(filename);
|
|
#else
|
|
return unlink(filename);
|
|
#endif
|
|
}
|
|
|
|
#endif
|
|
|
|
struct rtgui_filerw* rtgui_filerw_create_mem(const rt_uint8_t* mem, rt_size_t size)
|
|
{
|
|
struct rtgui_filerw_mem* rw;
|
|
RT_ASSERT(mem != RT_NULL);
|
|
|
|
rw = (struct rtgui_filerw_mem*) rtgui_malloc(sizeof(struct rtgui_filerw_mem));
|
|
if (rw != RT_NULL)
|
|
{
|
|
rw->parent.seek = mem_seek;
|
|
rw->parent.read = mem_read;
|
|
rw->parent.write = mem_write;
|
|
rw->parent.tell = mem_tell;
|
|
rw->parent.eof = mem_eof;
|
|
rw->parent.close = mem_close;
|
|
|
|
rw->mem_base = mem;
|
|
rw->mem_position = mem;
|
|
rw->mem_end = mem + size;
|
|
}
|
|
|
|
return &(rw->parent);
|
|
}
|
|
|
|
int rtgui_filerw_seek(struct rtgui_filerw* context, rt_off_t offset, int whence)
|
|
{
|
|
RT_ASSERT(context != RT_NULL);
|
|
|
|
return context->seek(context, offset, whence);
|
|
}
|
|
|
|
int rtgui_filerw_read(struct rtgui_filerw* context, void* buffer, rt_size_t size, rt_size_t count)
|
|
{
|
|
RT_ASSERT(context != RT_NULL);
|
|
|
|
return context->read(context, buffer, size, count);
|
|
}
|
|
|
|
int rtgui_filerw_write(struct rtgui_filerw* context, const void* buffer, rt_size_t size, rt_size_t count)
|
|
{
|
|
RT_ASSERT(context != RT_NULL);
|
|
|
|
return context->write(context, buffer, size, count);
|
|
}
|
|
|
|
int rtgui_filerw_eof (struct rtgui_filerw* context)
|
|
{
|
|
RT_ASSERT(context != RT_NULL);
|
|
|
|
return context->eof(context);
|
|
}
|
|
|
|
int rtgui_filerw_tell(struct rtgui_filerw* context)
|
|
{
|
|
RT_ASSERT(context != RT_NULL);
|
|
|
|
return context->tell(context);
|
|
}
|
|
|
|
int rtgui_filerw_close(struct rtgui_filerw* context)
|
|
{
|
|
int result;
|
|
|
|
RT_ASSERT(context != RT_NULL);
|
|
|
|
/* close context */
|
|
result = context->close(context);
|
|
if (result != 0)
|
|
{
|
|
/* close file failed */
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|