rt-thread/components/gui/src/filerw.c

/*
 * File      : filerw.c
 * This file is part of RT-Thread GUI Engine
 * COPYRIGHT (C) 2006 - 2017, RT-Thread Development Team
 *
 *  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; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  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.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * 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_NATIVE
    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);
        }

        close(fd);
    }
    else
    {
        rt_kprintf("open:%s failed! errno=%d\n", filename, errno);
    }

    return RT_NULL;
}

int rtgui_filerw_unlink(const char *filename)
{
#ifdef _WIN32_NATIVE
    return _unlink(filename);
#else
#ifndef RT_USING_DFS
    /* no unlink function */
    return -1;
#else
    return unlink(filename);
#endif
#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;
}