void TypeDescriptorImpl::Load()
{
if(!loaded)
{
loaded=true;
LoadInternal();
}
}
NS_IMETHODIMP mozPersonalDictionary::Load()
{
nsresult rv = LoadInternal();
if (NS_FAILED(rv)) {
mIsLoaded = true;
}
return rv;
}
void TextureLoader::Load(std::shared_ptr<Stream::IStream> spStream, const CString& cszExtensionWithDot,
std::shared_ptr<Texture> spTexture, bool bGenerateMipmap)
{
std::shared_ptr<IImageReader> spImageReader = SelectImageReader(cszExtensionWithDot);
if (spImageReader == NULL)
throw Exception(_T("image file type not supported; extension: ") + cszExtensionWithDot, __FILE__, __LINE__);
LoadInternal(spStream, spImageReader, spTexture, bGenerateMipmap);
}
void TextureLoader::Load(const CString& cszFilename, std::shared_ptr<Texture> spTexture, bool bGenerateMipmap)
{
ATLASSERT(spTexture != nullptr);
std::shared_ptr<IImageReader> spImageReader = SelectImageReader(cszFilename.Right(4));
if (spImageReader == NULL)
throw Exception(_T("image file type not supported; filename: ") + cszFilename, __FILE__, __LINE__);
std::shared_ptr<Stream::IStream> spStream = m_fileSystem.OpenFile(cszFilename, true);
LoadInternal(spStream, spImageReader, spTexture, bGenerateMipmap);
}
bool CGbaLoader::Load(bool aForce,bool aNotStart)
{
if(!expansion().IsValid()) return false;
bool load=false,nor=false;
struct stat st;
if(-1==stat(iFileName.c_str(),&st))
{
return false;
}
iSize=st.st_size;
if(iSize>MAX_PSRAM)
{
nor=true;
}
else if(iSize>MAX_NOR)
{
akui::messageBox( NULL, LANG("gba warn", "title"), LANG("gba warn", "text"), MB_OK );
return false;
}
FILE* gbaFile=fopen(iFileName.c_str(),"rb");
if(gbaFile)
{
sGBAHeader header;
fread(&header,1,sizeof(header),gbaFile);
fclose(gbaFile);
if(header.is96h==0x96)
{
load=LoadInternal(nor,aForce);
}
}
if(!aNotStart&&load&&!CheckLink())
{
StartGBA();
}
return load;
}
void XmlFileUtil::Load( XNode *pNode, const RString &sXml, RString &sErrorOut )
{
InitEntities();
LoadInternal( pNode, sXml, sErrorOut, 0 );
}
PSFTags PSFLoader::Load(uint8 version, uint32 max_exe_size, MDFNFILE *fp)
{
return(LoadInternal(version, max_exe_size, fp, 0, false));
}
PSFTags PSFLoader::LoadInternal(uint8 version, uint32 max_exe_size, MDFNFILE *fp, uint32 level, bool force_ignore_pcsp)
{
uint32 reserved_size, compressed_size, compressed_crc32;
bool _lib_present = false;
PSFTags tags;
std::vector<uint8> decompress_buffer;
uLongf decompress_len;
if(!TestMagic(version, fp))
throw(MDFN_Error(0, _("Not a PSF(version=0x%02x) file!"), version));
reserved_size = MDFN_de32lsb(fp->data + 4);
compressed_size = MDFN_de32lsb(fp->data + 8);
compressed_crc32 = MDFN_de32lsb(fp->data + 12);
if(fp->size < (16 + reserved_size + compressed_size))
throw(MDFN_Error(0, _("PSF is missing at least %u bytes of data!"), 16 + reserved_size + compressed_size - fp->size));
if(crc32(0, fp->data + 16 + reserved_size, compressed_size) != compressed_crc32)
throw(MDFN_Error(0, _("PSF compressed CRC32 mismatch(data is corrupt)!")));
{
const uint8 *tag_section = fp->data + 16 + reserved_size + compressed_size;
uint32 tag_section_size = fp->size - 16 - reserved_size - compressed_size;
if(tag_section_size > 5 && !memcmp(tag_section, "[TAG]", 5))
tags.LoadTags(tag_section + 5, tag_section_size - 5);
}
//
// Handle minipsf simple _lib
//
if(level < 15)
{
if(tags.TagExists("_lib"))
{
std::string tp = tags.GetTag("_lib");
if(!MDFN_IsFIROPSafe(tp))
{
throw(MDFN_Error(0, _("Referenced path \"%s\" is potentially unsafe. See \"filesys.untrusted_fip_check\" setting."), tp.c_str()));
}
MDFNFILE subfile(MDFN_MakeFName(MDFNMKF_AUX, 0, tp.c_str()).c_str(), NULL, NULL);
LoadInternal(version, max_exe_size, &subfile, level + 1);
_lib_present = true;
}
}
//
//
//
decompress_buffer.resize(max_exe_size);
decompress_len = max_exe_size;
switch( uncompress((Bytef *)&decompress_buffer[0], &decompress_len, (const Bytef *)(fp->data + 16 + reserved_size), compressed_size) )
{
default:
throw(MDFN_Error(0, "zlib unknown error"));
case Z_OK: break;
case Z_MEM_ERROR:
throw(MDFN_Error(0, "zlib Z_MEM_ERROR"));
case Z_BUF_ERROR:
throw(MDFN_Error(0, _("PSF decompressed size exceeds maximum allowed!")));
case Z_DATA_ERROR:
throw(MDFN_Error(0, _("PSF compressed data is bad.")));
}
HandleReserved(fp->data + 16, reserved_size);
HandleEXE(&decompress_buffer[0], decompress_len, force_ignore_pcsp | _lib_present);
decompress_buffer.resize(0);
//
// handle libN
//
if(level < 15)
{
for(unsigned int n = 2; n <= INT_MAX; n++)
{
char tmpbuf[32];
trio_snprintf(tmpbuf, 32, "_lib%d", (int)n);
if(tags.TagExists(tmpbuf))
{
MDFNFILE subfile(MDFN_MakeFName(MDFNMKF_AUX, 0, tags.GetTag(tmpbuf).c_str()).c_str(), NULL, NULL);
LoadInternal(version, max_exe_size, &subfile, level + 1, true);
}
else
break;
}
}
return(tags);
}
