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
176
177
178
179
180
181
182
183
184
185
186
|
/***************************************************************************
fileio.h
Core file I/O interface functions and definitions.
****************************************************************************
Copyright Aaron Giles
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
distribution.
* Neither the name 'MAME' nor the names of its contributors may be
used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY AARON GILES ''AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL AARON GILES BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
***************************************************************************/
#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
typedef struct _zip_file_header zip_file_header;
typedef struct _zip_file zip_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);
// setters
void remove_on_close() { m_remove_on_close = true; }
void set_openflags(UINT32 openflags) { assert(m_file == NULL); m_openflags = openflags; }
// 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, ...);
private:
// 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);
// 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
UINT32 m_crc; // iterator for paths
UINT32 m_openflags; // flags we used for the open
hash_collection m_hashes; // collection of hashes
zip_file * m_zipfile; // ZIP file pointer
UINT8 * m_zipdata; // ZIP file data
UINT64 m_ziplength; // ZIP file length
bool m_remove_on_close; // flag: remove the file when closing
};
#endif /* __FILEIO_H__ */
|