[pcsx_rearmed.git] / deps / libretro-common / streams / file_stream.c

/* Copyright  (C) 2010-2020 The RetroArch team
 *
 * ---------------------------------------------------------------------------------------
 * The following license statement only applies to this file (file_stream.c).
 * ---------------------------------------------------------------------------------------
 *
 * Permission is hereby granted, free of charge,
 * to any person obtaining a copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
 * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <ctype.h>

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#ifdef _MSC_VER
#include <compat/msvc.h>
#endif

#include <string/stdstring.h>
#include <streams/file_stream.h>
#define VFS_FRONTEND
#include <vfs/vfs_implementation.h>

#define VFS_ERROR_RETURN_VALUE -1

struct RFILE
{
   struct retro_vfs_file_handle *hfile;
	bool error_flag;
};

static retro_vfs_get_path_t filestream_get_path_cb = NULL;
static retro_vfs_open_t filestream_open_cb         = NULL;
static retro_vfs_close_t filestream_close_cb       = NULL;
static retro_vfs_size_t filestream_size_cb         = NULL;
static retro_vfs_truncate_t filestream_truncate_cb = NULL;
static retro_vfs_tell_t filestream_tell_cb         = NULL;
static retro_vfs_seek_t filestream_seek_cb         = NULL;
static retro_vfs_read_t filestream_read_cb         = NULL;
static retro_vfs_write_t filestream_write_cb       = NULL;
static retro_vfs_flush_t filestream_flush_cb       = NULL;
static retro_vfs_remove_t filestream_remove_cb     = NULL;
static retro_vfs_rename_t filestream_rename_cb     = NULL;

/* VFS Initialization */

void filestream_vfs_init(const struct retro_vfs_interface_info* vfs_info)
{
   const struct retro_vfs_interface *
      vfs_iface           = vfs_info->iface;

   filestream_get_path_cb = NULL;
   filestream_open_cb     = NULL;
   filestream_close_cb    = NULL;
   filestream_tell_cb     = NULL;
   filestream_size_cb     = NULL;
   filestream_truncate_cb = NULL;
   filestream_seek_cb     = NULL;
   filestream_read_cb     = NULL;
   filestream_write_cb    = NULL;
   filestream_flush_cb    = NULL;
   filestream_remove_cb   = NULL;
   filestream_rename_cb   = NULL;

   if (
             (vfs_info->required_interface_version < 
             FILESTREAM_REQUIRED_VFS_VERSION)
         || !vfs_iface)
      return;

   filestream_get_path_cb = vfs_iface->get_path;
   filestream_open_cb     = vfs_iface->open;
   filestream_close_cb    = vfs_iface->close;
   filestream_size_cb     = vfs_iface->size;
   filestream_truncate_cb = vfs_iface->truncate;
   filestream_tell_cb     = vfs_iface->tell;
   filestream_seek_cb     = vfs_iface->seek;
   filestream_read_cb     = vfs_iface->read;
   filestream_write_cb    = vfs_iface->write;
   filestream_flush_cb    = vfs_iface->flush;
   filestream_remove_cb   = vfs_iface->remove;
   filestream_rename_cb   = vfs_iface->rename;
}

/* Callback wrappers */
bool filestream_exists(const char *path)
{
   RFILE *dummy           = NULL;

   if (!path || !*path)
      return false;
   if (!(dummy = filestream_open(
         path,
         RETRO_VFS_FILE_ACCESS_READ,
         RETRO_VFS_FILE_ACCESS_HINT_NONE)))
      return false;

   if (filestream_close(dummy) != 0)
      free(dummy);

   dummy = NULL;
   return true;
}

int64_t filestream_get_size(RFILE *stream)
{
   int64_t output;

   if (filestream_size_cb)
      output = filestream_size_cb(stream->hfile);
   else
      output = retro_vfs_file_size_impl(
            (libretro_vfs_implementation_file*)stream->hfile);

   if (output == VFS_ERROR_RETURN_VALUE)
      stream->error_flag = true;

   return output;
}

int64_t filestream_truncate(RFILE *stream, int64_t length)
{
   int64_t output;

   if (filestream_truncate_cb)
      output = filestream_truncate_cb(stream->hfile, length);
   else
      output = retro_vfs_file_truncate_impl(
            (libretro_vfs_implementation_file*)stream->hfile, length);

   if (output == VFS_ERROR_RETURN_VALUE)
      stream->error_flag = true;

   return output;
}

/**
 * filestream_open:
 * @path               : path to file
 * @mode               : file mode to use when opening (read/write)
 * @hints              :
 *
 * Opens a file for reading or writing, depending on the requested mode.
 * @return A pointer to an RFILE if opened successfully, otherwise NULL.
 **/
RFILE* filestream_open(const char *path, unsigned mode, unsigned hints)
{
   struct retro_vfs_file_handle  *fp = NULL;
   RFILE* output                     = NULL;

   if (filestream_open_cb)
      fp = (struct retro_vfs_file_handle*)
         filestream_open_cb(path, mode, hints);
   else
      fp = (struct retro_vfs_file_handle*)
         retro_vfs_file_open_impl(path, mode, hints);

   if (!fp)
      return NULL;

   output             = (RFILE*)malloc(sizeof(RFILE));
   output->error_flag = false;
   output->hfile      = fp;
   return output;
}

char* filestream_gets(RFILE *stream, char *s, size_t len)
{
   int c   = 0;
   char *p = s;
   if (!stream)
      return NULL;

   /* get max bytes or up to a newline */

   for (len--; len > 0; len--)
   {
      if ((c = filestream_getc(stream)) == EOF)
         break;
      *p++ = c;
      if (c == '\n')
         break;
   }
   *p = 0;

   if (p == s && c == EOF)
      return NULL;
   return (s);
}

int filestream_getc(RFILE *stream)
{
   char c = 0;
   if (stream && filestream_read(stream, &c, 1) == 1)
      return (int)(unsigned char)c;
   return EOF;
}

int filestream_vscanf(RFILE *stream, const char* format, va_list *args)
{
   char buf[4096];
   char subfmt[64];
   va_list args_copy;
   const char *bufiter  = buf;
   int        ret       = 0;
   int64_t startpos     = filestream_tell(stream);
   int64_t maxlen       = filestream_read(stream, buf, sizeof(buf)-1);

   if (maxlen <= 0)
      return EOF;

   buf[maxlen] = '\0';

   /* Have to copy the input va_list here
    * > Calling va_arg() on 'args' directly would
    *   cause the va_list to have an indeterminate value
    *   in the function calling filestream_vscanf(),
    *   leading to unexpected behaviour */
#ifdef __va_copy
   __va_copy(args_copy, *args);
#else
   va_copy(args_copy, *args);
#endif

   while (*format)
   {
      if (*format == '%')
      {
         int sublen;
         char* subfmtiter = subfmt;
         bool asterisk    = false;

         *subfmtiter++    = *format++; /* '%' */

         /* %[*][width][length]specifier */

         if (*format == '*')
         {
            asterisk      = true;
            *subfmtiter++ = *format++;
         }

         while (ISDIGIT((unsigned char)*format))
            *subfmtiter++ = *format++; /* width */

         /* length */
         if (*format == 'h' || *format == 'l')
         {
            if (format[1] == format[0])
               *subfmtiter++ = *format++;
            *subfmtiter++    = *format++;
         }
         else if (
               *format == 'j' || 
               *format == 'z' || 
               *format == 't' || 
               *format == 'L')
         {
            *subfmtiter++ = *format++;
         }

         /* specifier - always a single character (except ]) */
         if (*format == '[')
         {
            while (*format != ']')
               *subfmtiter++ = *format++;
            *subfmtiter++    = *format++;
         }
         else
            *subfmtiter++    = *format++;

         *subfmtiter++       = '%';
         *subfmtiter++       = 'n';
         *subfmtiter++       = '\0';

         if (sizeof(void*) != sizeof(long*))
            abort(); /* all pointers must have the same size */

         if (asterisk)
         {
            int v = sscanf(bufiter, subfmt, &sublen);
            if (v == EOF)
               return EOF;
            if (v != 0)
               break;
         }
         else
         {
            int v = sscanf(bufiter, subfmt, va_arg(args_copy, void*), &sublen);
            if (v == EOF)
               return EOF;
            if (v != 1)
               break;
         }

         ret++;
         bufiter += sublen;
      }
      else if (isspace((unsigned char)*format))
      {
         while (isspace((unsigned char)*bufiter))
            bufiter++;
         format++;
      }
      else
      {
         if (*bufiter != *format)
            break;
         bufiter++;
         format++;
      }
   }

   va_end(args_copy);
   filestream_seek(stream, startpos + (bufiter - buf),
         RETRO_VFS_SEEK_POSITION_START);

   return ret;
}

int filestream_scanf(RFILE *stream, const char* format, ...)
{
   int result;
   va_list vl;
   va_start(vl, format);
   result = filestream_vscanf(stream, format, &vl);
   va_end(vl);
   return result;
}

int64_t filestream_seek(RFILE *stream, int64_t offset, int seek_position)
{
   int64_t output;

   if (filestream_seek_cb)
      output = filestream_seek_cb(stream->hfile, offset, seek_position);
   else
      output = retro_vfs_file_seek_impl(
            (libretro_vfs_implementation_file*)stream->hfile,
            offset, seek_position);

   if (output == VFS_ERROR_RETURN_VALUE)
      stream->error_flag = true;

   return output;
}

int filestream_eof(RFILE *stream)
{
   return filestream_tell(stream) == filestream_get_size(stream) ? EOF : 0;
}

int64_t filestream_tell(RFILE *stream)
{
   int64_t output;

   if (filestream_size_cb)
      output = filestream_tell_cb(stream->hfile);
   else
      output = retro_vfs_file_tell_impl(
            (libretro_vfs_implementation_file*)stream->hfile);

   if (output == VFS_ERROR_RETURN_VALUE)
      stream->error_flag = true;

   return output;
}

void filestream_rewind(RFILE *stream)
{
   if (!stream)
      return;
   filestream_seek(stream, 0L, RETRO_VFS_SEEK_POSITION_START);
   stream->error_flag = false;
}

int64_t filestream_read(RFILE *stream, void *s, int64_t len)
{
   int64_t output;

   if (filestream_read_cb)
      output = filestream_read_cb(stream->hfile, s, len);
   else
      output = retro_vfs_file_read_impl(
            (libretro_vfs_implementation_file*)stream->hfile, s, len);

   if (output == VFS_ERROR_RETURN_VALUE)
      stream->error_flag = true;

   return output;
}

int filestream_flush(RFILE *stream)
{
   int output;

   if (filestream_flush_cb)
      output = filestream_flush_cb(stream->hfile);
   else
      output = retro_vfs_file_flush_impl(
            (libretro_vfs_implementation_file*)stream->hfile);

   if (output == VFS_ERROR_RETURN_VALUE)
      stream->error_flag = true;

   return output;
}

int filestream_delete(const char *path)
{
   if (filestream_remove_cb)
      return filestream_remove_cb(path);

   return retro_vfs_file_remove_impl(path);
}

int filestream_rename(const char *old_path, const char *new_path)
{
   if (filestream_rename_cb)
      return filestream_rename_cb(old_path, new_path);

   return retro_vfs_file_rename_impl(old_path, new_path);
}

const char* filestream_get_path(RFILE *stream)
{
   if (filestream_get_path_cb)
      return filestream_get_path_cb(stream->hfile);

   return retro_vfs_file_get_path_impl(
         (libretro_vfs_implementation_file*)stream->hfile);
}

int64_t filestream_write(RFILE *stream, const void *s, int64_t len)
{
   int64_t output;

   if (filestream_write_cb)
      output = filestream_write_cb(stream->hfile, s, len);
   else
      output = retro_vfs_file_write_impl(
            (libretro_vfs_implementation_file*)stream->hfile, s, len);

   if (output == VFS_ERROR_RETURN_VALUE)
      stream->error_flag = true;

   return output;
}

int filestream_putc(RFILE *stream, int c)
{
   char c_char = (char)c;
   if (!stream)
      return EOF;
   return filestream_write(stream, &c_char, 1) == 1 
      ? (int)(unsigned char)c 
      : EOF;
}

int filestream_vprintf(RFILE *stream, const char* format, va_list args)
{
   static char buffer[8 * 1024];
   int64_t num_chars = vsnprintf(buffer, sizeof(buffer),
         format, args);

   if (num_chars < 0)
      return -1;
   else if (num_chars == 0)
      return 0;

   return (int)filestream_write(stream, buffer, num_chars);
}

int filestream_printf(RFILE *stream, const char* format, ...)
{
   va_list vl;
   int result;
   va_start(vl, format);
   result = filestream_vprintf(stream, format, vl);
   va_end(vl);
   return result;
}

int filestream_error(RFILE *stream)
{
   return (stream && stream->error_flag);
}

int filestream_close(RFILE *stream)
{
   int output;
   struct retro_vfs_file_handle* fp = stream->hfile;

   if (filestream_close_cb)
      output = filestream_close_cb(fp);
   else
      output = retro_vfs_file_close_impl(
            (libretro_vfs_implementation_file*)fp);

   if (output == 0)
      free(stream);

   return output;
}

/**
 * filestream_read_file:
 * @path             : path to file.
 * @buf              : buffer to allocate and read the contents of the
 *                     file into. Needs to be freed manually.
 * @len              : optional output integer containing bytes read.
 *
 * Read the contents of a file into @buf.
 *
 * @return Non-zero on success.
 */
int64_t filestream_read_file(const char *path, void **buf, int64_t *len)
{
   int64_t ret              = 0;
   int64_t content_buf_size = 0;
   void *content_buf        = NULL;
   RFILE *file              = filestream_open(path,
         RETRO_VFS_FILE_ACCESS_READ,
         RETRO_VFS_FILE_ACCESS_HINT_NONE);

   if (!file)
   {
      *buf = NULL;
      return 0;
   }

   if ((content_buf_size = filestream_get_size(file)) < 0)
      goto error;

   if (!(content_buf = malloc((size_t)(content_buf_size + 1))))
      goto error;
   if ((int64_t)(uint64_t)(content_buf_size + 1) != (content_buf_size + 1))
      goto error;

   if ((ret = filestream_read(file, content_buf, (int64_t)content_buf_size)) <
         0)
      goto error;

   if (filestream_close(file) != 0)
      free(file);

   *buf    = content_buf;

   /* Allow for easy reading of strings to be safe.
    * Will only work with sane character formatting (Unix). */
   ((char*)content_buf)[ret] = '\0';

   if (len)
      *len = ret;

   return 1;

error:
   if (filestream_close(file) != 0)
      free(file);
   if (content_buf)
      free(content_buf);
   if (len)
      *len = -1;
   *buf = NULL;
   return 0;
}

/**
 * filestream_write_file:
 * @path             : path to file.
 * @data             : contents to write to the file.
 * @size             : size of the contents.
 *
 * Writes data to a file.
 *
 * @return true on success, otherwise false.
 **/
bool filestream_write_file(const char *path, const void *data, int64_t size)
{
   int64_t ret   = 0;
   RFILE *file   = filestream_open(path,
         RETRO_VFS_FILE_ACCESS_WRITE,
         RETRO_VFS_FILE_ACCESS_HINT_NONE);
   if (!file)
      return false;
   ret = filestream_write(file, data, size);
   if (filestream_close(file) != 0)
      free(file);
   return (ret == size);
}

/**
 * filestream_getline:
 *
 * Returned pointer must be freed by the caller.
 **/
char *filestream_getline(RFILE *stream)
{
   char *newline_tmp  = NULL;
   size_t cur_size    = 8;
   size_t idx         = 0;
   int in             = 0;
   char *newline      = (char*)malloc(9);

   if (!stream || !newline)
   {
      if (newline)
         free(newline);
      return NULL;
   }

   in = filestream_getc(stream);

   while (in != EOF && in != '\n')
   {
      if (idx == cur_size)
      {
         cur_size    *= 2;

         if (!(newline_tmp = (char*)realloc(newline, cur_size + 1)))
         {
            free(newline);
            return NULL;
         }

         newline     = newline_tmp;
      }

      newline[idx++] = in;
      in             = filestream_getc(stream);
   }

   newline[idx]      = '\0';
   return newline;
}

libretro_vfs_implementation_file* filestream_get_vfs_handle(RFILE *stream)
{
   return (libretro_vfs_implementation_file*)stream->hfile;
}
Commit	Line	Data
3719602c PC	1	/* Copyright (C) 2010-2020 The RetroArch team
	2	*
	3	* ---------------------------------------------------------------------------------------
	4	* The following license statement only applies to this file (file_stream.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 <stdio.h>
	24	#include <stdlib.h>
	25	#include <string.h>
	26	#include <stdarg.h>
	27	#include <ctype.h>
	28
	29	#ifdef HAVE_CONFIG_H
	30	#include "config.h"
	31	#endif
	32
	33	#ifdef _MSC_VER
	34	#include <compat/msvc.h>
	35	#endif
	36
	37	#include <string/stdstring.h>
	38	#include <streams/file_stream.h>
	39	#define VFS_FRONTEND
	40	#include <vfs/vfs_implementation.h>
	41
	42	#define VFS_ERROR_RETURN_VALUE -1
	43
	44	struct RFILE
	45	{
	46	struct retro_vfs_file_handle *hfile;
	47	bool error_flag;
	48	};
	49
	50	static retro_vfs_get_path_t filestream_get_path_cb = NULL;
	51	static retro_vfs_open_t filestream_open_cb = NULL;
	52	static retro_vfs_close_t filestream_close_cb = NULL;
	53	static retro_vfs_size_t filestream_size_cb = NULL;
	54	static retro_vfs_truncate_t filestream_truncate_cb = NULL;
	55	static retro_vfs_tell_t filestream_tell_cb = NULL;
	56	static retro_vfs_seek_t filestream_seek_cb = NULL;
	57	static retro_vfs_read_t filestream_read_cb = NULL;
	58	static retro_vfs_write_t filestream_write_cb = NULL;
	59	static retro_vfs_flush_t filestream_flush_cb = NULL;
	60	static retro_vfs_remove_t filestream_remove_cb = NULL;
	61	static retro_vfs_rename_t filestream_rename_cb = NULL;
	62
	63	/* VFS Initialization */
	64
65	void filestream_vfs_init(const struct retro_vfs_interface_info* vfs_info)
66	{
67	const struct retro_vfs_interface *
68	vfs_iface = vfs_info->iface;
69
70	filestream_get_path_cb = NULL;
71	filestream_open_cb = NULL;
72	filestream_close_cb = NULL;
73	filestream_tell_cb = NULL;
74	filestream_size_cb = NULL;
75	filestream_truncate_cb = NULL;
76	filestream_seek_cb = NULL;
77	filestream_read_cb = NULL;
78	filestream_write_cb = NULL;
79	filestream_flush_cb = NULL;
80	filestream_remove_cb = NULL;
81	filestream_rename_cb = NULL;
82
83	if (
84	(vfs_info->required_interface_version <
85	FILESTREAM_REQUIRED_VFS_VERSION)
86	\|\| !vfs_iface)
87	return;
88
89	filestream_get_path_cb = vfs_iface->get_path;
90	filestream_open_cb = vfs_iface->open;
91	filestream_close_cb = vfs_iface->close;
92	filestream_size_cb = vfs_iface->size;
93	filestream_truncate_cb = vfs_iface->truncate;
94	filestream_tell_cb = vfs_iface->tell;
95	filestream_seek_cb = vfs_iface->seek;
96	filestream_read_cb = vfs_iface->read;
97	filestream_write_cb = vfs_iface->write;
98	filestream_flush_cb = vfs_iface->flush;
99	filestream_remove_cb = vfs_iface->remove;
100	filestream_rename_cb = vfs_iface->rename;
101	}
102
103	/* Callback wrappers */
104	bool filestream_exists(const char *path)
105	{
106	RFILE *dummy = NULL;
107
108	if (!path \|\| !*path)
109	return false;
110	if (!(dummy = filestream_open(
111	path,
112	RETRO_VFS_FILE_ACCESS_READ,
113	RETRO_VFS_FILE_ACCESS_HINT_NONE)))
114	return false;
115
116	if (filestream_close(dummy) != 0)
117	free(dummy);
118
119	dummy = NULL;
120	return true;
121	}
122
123	int64_t filestream_get_size(RFILE *stream)
124	{
125	int64_t output;
126
127	if (filestream_size_cb)
128	output = filestream_size_cb(stream->hfile);
129	else
130	output = retro_vfs_file_size_impl(
131	(libretro_vfs_implementation_file*)stream->hfile);
132
133	if (output == VFS_ERROR_RETURN_VALUE)
134	stream->error_flag = true;
135
136	return output;
137	}
138
139	int64_t filestream_truncate(RFILE *stream, int64_t length)
140	{
141	int64_t output;
142
143	if (filestream_truncate_cb)
144	output = filestream_truncate_cb(stream->hfile, length);
145	else
146	output = retro_vfs_file_truncate_impl(
147	(libretro_vfs_implementation_file*)stream->hfile, length);
148
149	if (output == VFS_ERROR_RETURN_VALUE)
150	stream->error_flag = true;
151
152	return output;
153	}
154
155	/**
156	* filestream_open:
157	* @path : path to file
158	* @mode : file mode to use when opening (read/write)
159	* @hints :
160	*
161	* Opens a file for reading or writing, depending on the requested mode.
162	* @return A pointer to an RFILE if opened successfully, otherwise NULL.
163	**/
164	RFILE* filestream_open(const char *path, unsigned mode, unsigned hints)
165	{
166	struct retro_vfs_file_handle *fp = NULL;
167	RFILE* output = NULL;
168
169	if (filestream_open_cb)
170	fp = (struct retro_vfs_file_handle*)
171	filestream_open_cb(path, mode, hints);
172	else
173	fp = (struct retro_vfs_file_handle*)
174	retro_vfs_file_open_impl(path, mode, hints);
175
176	if (!fp)
177	return NULL;
178
179	output = (RFILE*)malloc(sizeof(RFILE));
180	output->error_flag = false;
181	output->hfile = fp;
182	return output;
183	}
184
185	char* filestream_gets(RFILE stream, char s, size_t len)
186	{
187	int c = 0;
188	char *p = s;
189	if (!stream)
190	return NULL;
191
192	/* get max bytes or up to a newline */
193
194	for (len--; len > 0; len--)
195	{
196	if ((c = filestream_getc(stream)) == EOF)
197	break;
198	*p++ = c;
199	if (c == '\n')
200	break;
201	}
202	*p = 0;
203
204	if (p == s && c == EOF)
205	return NULL;
206	return (s);
207	}
208
209	int filestream_getc(RFILE *stream)
210	{
211	char c = 0;
212	if (stream && filestream_read(stream, &c, 1) == 1)
213	return (int)(unsigned char)c;
214	return EOF;
215	}
216
217	int filestream_vscanf(RFILE stream, const char format, va_list *args)
218	{
219	char buf[4096];
220	char subfmt[64];
221	va_list args_copy;
222	const char *bufiter = buf;
223	int ret = 0;
224	int64_t startpos = filestream_tell(stream);
225	int64_t maxlen = filestream_read(stream, buf, sizeof(buf)-1);
226
227	if (maxlen <= 0)
228	return EOF;
229
230	buf[maxlen] = '\0';
231
232	/* Have to copy the input va_list here
233	* > Calling va_arg() on 'args' directly would
234	* cause the va_list to have an indeterminate value
235	* in the function calling filestream_vscanf(),
236	* leading to unexpected behaviour */
237	#ifdef __va_copy
238	__va_copy(args_copy, *args);
239	#else
240	va_copy(args_copy, *args);
241	#endif
242
243	while (*format)
244	{
245	if (*format == '%')
246	{
247	int sublen;
248	char* subfmtiter = subfmt;
249	bool asterisk = false;
250
251	subfmtiter++ = format++; /* '%' */
252
253	/* %[][width][length]specifier /
254
255	if (format == '')
256	{
257	asterisk = true;
258	subfmtiter++ = format++;
259	}
260
261	while (ISDIGIT((unsigned char)*format))
262	subfmtiter++ = format++; /* width */
263
264	/* length */
265	if (format == 'h' \|\| format == 'l')
266	{
267	if (format[1] == format[0])
268	subfmtiter++ = format++;
269	subfmtiter++ = format++;
270	}
271	else if (
272	*format == 'j' \|\|
273	*format == 'z' \|\|
274	*format == 't' \|\|
275	*format == 'L')
276	{
277	subfmtiter++ = format++;
278	}
279
280	/* specifier - always a single character (except ]) */
281	if (*format == '[')
282	{
283	while (*format != ']')
284	subfmtiter++ = format++;
285	subfmtiter++ = format++;
286	}
287	else
288	subfmtiter++ = format++;
289
290	*subfmtiter++ = '%';
291	*subfmtiter++ = 'n';
292	*subfmtiter++ = '\0';
293
294	if (sizeof(void) != sizeof(long))
295	abort(); /* all pointers must have the same size */
296
297	if (asterisk)
298	{
299	int v = sscanf(bufiter, subfmt, &sublen);
300	if (v == EOF)
301	return EOF;
302	if (v != 0)
303	break;
304	}
305	else
306	{
307	int v = sscanf(bufiter, subfmt, va_arg(args_copy, void*), &sublen);
308	if (v == EOF)
309	return EOF;
310	if (v != 1)
311	break;
312	}
313
314	ret++;
315	bufiter += sublen;
316	}
317	else if (isspace((unsigned char)*format))
318	{
319	while (isspace((unsigned char)*bufiter))
320	bufiter++;
321	format++;
322	}
323	else
324	{
325	if (bufiter != format)
326	break;
327	bufiter++;
328	format++;
329	}
330	}
331
332	va_end(args_copy);
333	filestream_seek(stream, startpos + (bufiter - buf),
334	RETRO_VFS_SEEK_POSITION_START);
335
336	return ret;
337	}
338
339	int filestream_scanf(RFILE stream, const char format, ...)
340	{
341	int result;
342	va_list vl;
343	va_start(vl, format);
344	result = filestream_vscanf(stream, format, &vl);
345	va_end(vl);
346	return result;
347	}
348
349	int64_t filestream_seek(RFILE *stream, int64_t offset, int seek_position)
350	{
351	int64_t output;
352
353	if (filestream_seek_cb)
354	output = filestream_seek_cb(stream->hfile, offset, seek_position);
355	else
356	output = retro_vfs_file_seek_impl(
357	(libretro_vfs_implementation_file*)stream->hfile,
358	offset, seek_position);
359
360	if (output == VFS_ERROR_RETURN_VALUE)
361	stream->error_flag = true;
362
363	return output;
364	}
365
366	int filestream_eof(RFILE *stream)
367	{
368	return filestream_tell(stream) == filestream_get_size(stream) ? EOF : 0;
369	}
370
371	int64_t filestream_tell(RFILE *stream)
372	{
373	int64_t output;
374
375	if (filestream_size_cb)
376	output = filestream_tell_cb(stream->hfile);
377	else
378	output = retro_vfs_file_tell_impl(
379	(libretro_vfs_implementation_file*)stream->hfile);
380
381	if (output == VFS_ERROR_RETURN_VALUE)
382	stream->error_flag = true;
383
384	return output;
385	}
386
387	void filestream_rewind(RFILE *stream)
388	{
389	if (!stream)
390	return;
391	filestream_seek(stream, 0L, RETRO_VFS_SEEK_POSITION_START);
392	stream->error_flag = false;
393	}
394
395	int64_t filestream_read(RFILE stream, void s, int64_t len)
396	{
397	int64_t output;
398
399	if (filestream_read_cb)
400	output = filestream_read_cb(stream->hfile, s, len);
401	else
402	output = retro_vfs_file_read_impl(
403	(libretro_vfs_implementation_file*)stream->hfile, s, len);
404
405	if (output == VFS_ERROR_RETURN_VALUE)
406	stream->error_flag = true;
407
408	return output;
409	}
410
411	int filestream_flush(RFILE *stream)
412	{
413	int output;
414
415	if (filestream_flush_cb)
416	output = filestream_flush_cb(stream->hfile);
417	else
418	output = retro_vfs_file_flush_impl(
419	(libretro_vfs_implementation_file*)stream->hfile);
420
421	if (output == VFS_ERROR_RETURN_VALUE)
422	stream->error_flag = true;
423
424	return output;
425	}
426
427	int filestream_delete(const char *path)
428	{
429	if (filestream_remove_cb)
430	return filestream_remove_cb(path);
431
432	return retro_vfs_file_remove_impl(path);
433	}
434
435	int filestream_rename(const char old_path, const char new_path)
436	{
437	if (filestream_rename_cb)
438	return filestream_rename_cb(old_path, new_path);
439
440	return retro_vfs_file_rename_impl(old_path, new_path);
441	}
442
443	const char* filestream_get_path(RFILE *stream)
444	{
445	if (filestream_get_path_cb)
446	return filestream_get_path_cb(stream->hfile);
447
448	return retro_vfs_file_get_path_impl(
449	(libretro_vfs_implementation_file*)stream->hfile);
450	}
451
452	int64_t filestream_write(RFILE stream, const void s, int64_t len)
453	{
454	int64_t output;
455
456	if (filestream_write_cb)
457	output = filestream_write_cb(stream->hfile, s, len);
458	else
459	output = retro_vfs_file_write_impl(
460	(libretro_vfs_implementation_file*)stream->hfile, s, len);
461
462	if (output == VFS_ERROR_RETURN_VALUE)
463	stream->error_flag = true;
464
465	return output;
466	}
467
468	int filestream_putc(RFILE *stream, int c)
469	{
470	char c_char = (char)c;
471	if (!stream)
472	return EOF;
473	return filestream_write(stream, &c_char, 1) == 1
474	? (int)(unsigned char)c
475	: EOF;
476	}
477
478	int filestream_vprintf(RFILE stream, const char format, va_list args)
479	{
480	static char buffer[8 * 1024];
481	int64_t num_chars = vsnprintf(buffer, sizeof(buffer),
482	format, args);
483
484	if (num_chars < 0)
485	return -1;
486	else if (num_chars == 0)
487	return 0;
488
489	return (int)filestream_write(stream, buffer, num_chars);
490	}
491
492	int filestream_printf(RFILE stream, const char format, ...)
493	{
494	va_list vl;
495	int result;
496	va_start(vl, format);
497	result = filestream_vprintf(stream, format, vl);
498	va_end(vl);
499	return result;
500	}
501
502	int filestream_error(RFILE *stream)
503	{
504	return (stream && stream->error_flag);
505	}
506
507	int filestream_close(RFILE *stream)
508	{
509	int output;
510	struct retro_vfs_file_handle* fp = stream->hfile;
511
512	if (filestream_close_cb)
513	output = filestream_close_cb(fp);
514	else
515	output = retro_vfs_file_close_impl(
516	(libretro_vfs_implementation_file*)fp);
517
518	if (output == 0)
519	free(stream);
520
521	return output;
522	}
523
524	/**
525	* filestream_read_file:
526	* @path : path to file.
527	* @buf : buffer to allocate and read the contents of the
528	* file into. Needs to be freed manually.
529	* @len : optional output integer containing bytes read.
530	*
531	* Read the contents of a file into @buf.
532	*
533	* @return Non-zero on success.
534	*/
535	int64_t filestream_read_file(const char path, void buf, int64_t len)
536	{
537	int64_t ret = 0;
538	int64_t content_buf_size = 0;
539	void *content_buf = NULL;
540	RFILE *file = filestream_open(path,
541	RETRO_VFS_FILE_ACCESS_READ,
542	RETRO_VFS_FILE_ACCESS_HINT_NONE);
543
544	if (!file)
545	{
546	*buf = NULL;
547	return 0;
548	}
549
550	if ((content_buf_size = filestream_get_size(file)) < 0)
551	goto error;
552
553	if (!(content_buf = malloc((size_t)(content_buf_size + 1))))
554	goto error;
555	if ((int64_t)(uint64_t)(content_buf_size + 1) != (content_buf_size + 1))
556	goto error;
557
558	if ((ret = filestream_read(file, content_buf, (int64_t)content_buf_size)) <
559	0)
560	goto error;
561
562	if (filestream_close(file) != 0)
563	free(file);
564
565	*buf = content_buf;
566
567	/* Allow for easy reading of strings to be safe.
568	* Will only work with sane character formatting (Unix). */
569	((char*)content_buf)[ret] = '\0';
570
571	if (len)
572	*len = ret;
573
574	return 1;
575
576	error:
577	if (filestream_close(file) != 0)
578	free(file);
579	if (content_buf)
580	free(content_buf);
581	if (len)
582	*len = -1;
583	*buf = NULL;
584	return 0;
585	}
586
587	/**
588	* filestream_write_file:
589	* @path : path to file.
590	* @data : contents to write to the file.
591	* @size : size of the contents.
592	*
593	* Writes data to a file.
594	*
595	* @return true on success, otherwise false.
596	**/
597	bool filestream_write_file(const char path, const void data, int64_t size)
598	{
599	int64_t ret = 0;
600	RFILE *file = filestream_open(path,
601	RETRO_VFS_FILE_ACCESS_WRITE,
602	RETRO_VFS_FILE_ACCESS_HINT_NONE);
603	if (!file)
604	return false;
605	ret = filestream_write(file, data, size);
606	if (filestream_close(file) != 0)
607	free(file);
608	return (ret == size);
609	}
610
611	/**
612	* filestream_getline:
613	*
614	* Returned pointer must be freed by the caller.
615	**/
616	char filestream_getline(RFILE stream)
617	{
618	char *newline_tmp = NULL;
619	size_t cur_size = 8;
620	size_t idx = 0;
621	int in = 0;
622	char newline = (char)malloc(9);
623
624	if (!stream \|\| !newline)
625	{
626	if (newline)
627	free(newline);
628	return NULL;
629	}
630
631	in = filestream_getc(stream);
632
633	while (in != EOF && in != '\n')
634	{
635	if (idx == cur_size)
636	{
637	cur_size *= 2;
638
639	if (!(newline_tmp = (char*)realloc(newline, cur_size + 1)))
640	{
641	free(newline);
642	return NULL;
643	}
644
645	newline = newline_tmp;
646	}
647
648	newline[idx++] = in;
649	in = filestream_getc(stream);
650	}
651
652	newline[idx] = '\0';
653	return newline;
654	}
655
656	libretro_vfs_implementation_file* filestream_get_vfs_handle(RFILE *stream)
657	{
658	return (libretro_vfs_implementation_file*)stream->hfile;
659	}