ShuriZma
/
BizHawk
mirror of https://github.com/TASEmulators/BizHawk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
BizHawk/psx/octoshock/file.cpp

563 lines
13 KiB
C++
Raw Blame History

///* Mednafen - Multi-system Emulator
// *
// * This program is free software; you can redistribute it and/or modify
// * it under the terms of the GNU General Public License as published by
// * the Free Software Foundation; either version 2 of the License, or
// * (at your option) any later version.
// *
// * This program is distributed in the hope that it will be useful,
// * but WITHOUT ANY WARRANTY; without even the implied warranty of
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// * GNU General Public License for more details.
// *
// * You should have received a copy of the GNU General Public License
// * along with this program; if not, write to the Free Software
// * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
// */
//
//#include <stdarg.h>
//#include <string.h>
//#include <sys/types.h>
//#include <sys/stat.h>
//#include <errno.h>
//
//#include "octoshock.h"
//#include "FileStream.h"
//
//
//#ifdef HAVE_MMAP
//#include <sys/mman.h>
//#include <sys/types.h>
//#include <sys/stat.h>
//#include <fcntl.h>
//#endif
//
//#include "file.h"
//
//static const int64 MaxROMImageSize = (int64)1 << 26; // 2 ^ 26 = 64MiB
//
//enum
//{
// MDFN_FILETYPE_PLAIN = 0,
// MDFN_FILETYPE_GZIP = 1,
// MDFN_FILETYPE_ZIP = 2,
//};
//
//void MDFNFILE::MakeMemWrap(void *tz, int type)
//{
// #ifdef HAVE_MMAP
// is_mmap = FALSE;
// #endif
// location = 0;
//
// if(type == MDFN_FILETYPE_PLAIN)
// {
// ::fseek((FILE *)tz, 0, SEEK_END);
// f_size = ::ftell((FILE *)tz);
// ::fseek((FILE *)tz, 0, SEEK_SET);
//
//
// #ifdef HAVE_MMAP
// if((void *)-1 != (f_data = (uint8 *)mmap(NULL, size, PROT_READ, MAP_SHARED, fileno((FILE *)tz), 0)))
// {
// //puts("mmap'ed");
// is_mmap = TRUE;
// #ifdef HAVE_MADVISE
// madvise(f_data, size, MADV_SEQUENTIAL | MADV_WILLNEED);
// #endif
// }
// else
// #endif
// {
// f_data = (uint8 *)MDFN_malloc_T(size, _("file read buffer"));
//
// if((int64)::fread(f_data, 1, size, (FILE *)tz) != size)
// {
// ErrnoHolder ene(errno);
//
// throw MDFN_Error(ene.Errno(), _("Error reading file: %s"), ene.StrError());
// }
// }
// }
// else if(type == MDFN_FILETYPE_GZIP)
// {
// uint32_t cur_size = 0;
// uint32_t cur_alloced = 65536;
// int howmany;
//
// f_data = (uint8 *)MDFN_malloc_T(cur_alloced, _("file read buffer"));
//
// while((howmany = gzread((gzFile)tz, f_data + cur_size, cur_alloced - cur_size)) > 0)
// {
// cur_size += howmany;
// cur_alloced <<= 1;
//
// if(cur_size > MaxROMImageSize)
// throw MDFN_Error(0, _("ROM image is too large; maximum size allowed is %llu bytes."), (unsigned long long)MaxROMImageSize);
//
// f_data = (uint8 *)MDFN_realloc_T(f_data, cur_alloced, _("file read buffer"));
// }
//
// f_data = (uint8 *)MDFN_realloc_T(f_data, cur_size, _("file read buffer"));
// f_size = cur_size;
//
// {
// int gzerrnum = 0;
// const char *gzerrstring;
// if((gzerrstring = gzerror((gzFile)tz, &gzerrnum)) && gzerrnum != Z_OK && gzerrnum != Z_STREAM_END)
// {
// if(gzerrnum != Z_ERRNO)
// {
// throw MDFN_Error(0, _("Error reading file: zlib error: %s"), gzerrstring);
// }
// else
// {
// ErrnoHolder ene(errno);
// throw MDFN_Error(ene.Errno(), _("Error reading file: %s"), ene.StrError());
// }
// }
// }
// }
// else if(type == MDFN_FILETYPE_ZIP)
// {
// unz_file_info ufo;
// unzGetCurrentFileInfo((unzFile)tz, &ufo, 0, 0, 0, 0, 0, 0);
//
// f_size = ufo.uncompressed_size;
//
// if(size > MaxROMImageSize)
// throw MDFN_Error(0, _("ROM image is too large; maximum size allowed is %llu bytes."), (unsigned long long)MaxROMImageSize);
//
// f_data = (uint8 *)MDFN_malloc_T(ufo.uncompressed_size, _("file read buffer"));
// unzReadCurrentFile((unzFile)tz, f_data, ufo.uncompressed_size);
// }
//}
//
//MDFNFILE::MDFNFILE(const char *path, const FileExtensionSpecStruct *known_ext, const char *purpose) : size(f_size), data((const uint8* const &)f_data), ext((const char * const &)f_ext), fbase((const char * const &)f_fbase)
//{
// f_data = NULL;
// f_size = 0;
// f_ext = NULL;
// f_fbase = NULL;
//
// location = 0;
//
// #ifdef HAVE_MMAP
// is_mmap = 0;
// #endif
//
// Open(path, known_ext, purpose);
//}
//
//MDFNFILE::~MDFNFILE()
//{
// Close();
//}
//
//
//void MDFNFILE::Open(const char *path, const FileExtensionSpecStruct *known_ext, const char *purpose)
//{
// unzFile tz = NULL;
// FILE *fp = NULL;
// gzFile gzp = NULL;
//
// try
// {
// //
// // Try opening it as a zip file first
// //
// if((tz = unzOpen(path)))
// {
// char tempu[1024];
// int errcode;
//
// if((errcode = unzGoToFirstFile(tz)) != UNZ_OK)
// {
// throw MDFN_Error(0, _("Could not seek to first file in ZIP archive: %s"), unzErrorString(errcode));
// }
//
// if(known_ext)
// {
// bool FileFound = FALSE;
// while(!FileFound)
// {
// size_t tempu_strlen;
// const FileExtensionSpecStruct *ext_search = known_ext;
//
// if((errcode = unzGetCurrentFileInfo(tz, 0, tempu, 1024, 0, 0, 0, 0)) != UNZ_OK)
// {
// throw MDFN_Error(0, _("Could not get file information in ZIP archive: %s"), unzErrorString(errcode));
// }
//
// tempu[1023] = 0;
// tempu_strlen = strlen(tempu);
//
// while(ext_search->extension && !FileFound)
// {
// size_t ttmeow = strlen(ext_search->extension);
// if(tempu_strlen >= ttmeow)
// {
// if(!strcasecmp(tempu + tempu_strlen - ttmeow, ext_search->extension))
// FileFound = TRUE;
// }
// ext_search++;
// }
//
// if(FileFound)
// break;
//
// if((errcode = unzGoToNextFile(tz)) != UNZ_OK)
// {
// if(errcode != UNZ_END_OF_LIST_OF_FILE)
// {
// throw MDFN_Error(0, _("Error seeking to next file in ZIP archive: %s"), unzErrorString(errcode));
// }
//
// if((errcode = unzGoToFirstFile(tz)) != UNZ_OK)
// {
// throw MDFN_Error(0, _("Could not seek to first file in ZIP archive: %s"), unzErrorString(errcode));
// }
// break;
// }
// } // end to while(!FileFound)
// } // end to if(ext)
//
// if((errcode = unzOpenCurrentFile(tz)) != UNZ_OK)
// {
// throw MDFN_Error(0, _("Could not open file in ZIP archive: %s"), unzErrorString(errcode));
// }
//
// MakeMemWrap(tz, MDFN_FILETYPE_ZIP);
//
// {
// char *ld = strrchr(tempu, '.');
//
// f_ext = strdup(ld ? ld + 1 : "");
// f_fbase = strdup(tempu);
// if(ld)
// f_fbase[ld - tempu] = 0;
// }
// }
// else // If it's not a zip file, handle it as...another type of file!
// {
// if(!(fp = fopen(path, "rb")))
// {
// ErrnoHolder ene(errno);
//
// throw MDFN_Error(ene.Errno(), _("Error opening \"%s\": %s"), path, ene.StrError());
// }
//
// const char *path_fnp = GetFNComponent(path);
//
// uint32 gzmagic;
//
// gzmagic = ::fgetc(fp);
// gzmagic |= ::fgetc(fp) << 8;
// gzmagic |= ::fgetc(fp) << 16;
//
// if(gzmagic != 0x088b1f) /* Not gzip... */
// {
// ::fseek(fp, 0, SEEK_SET);
//
// MakeMemWrap(fp, MDFN_FILETYPE_PLAIN);
//
// {
// const char *ld = strrchr(path_fnp, '.');
// f_ext = strdup(ld ? ld + 1 : "");
// f_fbase = strdup(path_fnp);
// if(ld)
// f_fbase[ld - path_fnp] = 0;
// }
// }
// else /* Probably gzip */
// {
// fclose(fp);
// fp = NULL;
//
// // Clear errno so we can see if the error occurred within zlib or the C lib
// errno = 0;
// if(!(gzp = gzopen(path, "rb")))
// {
// if(errno != 0)
// {
// ErrnoHolder ene(errno);
//
// throw MDFN_Error(ene.Errno(), _("Error opening \"%s\": %s"), path, ene.StrError());
// }
// else
// throw MDFN_Error(0, _("Error opening \"%s\": %s"), path, _("zlib error"));
// }
//
// MakeMemWrap(gzp, MDFN_FILETYPE_GZIP);
//
// char *tmp_path = strdup(path_fnp);
// char *ld = strrchr(tmp_path, '.');
//
// if(ld && ld > tmp_path)
// {
// char *last_ld = ld;
// *ld = 0;
// ld = strrchr(tmp_path, '.');
// if(!ld) { ld = last_ld; }
// else *ld = 0;
// }
// f_ext = strdup(ld ? ld + 1 : "");
// f_fbase = tmp_path;
// } // End gzip handling
// } // End normal and gzip file handling else to zip
// }
// catch(...)
// {
// if(tz != NULL)
// {
// unzCloseCurrentFile(tz);
// unzClose(tz);
// }
//
// if(fp != NULL)
// {
// fclose(fp);
// fp = NULL;
// }
//
// if(gzp != NULL)
// {
// gzclose(gzp);
// gzp = NULL;
// }
//
// Close();
// throw;
// }
//
// if(tz != NULL)
// {
// unzCloseCurrentFile(tz);
// unzClose(tz);
// }
//
// if(fp != NULL)
// {
// fclose(fp);
// fp = NULL;
// }
//
// if(gzp != NULL)
// {
// gzclose(gzp);
// gzp = NULL;
// }
//}
//
//void MDFNFILE::Close(void) throw()
//{
// if(f_ext)
// {
// free(f_ext);
// f_ext = NULL;
// }
//
// if(f_fbase)
// {
// free(f_fbase);
// f_fbase = NULL;
// }
//
// if(f_data)
// {
// #if HAVE_MMAP
// if(is_mmap)
// munmap(f_data, size);
// else
// #endif
// free(f_data);
// f_data = NULL;
// }
//}
//
//uint64 MDFNFILE::fread(void *ptr, size_t element_size, size_t nmemb)
//{
// uint32 total = element_size * nmemb;
//
// if(location >= f_size)
// return 0;
//
// if((location + total) > f_size)
// {
// int64 ak = f_size - location;
//
// memcpy((uint8*)ptr, f_data + location, ak);
//
// location = f_size;
//
// return(ak / element_size);
// }
// else
// {
// memcpy((uint8*)ptr, f_data + location, total);
//
// location += total;
//
// return nmemb;
// }
//}
//
//int MDFNFILE::fseek(int64 offset, int whence)
//{
// switch(whence)
// {
// case SEEK_SET:if(offset >= f_size)
// return(-1);
// location = offset;
// break;
//
// case SEEK_CUR:if((offset + location) > f_size)
// return(-1);
//
// location += offset;
// break;
// }
// return 0;
//}
//
//int MDFNFILE::read16le(uint16 *val)
//{
// if((location + 2) > size)
// return 0;
//
// *val = MDFN_de16lsb(data + location);
//
// location += 2;
//
// return(1);
//}
//
//int MDFNFILE::read32le(uint32 *val)
//{
// if((location + 4) > size)
// return 0;
//
// *val = MDFN_de32lsb(data + location);
//
// location += 4;
//
// return(1);
//}
//
//char *MDFNFILE::fgets(char *s, int buffer_size)
//{
// int pos = 0;
//
// if(!buffer_size)
// return(NULL);
//
// if(location >= buffer_size)
// return(NULL);
//
// while(pos < (buffer_size - 1) && location < buffer_size)
// {
// int v = data[location];
// s[pos] = v;
// location++;
// pos++;
// if(v == '\n') break;
// }
//
// if(buffer_size)
// s[pos] = 0;
//
// return(s);
//}
//
//static INLINE bool MDFN_DumpToFileReal(const char *filename, int compress, const std::vector<PtrLengthPair> &pearpairs)
//{
// if(MDFN_GetSettingB("filesys.disablesavegz"))
// compress = 0;
//
// if(compress)
// {
// char mode[64];
// gzFile gp;
//
// trio_snprintf(mode, 64, "wb%d", compress);
//
// gp = gzopen(filename, mode);
//
// if(!gp)
// {
// ErrnoHolder ene(errno);
//
// MDFN_PrintError(_("Error opening \"%s\": %s"), filename, ene.StrError());
// return(0);
// }
//
// for(unsigned int i = 0; i < pearpairs.size(); i++)
// {
// const void *data = pearpairs[i].GetData();
// const int64 length = pearpairs[i].GetLength();
//
// if(gzwrite(gp, data, length) != length)
// {
// int errnum;
//
// MDFN_PrintError(_("Error writing to \"%s\": %s"), filename, gzerror(gp, &errnum));
// gzclose(gp);
// return(0);
// }
// }
//
// if(gzclose(gp) != Z_OK) // FIXME: Huhm, how should we handle this?
// {
// MDFN_PrintError(_("Error closing \"%s\""), filename);
// return(0);
// }
// }
// else
// {
// FILE *fp = fopen(filename, "wb");
// if(!fp)
// {
// ErrnoHolder ene(errno);
//
// MDFN_PrintError(_("Error opening \"%s\": %s"), filename, ene.StrError());
// return(0);
// }
//
// for(unsigned int i = 0; i < pearpairs.size(); i++)
// {
// const void *data = pearpairs[i].GetData();
// const uint64 length = pearpairs[i].GetLength();
//
// if(fwrite(data, 1, length, fp) != length)
// {
// ErrnoHolder ene(errno);
//
// MDFN_PrintError(_("Error writing to \"%s\": %s"), filename, ene.StrError());
// fclose(fp);
// return(0);
// }
// }
//
// if(fclose(fp) == EOF)
// {
// ErrnoHolder ene(errno);
//
// MDFN_PrintError(_("Error closing \"%s\": %s"), filename, ene.StrError());
// return(0);
// }
// }
// return(1);
//}
//
//bool MDFN_DumpToFile(const char *filename, int compress, const std::vector<PtrLengthPair> &pearpairs)
//{
// return(MDFN_DumpToFileReal(filename, compress, pearpairs));
//}
//
//bool MDFN_DumpToFile(const char *filename, int compress, const void *data, uint64 length)
//{
// std::vector<PtrLengthPair> tmp_pairs;
// tmp_pairs.push_back(PtrLengthPair(data, length));
// return(MDFN_DumpToFileReal(filename, compress, tmp_pairs));
//}
Reference in New Issue View Git Blame Copy Permalink