summaryrefslogtreecommitdiffstatshomepage
path: root/src/emu/fileio.h
blob: 846f828a6bee230f32e6e3bca4a472fc012a054c (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
// license:BSD-3-Clause
// copyright-holders:Aaron Giles
/***************************************************************************

    fileio.h

    Core file I/O interface functions and definitions.

***************************************************************************/

#pragma once

#ifndef __FILEIO_H__
#define __FILEIO_H__

#include "corefile.h"
#include "hash.h"

// some systems use macros for getc/putc rather than functions
#ifdef getc
#undef getc
#endif

//**************************************************************************
//  TYPE DEFINITIONS
//**************************************************************************

// forward declarations
struct zip_file_header;
struct zip_file;

struct _7z_file_header;
struct _7z_file;

// ======================> path_iterator

// helper class for iterating over configured paths
class path_iterator
{
public:
	// construction/destruction
	path_iterator(const char *searchpath);

	// getters
	bool next(astring &buffer, const char *name = NULL);

	// reset
	void reset() { m_current = m_base; m_index = 0; }

private:
	// internal state
	const char *    m_base;
	const char *    m_current;
	int             m_index;
};



// ======================> file_enumerator

// iterate over all files in all paths specified in the searchpath
class file_enumerator
{
public:
	// construction/destruction
	file_enumerator(const char *searchpath);
	~file_enumerator();

	// iterator
	const osd_directory_entry *next();

private:
	// internal state
	path_iterator   m_iterator;
	osd_directory * m_curdir;
	astring         m_pathbuffer;
	//int             m_buflen;
};



// ======================> emu_file

class emu_file
{
public:
	// file open/creation
	emu_file(UINT32 openflags);
	emu_file(const char *searchpath, UINT32 openflags);
	virtual ~emu_file();

	// getters
	operator core_file *();
	operator core_file &();
	bool is_open() const { return (m_file != NULL); }
	const char *filename() const { return m_filename; }
	const char *fullpath() const { return m_fullpath; }
	UINT32 openflags() const { return m_openflags; }
	hash_collection &hashes(const char *types);
	bool restrict_to_mediapath() { return m_restrict_to_mediapath; }
	bool part_of_mediapath(astring path);

	// setters
	void remove_on_close() { m_remove_on_close = true; }
	void set_openflags(UINT32 openflags) { assert(m_file == NULL); m_openflags = openflags; }
	void set_restrict_to_mediapath(bool rtmp = true) { m_restrict_to_mediapath = rtmp; }

	// open/close
	file_error open(const char *name);
	file_error open(const char *name1, const char *name2);
	file_error open(const char *name1, const char *name2, const char *name3);
	file_error open(const char *name1, const char *name2, const char *name3, const char *name4);
	file_error open(const char *name, UINT32 crc);
	file_error open(const char *name1, const char *name2, UINT32 crc);
	file_error open(const char *name1, const char *name2, const char *name3, UINT32 crc);
	file_error open(const char *name1, const char *name2, const char *name3, const char *name4, UINT32 crc);
	file_error open_next();
	file_error open_ram(const void *data, UINT32 length);
	void close();

	// control
	file_error compress(int compress);
	int seek(INT64 offset, int whence);
	UINT64 tell();
	bool eof();
	UINT64 size();

	// reading
	UINT32 read(void *buffer, UINT32 length);
	int getc();
	int ungetc(int c);
	char *gets(char *s, int n);

	// writing
	UINT32 write(const void *buffer, UINT32 length);
	int puts(const char *s);
	int vprintf(const char *fmt, va_list va);
	int printf(const char *fmt, ...) ATTR_PRINTF(2,3);

private:
	bool compressed_file_ready(void);

	// internal helpers
	file_error attempt_zipped();
	file_error load_zipped_file();
	bool zip_filename_match(const zip_file_header &header, const astring &filename);
	bool zip_header_is_path(const zip_file_header &header);

	file_error attempt__7zped();
	file_error load__7zped_file();

	// internal state
	astring         m_filename;                     // original filename provided
	astring         m_fullpath;                     // full filename
	core_file *     m_file;                         // core file pointer
	path_iterator   m_iterator;                     // iterator for paths
	path_iterator   m_mediapaths;           // media-path iterator
	UINT32          m_crc;                          // file's CRC
	UINT32          m_openflags;                    // flags we used for the open
	hash_collection m_hashes;                       // collection of hashes

	zip_file *      m_zipfile;                      // ZIP file pointer
	dynamic_buffer  m_zipdata;                      // ZIP file data
	UINT64          m_ziplength;                    // ZIP file length

	_7z_file *      m__7zfile;                      // 7Z file pointer
	dynamic_buffer  m__7zdata;                      // 7Z file data
	UINT64          m__7zlength;                    // 7Z file length

	bool            m_remove_on_close;              // flag: remove the file when closing
	bool        m_restrict_to_mediapath;    // flag: restrict to paths inside the media-path
};


#endif  /* __FILEIO_H__ */