Ticket #8952: ds-stream.patch
File ds-stream.patch, 24.6 KB (added by , 16 years ago) |
---|
-
backends/platform/ds/arm9/makefile
237 237 endif 238 238 239 239 PORT_OBJS := $(portdir)/source/blitters_arm.o $(portdir)/source/cdaudio.o $(portdir)/source/dsmain.o \ 240 $(portdir)/../../../fs/ds/ds-fs.o $(portdir)/source/gbampsave.o $(portdir)/source/scummhelp.o\ 240 $(portdir)/../../../fs/ds/ds-fs.o $(portdir)/../../../fs/ds/dsstream.o \ 241 $(portdir)/source/gbampsave.o $(portdir)/source/scummhelp.o\ 241 242 $(portdir)/source/osystem_ds.o $(portdir)/source/portdefs.o $(portdir)/source/ramsave.o\ 242 243 $(portdir)/source/scummconsole.o $(portdir)/source/touchkeyboard.o $(portdir)/source/zipreader.o\ 243 244 $(portdir)/source/dsoptions.o $(portdir)/source/keys.o $(portdir)/source/wordcompletion.o -
backends/fs/stdiostream.cpp
57 57 //#define fsize(a) ps2_fsize(a) // not used -- and it is not a standard function either 58 58 #endif 59 59 60 #ifdef __DS__61 62 // These functions replace the standard library functions of the same name.63 // As this header is included after the standard one, I have the chance to #define64 // all of these to my own code.65 //66 // A #define is the only way, as redefinig the functions would cause linker errors.67 68 // These functions need to be #undef'ed, as their original definition69 // in devkitarm is done with #includes (ugh!)70 #undef feof71 #undef clearerr72 //#undef getc73 //#undef ferror74 75 #include "backends/fs/ds/ds-fs.h"76 77 78 // Only functions used in the ScummVM source have been defined here!79 #define fopen(name, mode) DS::std_fopen(name, mode)80 #define fclose(handle) DS::std_fclose(handle)81 #define fread(ptr, size, items, file) DS::std_fread(ptr, size, items, file)82 #define fwrite(ptr, size, items, file) DS::std_fwrite(ptr, size, items, file)83 #define feof(handle) DS::std_feof(handle)84 #define ftell(handle) DS::std_ftell(handle)85 #define fseek(handle, offset, whence) DS::std_fseek(handle, offset, whence)86 #define clearerr(handle) DS::std_clearerr(handle)87 #define fflush(file) DS::std_fflush(file)88 #undef ferror89 #define ferror(handle) DS::std_ferror(handle)90 91 #endif92 93 60 StdioStream::StdioStream(void *handle) : _handle(handle) { 94 61 assert(handle); 95 62 } -
backends/fs/ds/ds-fs.h
28 28 #include "zipreader.h" 29 29 #include "ramsave.h" 30 30 #include "scummconsole.h" 31 #include "fat/gba_nds_fat.h"32 31 #include "backends/fs/abstract-fs.h" 32 #include "backends/fs/ds/dsstream.h" 33 33 34 34 namespace DS { 35 35 … … 159 159 virtual Common::WriteStream *createWriteStream(); 160 160 }; 161 161 162 struct fileHandle {163 int pos;164 bool used;165 char* data;166 int size;167 168 DSSaveFile* sramFile;169 };170 171 #undef stderr172 #undef stdout173 #undef stdin174 175 #define stdout ((DS::fileHandle*) -1)176 #define stderr ((DS::fileHandle*) -2)177 #define stdin ((DS::fileHandle*) -3)178 179 #define FILE DS::fileHandle180 181 // Please do not remove any of these prototypes that appear not to be required.182 FILE* std_fopen(const char* name, const char* mode);183 void std_fclose(FILE* handle);184 size_t std_fread(const void* ptr, size_t size, size_t numItems, FILE* handle);185 size_t std_fwrite(const void* ptr, size_t size, size_t numItems, FILE* handle);186 bool std_feof(FILE* handle);187 long int std_ftell(FILE* handle);188 int std_fseek(FILE* handle, long int offset, int whence);189 void std_clearerr(FILE* handle);190 int std_fflush(FILE* handle);191 int std_ferror(FILE* handle);192 193 162 } //namespace DS 194 163 195 164 #endif //_DS_FS_H -
backends/fs/ds/dsstream.cpp
1 /* ScummVM - Graphic Adventure Engine 2 * 3 * ScummVM is the legal property of its developers, whose names 4 * are too numerous to list here. Please refer to the COPYRIGHT 5 * file distributed with this source distribution. 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License 9 * as published by the Free Software Foundation; either version 2 10 * of the License, or (at your option) any later version. 11 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. 20 * 21 * $URL$ 22 * $Id$ 23 * 24 */ 25 26 #include "common/scummsys.h" 27 #include "backends/fs/ds/dsstream.h" 28 #include "backends/fs/ds/ds-fs.h" 29 //#include "common/system.h" 30 31 #include "backends/platform/ds/arm9/source/dsmain.h" 32 #include "backends/platform/ds/arm9/source/fat/gba_nds_fat.h" 33 34 namespace DS { 35 36 37 // Stdio replacements 38 #define MAX_FILE_HANDLES 32 39 40 static bool readPastEndOfFile = false; 41 static bool inited = false; 42 static char currentDir[128]; 43 static DS::fileHandle handle[MAX_FILE_HANDLES]; 44 45 FILE* std_fopen(const char* name, const char* mode) { 46 if (!inited) { 47 for (int r = 0; r < MAX_FILE_HANDLES; r++) { 48 handle[r].used = false; 49 } 50 inited = true; 51 currentDir[0] = '\0'; 52 } 53 54 char* realName = (char *) name; 55 56 // Remove file system prefix 57 if ((name[0] == 'd') && (name[1] == 's') && (name[2] == ':') && (name[3] == '/')) { 58 realName += 4; 59 } 60 61 if ((name[0] == 'm') && (name[1] == 'p') && (name[2] == ':') && (name[3] == '/')) { 62 realName += 4; 63 } 64 65 // consolePrintf("Open file:"); 66 // consolePrintf("'%s', [%s]", name, realName); 67 68 if (DS::isGBAMPAvailable()) { 69 FAT_chdir("/"); 70 71 // Turn all back slashes into forward slashes for gba_nds_fat 72 char* p = realName; 73 while (*p) { 74 if (*p == '\\') *p = '/'; 75 p++; 76 } 77 78 FAT_FILE* result = FAT_fopen(realName, mode); 79 80 if (result == 0) { 81 // consolePrintf("Error code %d\n", result); 82 //consolePrintf("Opening file %s\n", realName); 83 } else { 84 // consolePrintf("Opened file %d\n", result); 85 } 86 // MT_memoryReport(); 87 88 return (FILE *) result; 89 } 90 91 // Fail to open file for writing. It's in ROM! 92 93 // Allocate a file handle 94 int r = 0; 95 while (handle[r].used) { 96 r++; 97 assert(r < MAX_FILE_HANDLES); 98 } 99 100 #ifdef GBA_SRAM_SAVE 101 if (strchr(mode, 'w')) { 102 // consolePrintf("Writing %s\n", realName); 103 handle[r].sramFile = (DSSaveFile *) DSSaveFileManager::instance()->openSavefile(realName, true); 104 } else { 105 // consolePrintf("Reading %s\n", realName); 106 handle[r].sramFile = (DSSaveFile *) DSSaveFileManager::instance()->openSavefile(realName, false); 107 } 108 #endif 109 110 if (handle[r].sramFile) { 111 handle[r].used = true; 112 handle[r].pos = 0; 113 handle[r].data = NULL; 114 handle[r].size = handle[r].sramFile->getSize(); 115 // consolePrintf("Found it"); 116 return &handle[r]; 117 } 118 119 // consolePrintf("Not in SRAM!"); 120 121 char* data; 122 123 ZipFile* zip = DSFileSystemNode::getZip(); 124 if (!zip) { 125 // consolePrintf("No zip yet!"); 126 return NULL; 127 } 128 129 // Grab the data if it exists 130 131 zip->setAllFilesVisible(true); 132 133 if (currentDir[0] != 0) { 134 char nameWithPath[128]; 135 sprintf(nameWithPath, "%s\%s", currentDir, realName); 136 strcpy(realName, nameWithPath); 137 } 138 139 // consolePrintf("fopen(%s, %s)\n", realName, name); 140 141 if (zip->findFile(realName)) { 142 data = zip->getFile(); 143 zip->setAllFilesVisible(false); 144 145 // Allocate a file handle 146 int r = 0; 147 while (handle[r].used) r++; 148 149 150 handle[r].used = true; 151 handle[r].pos = 0; 152 handle[r].data = data; 153 handle[r].size = zip->getFileSize(); 154 155 // consolePrintf("Opened file %d: %s (%s) ", r, realName, name); 156 return &handle[r]; 157 } else { 158 zip->setAllFilesVisible(false); 159 // consolePrintf("Not found: %s (%s) ", realName, name); 160 return NULL; 161 } 162 } 163 164 void std_fclose(FILE* handle) { 165 166 if (DS::isGBAMPAvailable()) { 167 FAT_fclose((FAT_FILE *) handle); 168 return; 169 } 170 171 handle->used = false; 172 if (handle->sramFile) { 173 delete handle->sramFile; 174 handle->sramFile = NULL; 175 } 176 } 177 178 size_t std_fread(const void* ptr, size_t size, size_t numItems, FILE* handle) { 179 // consolePrintf("fread %d,%d %d ", size, numItems, ptr); 180 181 if (DS::isGBAMPAvailable()) { 182 readPastEndOfFile = false; 183 184 int bytes = FAT_fread((void *) ptr, size, numItems, (FAT_FILE *) handle); 185 if (!FAT_feof((FAT_FILE *) handle)) { 186 return numItems; 187 } else { 188 // consolePrintf("Read past end of file: %d read out of %d\n", bytes / size, numItems); 189 if ((size_t)bytes != size * numItems) readPastEndOfFile = true; 190 return bytes / size; 191 } 192 return numItems; 193 } 194 195 if (handle->sramFile) { 196 int bytes = 0; 197 int result = 1; 198 //consolePrintf("fread size=", size * numItems); 199 for (int r = 0; (r < (s32) size * (s32) numItems) && (result > 0); r++) { 200 result = handle->sramFile->read((void *) ( ((char *) (ptr)) + r), 1); 201 bytes += result; 202 //consolePrintf("'%d',", ((char *) (ptr))[0]); 203 } 204 205 handle->pos += bytes; 206 207 return bytes / size; 208 } 209 210 if ((int)(handle->pos + size * numItems) > handle->size) { 211 numItems = (handle->size - handle->pos) / size; 212 if (numItems < 0) numItems = 0; 213 } 214 215 // consolePrintf("read %d ", size * numItems); 216 217 memcpy((void *) ptr, handle->data + handle->pos, size * numItems); 218 handle->pos += size * numItems; 219 220 return numItems; 221 } 222 223 size_t std_fwrite(const void* ptr, size_t size, size_t numItems, FILE* handle) { 224 if ((handle == stdin)) return 0; 225 226 if ((handle == stderr) || (handle == stdout)) { 227 // consolePrintf((char *) ptr); 228 return size; 229 } 230 231 //consolePrintf("fwrite size=%d\n", size * numItems); 232 233 if (DS::isGBAMPAvailable()) { 234 FAT_fwrite(((char *) (ptr)), size, numItems, (FAT_FILE *) handle); 235 return numItems; 236 237 int length = size * numItems; 238 int pos = 0; 239 240 while (pos < length) { 241 int amount = length > 512? 512: length; 242 243 FAT_fwrite(((char *) (ptr)) + pos, 1, amount, (FAT_FILE *) handle); 244 length -= amount; 245 pos += amount; 246 } 247 248 return numItems; 249 } 250 251 if (handle->sramFile) { 252 handle->sramFile->write(ptr, size); 253 return size; 254 } else { 255 return 0; 256 } 257 } 258 259 bool std_feof(FILE* handle) { 260 // consolePrintf("feof "); 261 262 if (DS::isGBAMPAvailable()) { 263 return readPastEndOfFile && FAT_feof((FAT_FILE *) handle); 264 } 265 266 if (handle->sramFile) { 267 return handle->sramFile->eos(); 268 } 269 270 // consolePrintf("feof %s", handle->pos >= handle->size? "true": "false"); 271 return handle->pos >= handle->size; 272 } 273 274 long int std_ftell(FILE* handle) { 275 if (DS::isGBAMPAvailable()) { 276 return FAT_ftell((FAT_FILE *) handle); 277 } 278 279 return handle->pos; 280 } 281 282 int std_fseek(FILE* handle, long int offset, int whence) { 283 // consolePrintf("fseek %d %d ", offset, whence); 284 285 if (DS::isGBAMPAvailable()) { 286 return FAT_fseek((FAT_FILE *) handle, offset, whence); 287 } 288 289 switch (whence) { 290 case SEEK_CUR: 291 handle->pos += offset; 292 break; 293 case SEEK_SET: 294 handle->pos = offset; 295 break; 296 case SEEK_END: 297 handle->pos = handle->size + offset; 298 break; 299 default: 300 handle->pos = offset; 301 break; 302 } 303 304 return 0; 305 } 306 307 int std_ferror(FILE* handle) { 308 //FIXME: not implemented? 309 // consolePrintf("ferror "); 310 311 return readPastEndOfFile; 312 } 313 314 void std_clearerr(FILE* handle) { 315 } 316 317 void std_fprintf(FILE* handle, const char* fmt, ...) { 318 consolePrintf(fmt); 319 } 320 321 322 323 DSStream::DSStream(void *handle) : _handle(handle) { 324 assert(handle); 325 } 326 327 DSStream::~DSStream() { 328 DS::std_fclose((FILE *)_handle); 329 } 330 331 bool DSStream::err() const { 332 return DS::std_ferror((FILE *)_handle) != 0; 333 } 334 335 void DSStream::clearErr() { 336 //FIXME: not implemented? 337 readPastEndOfFile = false; 338 // consolePrintf("clearerr "); 339 } 340 341 bool DSStream::eos() const { 342 return DS::std_feof((FILE *)_handle) != 0; 343 } 344 345 int32 DSStream::pos() const { 346 return DS::std_ftell((FILE *)_handle); 347 } 348 349 int32 DSStream::size() const { 350 int32 oldPos = DS::std_ftell((FILE *)_handle); 351 DS::std_fseek((FILE *)_handle, 0, SEEK_END); 352 int32 length = DS::std_ftell((FILE *)_handle); 353 DS::std_fseek((FILE *)_handle, oldPos, SEEK_SET); 354 355 return length; 356 } 357 358 bool DSStream::seek(int32 offs, int whence) { 359 return DS::std_fseek((FILE *)_handle, offs, whence) == 0; 360 } 361 362 uint32 DSStream::read(void *ptr, uint32 len) { 363 return DS::std_fread((byte *)ptr, 1, len, (FILE *)_handle); 364 } 365 366 uint32 DSStream::write(const void *ptr, uint32 len) { 367 return DS::std_fwrite(ptr, 1, len, (FILE *)_handle); 368 } 369 370 bool DSStream::flush() { 371 //FIXME: not implemented? 372 // consolePrintf("fflush "); 373 return true; 374 } 375 376 DSStream *DSStream::makeFromPath(const Common::String &path, bool writeMode) { 377 FILE *handle = DS::std_fopen(path.c_str(), writeMode ? "wb" : "rb"); 378 if (handle) 379 return new DSStream(handle); 380 return 0; 381 } 382 383 } //namespace DS -
backends/fs/ds/dsstream.h
Eigenschaftsänderungen: backends/fs/ds/dsstream.cpp ___________________________________________________________________ Name: svn:mime-type + text/plain Name: svn:keywords + Date Rev Author URL Id Name: svn:eol-style + native
1 /* ScummVM - Graphic Adventure Engine 2 * 3 * ScummVM is the legal property of its developers, whose names 4 * are too numerous to list here. Please refer to the COPYRIGHT 5 * file distributed with this source distribution. 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License 9 * as published by the Free Software Foundation; either version 2 10 * of the License, or (at your option) any later version. 11 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. 20 * 21 * $URL$ 22 * $Id$ 23 * 24 */ 25 26 #ifndef BACKENDS_FS_DS_STREAM_H 27 #define BACKENDS_FS_DS_STREAM_H 28 29 #include "common/scummsys.h" 30 #include "common/noncopyable.h" 31 #include "common/stream.h" 32 #include "common/str.h" 33 34 #include "zipreader.h" 35 #include "ramsave.h" 36 37 namespace DS { 38 39 class DSStream : public Common::SeekableReadStream, public Common::WriteStream, public Common::NonCopyable { 40 protected: 41 /** File handle to the actual file. */ 42 void *_handle; 43 44 public: 45 /** 46 * Given a path, invokes fopen on that path and wrap the result in a 47 * StdioStream instance. 48 */ 49 static DSStream *makeFromPath(const Common::String &path, bool writeMode); 50 51 DSStream(void *handle); 52 virtual ~DSStream(); 53 54 bool err() const; 55 void clearErr(); 56 bool eos() const; 57 58 virtual uint32 write(const void *dataPtr, uint32 dataSize); 59 virtual bool flush(); 60 61 virtual int32 pos() const; 62 virtual int32 size() const; 63 bool seek(int32 offs, int whence = SEEK_SET); 64 uint32 read(void *dataPtr, uint32 dataSize); 65 }; 66 67 struct fileHandle { 68 int pos; 69 bool used; 70 char* data; 71 int size; 72 73 DSSaveFile* sramFile; 74 }; 75 76 #undef stderr 77 #undef stdout 78 #undef stdin 79 80 #define stdout ((DS::fileHandle*) -1) 81 #define stderr ((DS::fileHandle*) -2) 82 #define stdin ((DS::fileHandle*) -3) 83 84 #define FILE DS::fileHandle 85 86 // Please do not remove any of these prototypes that appear not to be required. 87 FILE* std_fopen(const char* name, const char* mode); 88 void std_fclose(FILE* handle); 89 size_t std_fread(const void* ptr, size_t size, size_t numItems, FILE* handle); 90 size_t std_fwrite(const void* ptr, size_t size, size_t numItems, FILE* handle); 91 bool std_feof(FILE* handle); 92 long int std_ftell(FILE* handle); 93 int std_fseek(FILE* handle, long int offset, int whence); 94 95 } //namespace DS 96 97 #endif -
backends/fs/ds/ds-fs.cpp
Eigenschaftsänderungen: backends/fs/ds/dsstream.h ___________________________________________________________________ Name: svn:mime-type + text/plain Name: svn:keywords + Date Rev Author URL Id Name: svn:eol-style + native
24 24 #include "common/util.h" 25 25 //#include <NDS/ARM9/console.h> //basic print funcionality 26 26 #include "backends/fs/ds/ds-fs.h" 27 #include "backends/fs/ stdiostream.h"27 #include "backends/fs/ds/dsstream.h" 28 28 #include "dsmain.h" 29 29 #include "fat/gba_nds_fat.h" 30 30 … … 37 37 ////////////////////////////////////////////////////////////// 38 38 39 39 ZipFile* DSFileSystemNode::_zipFile = NULL; 40 char currentDir[128];41 bool readPastEndOfFile = false;42 40 43 41 DSFileSystemNode::DSFileSystemNode() { 44 42 _displayName = "ds:/"; … … 197 195 } 198 196 199 197 Common::SeekableReadStream *DSFileSystemNode::createReadStream() { 200 return StdioStream::makeFromPath(getPath().c_str(), false);198 return DSStream::makeFromPath(getPath().c_str(), false); 201 199 } 202 200 203 201 Common::WriteStream *DSFileSystemNode::createWriteStream() { 204 return StdioStream::makeFromPath(getPath().c_str(), true);202 return DSStream::makeFromPath(getPath().c_str(), true); 205 203 } 206 204 207 205 ////////////////////////////////////////////////////////////////////////// … … 376 374 // consolePrintf("Opening: %s\n", getPath().c_str()); 377 375 378 376 if (!strncmp(getPath().c_str(), "mp:/", 4)) { 379 return StdioStream::makeFromPath(getPath().c_str() + 3, false);377 return DSStream::makeFromPath(getPath().c_str() + 3, false); 380 378 } else { 381 return StdioStream::makeFromPath(getPath().c_str(), false);379 return DSStream::makeFromPath(getPath().c_str(), false); 382 380 } 383 381 } 384 382 385 383 Common::WriteStream *GBAMPFileSystemNode::createWriteStream() { 386 return StdioStream::makeFromPath(getPath().c_str(), true);384 return DSStream::makeFromPath(getPath().c_str(), true); 387 385 } 388 386 389 // Stdio replacements390 #define MAX_FILE_HANDLES 32391 392 bool inited = false;393 DS::fileHandle handle[MAX_FILE_HANDLES];394 395 FILE* std_fopen(const char* name, const char* mode) {396 if (!inited) {397 for (int r = 0; r < MAX_FILE_HANDLES; r++) {398 handle[r].used = false;399 }400 inited = true;401 currentDir[0] = '\0';402 }403 404 char* realName = (char *) name;405 406 // Remove file system prefix407 if ((name[0] == 'd') && (name[1] == 's') && (name[2] == ':') && (name[3] == '/')) {408 realName += 4;409 }410 411 if ((name[0] == 'm') && (name[1] == 'p') && (name[2] == ':') && (name[3] == '/')) {412 realName += 4;413 }414 415 // consolePrintf("Open file:");416 // consolePrintf("'%s', [%s]", name, realName);417 418 if (DS::isGBAMPAvailable()) {419 FAT_chdir("/");420 421 // Turn all back slashes into forward slashes for gba_nds_fat422 char* p = realName;423 while (*p) {424 if (*p == '\\') *p = '/';425 p++;426 }427 428 FAT_FILE* result = FAT_fopen(realName, mode);429 430 if (result == 0) {431 // consolePrintf("Error code %d\n", result);432 //consolePrintf("Opening file %s\n", realName);433 } else {434 // consolePrintf("Opened file %d\n", result);435 }436 // MT_memoryReport();437 438 return (FILE *) result;439 }440 441 // Fail to open file for writing. It's in ROM!442 443 // Allocate a file handle444 int r = 0;445 while (handle[r].used) {446 r++;447 assert(r < MAX_FILE_HANDLES);448 }449 450 #ifdef GBA_SRAM_SAVE451 if (strchr(mode, 'w')) {452 // consolePrintf("Writing %s\n", realName);453 handle[r].sramFile = (DSSaveFile *) DSSaveFileManager::instance()->openSavefile(realName, true);454 } else {455 // consolePrintf("Reading %s\n", realName);456 handle[r].sramFile = (DSSaveFile *) DSSaveFileManager::instance()->openSavefile(realName, false);457 }458 #endif459 460 if (handle[r].sramFile) {461 handle[r].used = true;462 handle[r].pos = 0;463 handle[r].data = NULL;464 handle[r].size = handle[r].sramFile->getSize();465 // consolePrintf("Found it");466 return &handle[r];467 }468 469 // consolePrintf("Not in SRAM!");470 471 char* data;472 473 ZipFile* zip = DSFileSystemNode::getZip();474 if (!zip) {475 // consolePrintf("No zip yet!");476 return NULL;477 }478 479 // Grab the data if it exists480 481 zip->setAllFilesVisible(true);482 483 if (currentDir[0] != 0) {484 char nameWithPath[128];485 sprintf(nameWithPath, "%s\%s", currentDir, realName);486 strcpy(realName, nameWithPath);487 }488 489 // consolePrintf("fopen(%s, %s)\n", realName, name);490 491 if (zip->findFile(realName)) {492 data = zip->getFile();493 zip->setAllFilesVisible(false);494 495 // Allocate a file handle496 int r = 0;497 while (handle[r].used) r++;498 499 500 handle[r].used = true;501 handle[r].pos = 0;502 handle[r].data = data;503 handle[r].size = zip->getFileSize();504 505 // consolePrintf("Opened file %d: %s (%s) ", r, realName, name);506 return &handle[r];507 } else {508 zip->setAllFilesVisible(false);509 // consolePrintf("Not found: %s (%s) ", realName, name);510 return NULL;511 }512 }513 514 void std_fclose(FILE* handle) {515 516 if (DS::isGBAMPAvailable()) {517 FAT_fclose((FAT_FILE *) handle);518 return;519 }520 521 handle->used = false;522 if (handle->sramFile) {523 delete handle->sramFile;524 handle->sramFile = NULL;525 }526 }527 528 size_t std_fread(const void* ptr, size_t size, size_t numItems, FILE* handle) {529 // consolePrintf("fread %d,%d %d ", size, numItems, ptr);530 531 if (DS::isGBAMPAvailable()) {532 readPastEndOfFile = false;533 534 int bytes = FAT_fread((void *) ptr, size, numItems, (FAT_FILE *) handle);535 if (!FAT_feof((FAT_FILE *) handle)) {536 return numItems;537 } else {538 // consolePrintf("Read past end of file: %d read out of %d\n", bytes / size, numItems);539 if ((size_t)bytes != size * numItems) readPastEndOfFile = true;540 return bytes / size;541 }542 return numItems;543 }544 545 if (handle->sramFile) {546 int bytes = 0;547 int result = 1;548 //consolePrintf("fread size=", size * numItems);549 for (int r = 0; (r < (s32) size * (s32) numItems) && (result > 0); r++) {550 result = handle->sramFile->read((void *) ( ((char *) (ptr)) + r), 1);551 bytes += result;552 //consolePrintf("'%d',", ((char *) (ptr))[0]);553 }554 555 handle->pos += bytes;556 557 return bytes / size;558 }559 560 if ((int)(handle->pos + size * numItems) > handle->size) {561 numItems = (handle->size - handle->pos) / size;562 if (numItems < 0) numItems = 0;563 }564 565 // consolePrintf("read %d ", size * numItems);566 567 memcpy((void *) ptr, handle->data + handle->pos, size * numItems);568 handle->pos += size * numItems;569 570 return numItems;571 }572 573 size_t std_fwrite(const void* ptr, size_t size, size_t numItems, FILE* handle) {574 if ((handle == stdin)) return 0;575 576 if ((handle == stderr) || (handle == stdout)) {577 // consolePrintf((char *) ptr);578 return size;579 }580 581 //consolePrintf("fwrite size=%d\n", size * numItems);582 583 if (DS::isGBAMPAvailable()) {584 FAT_fwrite(((char *) (ptr)), size, numItems, (FAT_FILE *) handle);585 return numItems;586 587 int length = size * numItems;588 int pos = 0;589 590 while (pos < length) {591 int amount = length > 512? 512: length;592 593 FAT_fwrite(((char *) (ptr)) + pos, 1, amount, (FAT_FILE *) handle);594 length -= amount;595 pos += amount;596 }597 598 return numItems;599 }600 601 if (handle->sramFile) {602 handle->sramFile->write(ptr, size);603 return size;604 } else {605 return 0;606 }607 }608 609 bool std_feof(FILE* handle) {610 // consolePrintf("feof ");611 612 if (DS::isGBAMPAvailable()) {613 return readPastEndOfFile && FAT_feof((FAT_FILE *) handle);614 }615 616 if (handle->sramFile) {617 return handle->sramFile->eos();618 }619 620 // consolePrintf("feof %s", handle->pos >= handle->size? "true": "false");621 return handle->pos >= handle->size;622 }623 624 int std_fflush(FILE* handle) {625 //FIXME: not implemented?626 // consolePrintf("fflush ");627 return 0;628 }629 630 long int std_ftell(FILE* handle) {631 if (DS::isGBAMPAvailable()) {632 return FAT_ftell((FAT_FILE *) handle);633 }634 635 return handle->pos;636 }637 638 int std_fseek(FILE* handle, long int offset, int whence) {639 // consolePrintf("fseek %d %d ", offset, whence);640 641 if (DS::isGBAMPAvailable()) {642 return FAT_fseek((FAT_FILE *) handle, offset, whence);643 }644 645 switch (whence) {646 case SEEK_CUR:647 handle->pos += offset;648 break;649 case SEEK_SET:650 handle->pos = offset;651 break;652 case SEEK_END:653 handle->pos = handle->size + offset;654 break;655 default:656 handle->pos = offset;657 break;658 }659 660 return 0;661 }662 663 int std_ferror(FILE* handle) {664 //FIXME: not implemented?665 // consolePrintf("ferror ");666 667 return readPastEndOfFile;668 }669 670 void std_clearerr(FILE* handle) {671 //FIXME: not implemented?672 readPastEndOfFile = false;673 // consolePrintf("clearerr ");674 }675 676 void std_fprintf(FILE* handle, const char* fmt, ...) {677 consolePrintf(fmt);678 }679 680 681 387 } // namespace DS