ShuriZma
/
stella
mirror of https://github.com/stella-emu/stella.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Added disclaimer for new ZipHandler code, and cleaned up some 

debug code and formatting issues.


git-svn-id: svn://svn.code.sf.net/p/stella/code/trunk@2604 8b62c5a3-ac7e-4cc8-8f21-d9a121418aba
This commit is contained in:
stephena 2013-02-12 12:28:53 +00:00
parent b6b6835435
commit 3aa7bfd8e3
4 changed files with 96 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
Copyright.txt
View File

@ -36,3 +36,38 @@ FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. THIS SOFTWARE IS
PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO
OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
MODIFICATIONS.
/***************************************************************************
The Stella project uses certain portions of code under the following
licensing; the specific files also contain this disclaimer:
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.
***************************************************************************/

9
Readme.txt
View File

@ -1,8 +1,7 @@
This is release 3.7.5 of Stella. Stella is a multi-platform Atari 2600 VCS
emulator which allows you to play all of your favourite Atari 2600 games
on your PC. You'll find the Stella Users Manual in the docs subdirectory.
If you'd like to verify that you have the latest release of Stella visit
the Stella Website at:
Stella is a multi-platform Atari 2600 VCS emulator which allows you to
play all of your favourite Atari 2600 games on your PC. You'll find the
Stella Users Manual in the docs subdirectory. If you'd like to verify
that you have the latest release of Stella, visit the Stella Website at:
http://stella.sourceforge.net

88
src/common/ZipHandler.cxx
View File

@ -167,8 +167,10 @@ ZipHandler::zip_error ZipHandler::zip_file_open(const char *filename, zip_file *
{
zip_file *cached = myZipCache[cachenum];
/* if we have a valid entry and it matches our filename, use it and remove from the cache */
if (cached != NULL && cached->filename != NULL && strcmp(filename, cached->filename) == 0)
/* if we have a valid entry and it matches our filename, use it and remove
from the cache */
if (cached != NULL && cached->filename != NULL &&
strcmp(filename, cached->filename) == 0)
{
*zip = cached;
myZipCache[cachenum] = NULL;
@ -195,7 +197,8 @@ ZipHandler::zip_error ZipHandler::zip_file_open(const char *filename, zip_file *
goto error;
/* verify that we can work with this zipfile (no disk spanning allowed) */
if (newzip->ecd.disk_number != newzip->ecd.cd_start_disk_number || newzip->ecd.cd_disk_entries != newzip->ecd.cd_total_entries)
if (newzip->ecd.disk_number != newzip->ecd.cd_start_disk_number ||
newzip->ecd.cd_disk_entries != newzip->ecd.cd_total_entries)
{
ziperr = ZIPERR_UNSUPPORTED;
goto error;
@ -210,7 +213,8 @@ ZipHandler::zip_error ZipHandler::zip_file_open(const char *filename, zip_file *
}
/* read the central directory */
success = stream_read(newzip->file, newzip->cd, newzip->ecd.cd_start_disk_offset, newzip->ecd.cd_size, read_length);
success = stream_read(newzip->file, newzip->cd, newzip->ecd.cd_start_disk_offset,
newzip->ecd.cd_size, read_length);
if (!success || read_length != newzip->ecd.cd_size)
{
ziperr = success ? ZIPERR_FILE_TRUNCATED : ZIPERR_FILE_ERROR;
@ -275,7 +279,6 @@ void ZipHandler::zip_file_cache_clear(void)
for (int cachenum = 0; cachenum < ZIP_CACHE_SIZE; cachenum++)
if (myZipCache[cachenum] != NULL)
{
cerr << "free cache: " << myZipCache[cachenum]->filename << endl;
free_zip_file(myZipCache[cachenum]);
myZipCache[cachenum] = NULL;
}
@ -345,39 +348,40 @@ const ZipHandler::zip_file_header* ZipHandler::zip_file_next_file(zip_file *zip)
zip_file_decompress - decompress a file
from a ZIP into the target buffer
-------------------------------------------------*/
ZipHandler::zip_error ZipHandler::zip_file_decompress(zip_file *zip, void *buffer, uInt32 length)
ZipHandler::zip_error
ZipHandler::zip_file_decompress(zip_file *zip, void *buffer, uInt32 length)
{
zip_error ziperr;
uInt64 offset;
zip_error ziperr;
uInt64 offset;
/* if we don't have enough buffer, error */
if (length < zip->header.uncompressed_length)
return ZIPERR_BUFFER_TOO_SMALL;
/* if we don't have enough buffer, error */
if (length < zip->header.uncompressed_length)
return ZIPERR_BUFFER_TOO_SMALL;
/* make sure the info in the header aligns with what we know */
/* make sure the info in the header aligns with what we know */
if (zip->header.start_disk_number != zip->ecd.disk_number)
return ZIPERR_UNSUPPORTED;
/* get the compressed data offset */
ziperr = get_compressed_data_offset(zip, &offset);
if (ziperr != ZIPERR_NONE)
return ziperr;
/* get the compressed data offset */
ziperr = get_compressed_data_offset(zip, &offset);
if (ziperr != ZIPERR_NONE)
return ziperr;
/* handle compression types */
switch (zip->header.compression)
{
case 0:
ziperr = decompress_data_type_0(zip, offset, buffer, length);
break;
/* handle compression types */
switch (zip->header.compression)
{
case 0:
ziperr = decompress_data_type_0(zip, offset, buffer, length);
break;
case 8:
ziperr = decompress_data_type_8(zip, offset, buffer, length);
break;
ziperr = decompress_data_type_8(zip, offset, buffer, length);
break;
default:
ziperr = ZIPERR_UNSUPPORTED;
break;
}
default:
ziperr = ZIPERR_UNSUPPORTED;
break;
}
return ziperr;
}
@ -393,7 +397,6 @@ void ZipHandler::free_zip_file(zip_file *zip)
{
if (zip != NULL)
{
if (zip->file) cerr << "free: " << zip->filename << endl;
if (zip->file)
stream_close(&zip->file);
if (zip->filename != NULL)
@ -435,7 +438,8 @@ ZipHandler::zip_error ZipHandler::read_ecd(zip_file *zip)
return ZIPERR_OUT_OF_MEMORY;
/* read in one buffers' worth of data */
bool success = stream_read(zip->file, buffer, zip->length - buflen, buflen, read_length);
bool success = stream_read(zip->file, buffer, zip->length - buflen,
buflen, read_length);
if (!success || read_length != buflen)
{
free(buffer);
@ -444,7 +448,8 @@ ZipHandler::zip_error ZipHandler::read_ecd(zip_file *zip)
/* find the ECD signature */
for (offset = buflen - 22; offset >= 0; offset--)
if (buffer[offset + 0] == 'P' && buffer[offset + 1] == 'K' && buffer[offset + 2] == 0x05 && buffer[offset + 3] == 0x06)
if (buffer[offset + 0] == 'P' && buffer[offset + 1] == 'K' &&
buffer[offset + 2] == 0x05 && buffer[offset + 3] == 0x06)
break;
/* if we found it, fill out the data */
@ -485,7 +490,8 @@ ZipHandler::zip_error ZipHandler::read_ecd(zip_file *zip)
get_compressed_data_offset - return the
offset of the compressed data
-------------------------------------------------*/
ZipHandler::zip_error ZipHandler::get_compressed_data_offset(zip_file *zip, uInt64 *offset)
ZipHandler::zip_error
ZipHandler::get_compressed_data_offset(zip_file *zip, uInt64 *offset)
{
uInt32 read_length;
@ -494,7 +500,8 @@ ZipHandler::zip_error ZipHandler::get_compressed_data_offset(zip_file *zip, uInt
return ZIPERR_FILE_ERROR;
/* now go read the fixed-sized part of the local file header */
bool success = stream_read(zip->file, zip->buffer, zip->header.local_header_offset, ZIPNAME, read_length);
bool success = stream_read(zip->file, zip->buffer, zip->header.local_header_offset,
ZIPNAME, read_length);
if (!success || read_length != ZIPNAME)
return success ? ZIPERR_FILE_TRUNCATED : ZIPERR_FILE_ERROR;
@ -514,12 +521,15 @@ ZipHandler::zip_error ZipHandler::get_compressed_data_offset(zip_file *zip, uInt
decompress_data_type_0 - "decompress"
type 0 data (which is uncompressed)
-------------------------------------------------*/
ZipHandler::zip_error ZipHandler::decompress_data_type_0(zip_file *zip, uInt64 offset, void *buffer, uInt32 length)
ZipHandler::zip_error
ZipHandler::decompress_data_type_0(zip_file *zip, uInt64 offset,
void *buffer, uInt32 length)
{
uInt32 read_length;
/* the data is uncompressed; just read it */
bool success = stream_read(zip->file, buffer, offset, zip->header.compressed_length, read_length);
bool success = stream_read(zip->file, buffer, offset, zip->header.compressed_length,
read_length);
if (!success)
return ZIPERR_FILE_ERROR;
else if (read_length != zip->header.compressed_length)
@ -532,7 +542,9 @@ ZipHandler::zip_error ZipHandler::decompress_data_type_0(zip_file *zip, uInt64 o
decompress_data_type_8 - decompress
type 8 data (which is deflated)
-------------------------------------------------*/
ZipHandler::zip_error ZipHandler::decompress_data_type_8(zip_file *zip, uInt64 offset, void *buffer, uInt32 length)
ZipHandler::zip_error
ZipHandler::decompress_data_type_8(zip_file *zip, uInt64 offset,
void *buffer, uInt32 length)
{
uInt32 input_remaining = zip->header.compressed_length;
uInt32 read_length;
@ -557,7 +569,9 @@ ZipHandler::zip_error ZipHandler::decompress_data_type_8(zip_file *zip, uInt64 o
while (1)
{
/* read in the next chunk of data */
bool success = stream_read(zip->file, zip->buffer, offset, BSPF_min(input_remaining, (uInt32)sizeof(zip->buffer)), read_length);
bool success = stream_read(zip->file, zip->buffer, offset,
BSPF_min(input_remaining, (uInt32)sizeof(zip->buffer)),
read_length);
if (!success)
{
inflateEnd(&stream);

9
src/common/ZipHandler.hxx
View File

@ -86,7 +86,8 @@ class ZipHandler
// Replaces functionaity of various osd_xxxx functions
static bool stream_open(const char* filename, fstream** stream, uInt64& length);
static void stream_close(fstream** stream);
static bool stream_read(fstream* stream, void* buffer, uInt64 offset, uInt32 length, uInt32& actual);
static bool stream_read(fstream* stream, void* buffer, uInt64 offset,
uInt32 length, uInt32& actual);
/* Error types */
enum zip_error
@ -253,8 +254,10 @@ class ZipHandler
static zip_error get_compressed_data_offset(zip_file *zip, uInt64 *offset);
/* decompression interfaces */
static zip_error decompress_data_type_0(zip_file *zip, uInt64 offset, void *buffer, uInt32 length);
static zip_error decompress_data_type_8(zip_file *zip, uInt64 offset, void *buffer, uInt32 length);
static zip_error decompress_data_type_0(zip_file *zip, uInt64 offset,
void *buffer, uInt32 length);
static zip_error decompress_data_type_8(zip_file *zip, uInt64 offset,
void *buffer, uInt32 length);
private:
zip_file* myZip;