deps/libretro-common/streams/file_stream_transforms.c

   1 /* Copyright  (C) 2010-2020 The RetroArch team
   2 *
   3 * ---------------------------------------------------------------------------------------
   4 * The following license statement only applies to this file (file_stream_transforms.c).
   5 * ---------------------------------------------------------------------------------------
   6 *
   7 * Permission is hereby granted, free of charge,
   8 * to any person obtaining a copy of this software and associated documentation files (the "Software"),
   9 * to deal in the Software without restriction, including without limitation the rights to
  10 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
  11 * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
  12 *
  13 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
  14 *
  15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
  16 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  18 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  19 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  21 */
  22
  23 #include <string.h>
  24 #include <stdarg.h>
  25
  26 #include <libretro.h>
  27 #include <streams/file_stream.h>
  28
  29 RFILE* rfopen(const char *path, const char *mode)
  30 {
  31    RFILE          *output  = NULL;
  32    unsigned int retro_mode = RETRO_VFS_FILE_ACCESS_READ;
  33    bool position_to_end    = false;
  34
  35    if (strstr(mode, "r"))
  36    {
  37       retro_mode = RETRO_VFS_FILE_ACCESS_READ;
  38       if (strstr(mode, "+"))
  39       {
  40          retro_mode = RETRO_VFS_FILE_ACCESS_READ_WRITE |
  41             RETRO_VFS_FILE_ACCESS_UPDATE_EXISTING;
  42       }
  43    }
  44    else if (strstr(mode, "w"))
  45    {
  46       retro_mode = RETRO_VFS_FILE_ACCESS_WRITE;
  47       if (strstr(mode, "+"))
  48          retro_mode = RETRO_VFS_FILE_ACCESS_READ_WRITE;
  49    }
  50    else if (strstr(mode, "a"))
  51    {
  52       retro_mode = RETRO_VFS_FILE_ACCESS_WRITE |
  53          RETRO_VFS_FILE_ACCESS_UPDATE_EXISTING;
  54       position_to_end = true;
  55       if (strstr(mode, "+"))
  56       {
  57          retro_mode = RETRO_VFS_FILE_ACCESS_READ_WRITE |
  58             RETRO_VFS_FILE_ACCESS_UPDATE_EXISTING;
  59       }
  60    }
  61
  62    output = filestream_open(path, retro_mode,
  63          RETRO_VFS_FILE_ACCESS_HINT_NONE);
  64    if (output && position_to_end)
  65       filestream_seek(output, 0, RETRO_VFS_SEEK_POSITION_END);
  66
  67    return output;
  68 }
  69
  70 int rfclose(RFILE* stream)
  71 {
  72    if (!stream)
  73       return EOF;
  74
  75    return filestream_close(stream);
  76 }
  77
  78 int64_t rftell(RFILE* stream)
  79 {
  80    if (!stream)
  81       return -1;
  82
  83    return filestream_tell(stream);
  84 }
  85
  86 int64_t rfseek(RFILE* stream, int64_t offset, int origin)
  87 {
  88    int seek_position = -1;
  89
  90    if (!stream)
  91       return -1;
  92
  93    switch (origin)
  94    {
  95       case SEEK_SET:
  96          seek_position = RETRO_VFS_SEEK_POSITION_START;
  97          break;
  98       case SEEK_CUR:
  99          seek_position = RETRO_VFS_SEEK_POSITION_CURRENT;
 100          break;
 101       case SEEK_END:
 102          seek_position = RETRO_VFS_SEEK_POSITION_END;
 103          break;
 104    }
 105
 106    return filestream_seek(stream, offset, seek_position);
 107 }
 108
 109 int64_t rfread(void* buffer,
 110    size_t elem_size, size_t elem_count, RFILE* stream)
 111 {
 112    if (!stream || (elem_size == 0) || (elem_count == 0))
 113       return 0;
 114
 115    return (filestream_read(stream, buffer, elem_size * elem_count) / elem_size);
 116 }
 117
 118 char *rfgets(char *buffer, int maxCount, RFILE* stream)
 119 {
 120    if (!stream)
 121       return NULL;
 122
 123    return filestream_gets(stream, buffer, maxCount);
 124 }
 125
 126 int rfgetc(RFILE* stream)
 127 {
 128    if (!stream)
 129       return EOF;
 130
 131    return filestream_getc(stream);
 132 }
 133
 134 int64_t rfwrite(void const* buffer,
 135    size_t elem_size, size_t elem_count, RFILE* stream)
 136 {
 137    if (!stream || (elem_size == 0) || (elem_count == 0))
 138       return 0;
 139
 140    return (filestream_write(stream, buffer, elem_size * elem_count) / elem_size);
 141 }
 142
 143 int rfputc(int character, RFILE * stream)
 144 {
 145    if (!stream)
 146       return EOF;
 147
 148    return filestream_putc(stream, character);
 149 }
 150
 151 int64_t rfflush(RFILE * stream)
 152 {
 153    if (!stream)
 154       return EOF;
 155
 156    return filestream_flush(stream);
 157 }
 158
 159 int rfprintf(RFILE * stream, const char * format, ...)
 160 {
 161    int result;
 162    va_list vl;
 163
 164    if (!stream)
 165       return -1;
 166
 167    va_start(vl, format);
 168    result = filestream_vprintf(stream, format, vl);
 169    va_end(vl);
 170    return result;
 171 }
 172
 173 int rferror(RFILE* stream)
 174 {
 175    return filestream_error(stream);
 176 }
 177
 178 int rfeof(RFILE* stream)
 179 {
 180    return filestream_eof(stream);
 181 }
 182
 183 int rfscanf(RFILE * stream, const char * format, ...)
 184 {
 185    int result;
 186    va_list vl;
 187
 188    if (!stream)
 189       return 0;
 190
 191    va_start(vl, format);
 192    result = filestream_vscanf(stream, format, &vl);
 193    va_end(vl);
 194    return result;
 195 }