← Back to branch summary

~ubuntu-branches/ubuntu/trusty/fceux/trusty

« back to all changes in this revision

Viewing changes to src/emufile.cpp

  • Committer: Package Import Robot
  • Author(s): Joe Nahmias
  • Date: 2013-04-24 09:52:14 UTC
  • Revision ID: package-import@ubuntu.com-20130424095214-re5s7yh759yosy7n
Tags: upstream-2.2.1+dfsg0
Import upstream version 2.2.1+dfsg0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/emufile.cpp
 
1
/*
 
2
Copyright (C) 2009-2010 DeSmuME team
 
3
 
 
4
Permission is hereby granted, free of charge, to any person obtaining a copy
 
5
of this software and associated documentation files (the "Software"), to deal
 
6
in the Software without restriction, including without limitation the rights
 
7
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 
8
copies of the Software, and to permit persons to whom the Software is
 
9
furnished to do so, subject to the following conditions:
 
10
 
 
11
The above copyright notice and this permission notice shall be included in
 
12
all copies or substantial portions of the Software.
 
13
 
 
14
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 
15
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
16
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 
17
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 
18
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 
19
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 
20
THE SOFTWARE.
 
21
*/
 
22
 
 
23
#include <vector>
 
24
#include "emufile.h"
 
25
#include "utils/xstring.h"
 
26
 
 
27
bool EMUFILE::readAllBytes(std::vector<u8>* dstbuf, const std::string& fname)
 
28
{
 
29
        EMUFILE_FILE file(fname.c_str(),"rb");
 
30
        if(file.fail()) return false;
 
31
        int size = file.size();
 
32
        dstbuf->resize(size);
 
33
        file.fread(&dstbuf->at(0),size);
 
34
        return true;
 
35
}
 
36
 
 
37
size_t EMUFILE_MEMORY::_fread(const void *ptr, size_t bytes){
 
38
        u32 remain = len-pos;
 
39
        u32 todo = std::min<u32>(remain,(u32)bytes);
 
40
        if(len==0)
 
41
        {
 
42
                failbit = true;
 
43
                return 0;
 
44
        }
 
45
        if(todo<=4)
 
46
        {
 
47
                u8* src = buf()+pos;
 
48
                u8* dst = (u8*)ptr;
 
49
                for(size_t i=0;i<todo;i++)
 
50
                        *dst++ = *src++;
 
51
        }
 
52
        else
 
53
        {
 
54
                memcpy((void*)ptr,buf()+pos,todo);
 
55
        }
 
56
        pos += todo;
 
57
        if(todo<bytes)
 
58
                failbit = true;
 
59
        return todo;
 
60
}
 
61
 
 
62
void EMUFILE_FILE::open(const char* fname, const char* mode)
 
63
{
 
64
        fp = fopen(fname,mode);
 
65
        if(!fp)
 
66
        {
 
67
#ifdef _MSC_VER
 
68
                std::wstring wfname = mbstowcs((std::string)fname);
 
69
                std::wstring wfmode = mbstowcs((std::string)mode);
 
70
                fp = _wfopen(wfname.c_str(),wfmode.c_str());
 
71
#endif
 
72
                if(!fp)
 
73
                        failbit = true;
 
74
        }
 
75
        this->fname = fname;
 
76
        strcpy(this->mode,mode);
 
77
}
 
78
 
 
79
 
 
80
void EMUFILE_FILE::truncate(s32 length)
 
81
{
 
82
        ::fflush(fp);
 
83
        #ifdef _MSC_VER
 
84
                _chsize(_fileno(fp),length);
 
85
        #else
 
86
                ftruncate(fileno(fp),length);
 
87
        #endif
 
88
        fclose(fp);
 
89
        fp = NULL;
 
90
        open(fname.c_str(),mode);
 
91
}
 
92
 
 
93
 
 
94
EMUFILE* EMUFILE_FILE::memwrap()
 
95
{
 
96
        EMUFILE_MEMORY* mem = new EMUFILE_MEMORY(size());
 
97
        if(size()==0) return mem;
 
98
        fread(mem->buf(),size());
 
99
        return mem;
 
100
}
 
101
 
 
102
EMUFILE* EMUFILE_MEMORY::memwrap()
 
103
{
 
104
        return this;
 
105
}
 
106
 
 
107
void EMUFILE::write64le(u64* val)
 
108
{
 
109
        write64le(*val);
 
110
}
 
111
 
 
112
void EMUFILE::write64le(u64 val)
 
113
{
 
114
#ifdef LOCAL_BE
 
115
        u8 s[8];
 
116
        s[0]=(u8)b;
 
117
        s[1]=(u8)(b>>8);
 
118
        s[2]=(u8)(b>>16);
 
119
        s[3]=(u8)(b>>24);
 
120
        s[4]=(u8)(b>>32);
 
121
        s[5]=(u8)(b>>40);
 
122
        s[6]=(u8)(b>>48);
 
123
        s[7]=(u8)(b>>56);
 
124
        fwrite((char*)&s,8);
 
125
        return 8;
 
126
#else
 
127
        fwrite(&val,8);
 
128
#endif
 
129
}
 
130
 
 
131
 
 
132
size_t EMUFILE::read64le(u64 *Bufo)
 
133
{
 
134
        u64 buf;
 
135
        if(fread((char*)&buf,8) != 8)
 
136
                return 0;
 
137
#ifndef LOCAL_BE
 
138
        *Bufo=buf;
 
139
#else
 
140
        *Bufo = LE_TO_LOCAL_64(buf);
 
141
#endif
 
142
        return 1;
 
143
}
 
144
 
 
145
u64 EMUFILE::read64le()
 
146
{
 
147
        u64 temp;
 
148
        read64le(&temp);
 
149
        return temp;
 
150
}
 
151
 
 
152
void EMUFILE::write32le(u32* val)
 
153
{
 
154
        write32le(*val);
 
155
}
 
156
 
 
157
void EMUFILE::write32le(u32 val)
 
158
{
 
159
#ifdef LOCAL_BE
 
160
        u8 s[4];
 
161
        s[0]=(u8)val;
 
162
        s[1]=(u8)(val>>8);
 
163
        s[2]=(u8)(val>>16);
 
164
        s[3]=(u8)(val>>24);
 
165
        fwrite(s,4);
 
166
#else
 
167
        fwrite(&val,4);
 
168
#endif
 
169
}
 
170
 
 
171
size_t EMUFILE::read32le(s32* Bufo) { return read32le((u32*)Bufo); }
 
172
 
 
173
size_t EMUFILE::read32le(u32* Bufo)
 
174
{
 
175
        u32 buf;
 
176
        if(fread(&buf,4)<4)
 
177
                return 0;
 
178
#ifndef LOCAL_BE
 
179
        *(u32*)Bufo=buf;
 
180
#else
 
181
        *(u32*)Bufo=((buf&0xFF)<<24)|((buf&0xFF00)<<8)|((buf&0xFF0000)>>8)|((buf&0xFF000000)>>24);
 
182
#endif
 
183
        return 1;
 
184
}
 
185
 
 
186
u32 EMUFILE::read32le()
 
187
{
 
188
        u32 ret;
 
189
        read32le(&ret);
 
190
        return ret;
 
191
}
 
192
 
 
193
void EMUFILE::write16le(u16* val)
 
194
{
 
195
        write16le(*val);
 
196
}
 
197
 
 
198
void EMUFILE::write16le(u16 val)
 
199
{
 
200
#ifdef LOCAL_BE
 
201
        u8 s[2];
 
202
        s[0]=(u8)val;
 
203
        s[1]=(u8)(val>>8);
 
204
        fwrite(s,2);
 
205
#else
 
206
        fwrite(&val,2);
 
207
#endif
 
208
}
 
209
 
 
210
size_t EMUFILE::read16le(s16* Bufo) { return read16le((u16*)Bufo); }
 
211
 
 
212
size_t EMUFILE::read16le(u16* Bufo)
 
213
{
 
214
        u32 buf;
 
215
        if(fread(&buf,2)<2)
 
216
                return 0;
 
217
#ifndef LOCAL_BE
 
218
        *(u16*)Bufo=buf;
 
219
#else
 
220
        *Bufo = LE_TO_LOCAL_16(buf);
 
221
#endif
 
222
        return 1;
 
223
}
 
224
 
 
225
u16 EMUFILE::read16le()
 
226
{
 
227
        u16 ret;
 
228
        read16le(&ret);
 
229
        return ret;
 
230
}
 
231
 
 
232
void EMUFILE::write8le(u8* val)
 
233
{
 
234
        write8le(*val);
 
235
}
 
236
 
 
237
 
 
238
void EMUFILE::write8le(u8 val)
 
239
{
 
240
        fwrite(&val,1);
 
241
}
 
242
 
 
243
size_t EMUFILE::read8le(u8* val)
 
244
{
 
245
        return fread(val,1);
 
246
}
 
247
 
 
248
u8 EMUFILE::read8le()
 
249
{
 
250
        u8 temp;
 
251
        fread(&temp,1);
 
252
        return temp;
 
253
}
 
254
 
 
255
void EMUFILE::writedouble(double* val)
 
256
{
 
257
        write64le(double_to_u64(*val));
 
258
}
 
259
void EMUFILE::writedouble(double val)
 
260
{
 
261
        write64le(double_to_u64(val));
 
262
}
 
263
 
 
264
double EMUFILE::readdouble()
 
265
{
 
266
        double temp;
 
267
        readdouble(&temp);
 
268
        return temp;
 
269
}
 
270
 
 
271
size_t EMUFILE::readdouble(double* val)
 
272
{
 
273
        u64 temp;
 
274
        size_t ret = read64le(&temp);
 
275
        *val = u64_to_double(temp);
 
276
        return ret;
 
277
}
 
 
b'\\ No newline at end of file'