From 09f604482043fd45b5eebbc73af8b34f31a2b2ce Mon Sep 17 00:00:00 2001 From: Chris Danford Date: Sun, 24 Feb 2002 10:31:20 +0000 Subject: [PATCH] Code cleanup and bug fix in smpackage --- stepmania/src/ArrowEffects.cpp | 91 + stepmania/src/ArrowEffects.h | 49 + stepmania/src/Player.cpp | 61 +- stepmania/src/Player.h | 3 +- stepmania/src/StepMania.dsp | 8 + .../src/smpackage/SMPackageInstallDlg.cpp | 47 +- .../src/smpackage/ZipArchive/Appnote.txt | 257 +- .../src/smpackage/ZipArchive/ChangeLog.txt | 256 ++ .../src/smpackage/ZipArchive/License.txt | 64 + stepmania/src/smpackage/ZipArchive/Readme.txt | 596 +++++ stepmania/src/smpackage/ZipArchive/StdAfx.cpp | 20 +- stepmania/src/smpackage/ZipArchive/StdAfx.h | 32 +- .../ZipArchive/Windows/ZipFileMapping.h | 80 + .../ZipArchive/Windows/ZipPathComponent.cpp | 76 + .../ZipArchive/Windows/ZipPlatform.cpp | 351 +++ .../smpackage/ZipArchive/ZipAbstractFile.h | 52 + .../src/smpackage/ZipArchive/ZipArchive.cpp | 2358 +++++++++++++---- .../src/smpackage/ZipArchive/ZipArchive.dox | 913 +++++++ .../src/smpackage/ZipArchive/ZipArchive.dsp | 265 +- .../src/smpackage/ZipArchive/ZipArchive.h | 2213 +++++++++++----- .../smpackage/ZipArchive/ZipArchive_STL.dsp | 421 +++ .../smpackage/ZipArchive/ZipArchive_STL.dsw | 29 + .../smpackage/ZipArchive/ZipAutoBuffer.cpp | 14 +- .../src/smpackage/ZipArchive/ZipAutoBuffer.h | 35 +- .../smpackage/ZipArchive/ZipBaseException.h | 22 + .../smpackage/ZipArchive/ZipCentralDir.cpp | 565 ++-- .../src/smpackage/ZipArchive/ZipCentralDir.h | 563 +++- .../src/smpackage/ZipArchive/ZipCollections.h | 83 + .../smpackage/ZipArchive/ZipCompatibility.cpp | 214 ++ .../smpackage/ZipArchive/ZipCompatibility.h | 107 + .../src/smpackage/ZipArchive/ZipException.cpp | 260 +- .../src/smpackage/ZipArchive/ZipException.h | 257 +- .../src/smpackage/ZipArchive/ZipFile.cpp | 54 + stepmania/src/smpackage/ZipArchive/ZipFile.h | 67 + .../smpackage/ZipArchive/ZipFileHeader.cpp | 165 +- .../src/smpackage/ZipArchive/ZipFileHeader.h | 387 ++- .../src/smpackage/ZipArchive/ZipFileMapping.h | 80 + .../smpackage/ZipArchive/ZipInternalInfo.cpp | 17 +- .../smpackage/ZipArchive/ZipInternalInfo.h | 60 +- .../src/smpackage/ZipArchive/ZipMemFile.cpp | 98 + .../src/smpackage/ZipArchive/ZipMemFile.h | 105 + .../smpackage/ZipArchive/ZipPathComponent.cpp | 76 + .../smpackage/ZipArchive/ZipPathComponent.h | 208 ++ .../src/smpackage/ZipArchive/ZipPlatform.cpp | 351 +++ .../src/smpackage/ZipArchive/ZipPlatform.h | 174 ++ .../smpackage/ZipArchive/ZipPlatformComm.cpp | 48 + .../src/smpackage/ZipArchive/ZipStorage.cpp | 244 +- .../src/smpackage/ZipArchive/ZipStorage.h | 635 ++++- .../src/smpackage/ZipArchive/ZipString.cpp | 25 + .../src/smpackage/ZipArchive/ZipString.h | 38 + .../smpackage/ZipArchive/__Windows_MFC.zcfg | 0 .../src/smpackage/ZipArchive/_version.txt | 1 + stepmania/src/smpackage/ZipArchive/faq.txt | 211 ++ stepmania/src/smpackage/ZipArchive/gpl.txt | 285 ++ .../ZipArchive/mfc/ZipBaseException.h | 22 + .../smpackage/ZipArchive/mfc/ZipCollections.h | 83 + .../src/smpackage/ZipArchive/mfc/ZipFile.cpp | 54 + .../src/smpackage/ZipArchive/mfc/ZipFile.h | 67 + .../src/smpackage/ZipArchive/mfc/ZipString.h | 38 + .../src/smpackage/ZipArchive/mfc/stdafx.h | 41 + .../src/smpackage/ZipArchive/zlib/Makefile | 79 + .../src/smpackage/ZipArchive/zlib/adler32.c | 49 + .../src/smpackage/ZipArchive/zlib/compress.c | 68 + .../src/smpackage/ZipArchive/zlib/crc32.c | 161 ++ .../src/smpackage/ZipArchive/zlib/deflate.c | 1349 ++++++++++ .../src/smpackage/ZipArchive/zlib/deflate.h | 317 +++ .../src/smpackage/ZipArchive/zlib/gvmat32c.c | 209 ++ .../src/smpackage/ZipArchive/zlib/infblock.c | 398 +++ .../src/smpackage/ZipArchive/zlib/infblock.h | 39 + .../src/smpackage/ZipArchive/zlib/infcodes.c | 257 ++ .../src/smpackage/ZipArchive/zlib/infcodes.h | 27 + .../src/smpackage/ZipArchive/zlib/inffast.c | 170 ++ .../src/smpackage/ZipArchive/zlib/inffast.h | 17 + .../src/smpackage/ZipArchive/zlib/inffixed.h | 151 ++ .../src/smpackage/ZipArchive/zlib/inflate.c | 366 +++ .../src/smpackage/ZipArchive/zlib/inftrees.c | 455 ++++ .../src/smpackage/ZipArchive/zlib/inftrees.h | 58 + .../src/smpackage/ZipArchive/zlib/infutil.c | 87 + .../src/smpackage/ZipArchive/zlib/infutil.h | 98 + .../src/smpackage/ZipArchive/zlib/maketree.c | 85 + .../src/smpackage/ZipArchive/zlib/trees.c | 1213 +++++++++ .../src/smpackage/ZipArchive/zlib/trees.h | 128 + .../src/smpackage/ZipArchive/zlib/uncompr.c | 57 + .../src/smpackage/ZipArchive/zlib/zconf.h | 287 ++ .../src/smpackage/ZipArchive/zlib/zlib.h | 893 +++++++ .../src/smpackage/ZipArchive/zlib/zutil.c | 224 ++ .../src/smpackage/ZipArchive/zlib/zutil.h | 219 ++ stepmania/src/smpackage/resource.h | 4 +- stepmania/src/smpackage/smpackage.clw | 6 +- stepmania/src/smpackage/smpackage.dsp | 3 +- stepmania/src/smpackage/smpackage.rc | 8 +- stepmania/src/smpackage/smpackageDlg.cpp | 3 +- 92 files changed, 19415 insertions(+), 2066 deletions(-) create mode 100644 stepmania/src/ArrowEffects.cpp create mode 100644 stepmania/src/ArrowEffects.h create mode 100644 stepmania/src/smpackage/ZipArchive/ChangeLog.txt create mode 100644 stepmania/src/smpackage/ZipArchive/License.txt create mode 100644 stepmania/src/smpackage/ZipArchive/Readme.txt create mode 100644 stepmania/src/smpackage/ZipArchive/Windows/ZipFileMapping.h create mode 100644 stepmania/src/smpackage/ZipArchive/Windows/ZipPathComponent.cpp create mode 100644 stepmania/src/smpackage/ZipArchive/Windows/ZipPlatform.cpp create mode 100644 stepmania/src/smpackage/ZipArchive/ZipAbstractFile.h create mode 100644 stepmania/src/smpackage/ZipArchive/ZipArchive.dox create mode 100644 stepmania/src/smpackage/ZipArchive/ZipArchive_STL.dsp create mode 100644 stepmania/src/smpackage/ZipArchive/ZipArchive_STL.dsw create mode 100644 stepmania/src/smpackage/ZipArchive/ZipBaseException.h create mode 100644 stepmania/src/smpackage/ZipArchive/ZipCollections.h create mode 100644 stepmania/src/smpackage/ZipArchive/ZipCompatibility.cpp create mode 100644 stepmania/src/smpackage/ZipArchive/ZipCompatibility.h create mode 100644 stepmania/src/smpackage/ZipArchive/ZipFile.cpp create mode 100644 stepmania/src/smpackage/ZipArchive/ZipFile.h create mode 100644 stepmania/src/smpackage/ZipArchive/ZipFileMapping.h create mode 100644 stepmania/src/smpackage/ZipArchive/ZipMemFile.cpp create mode 100644 stepmania/src/smpackage/ZipArchive/ZipMemFile.h create mode 100644 stepmania/src/smpackage/ZipArchive/ZipPathComponent.cpp create mode 100644 stepmania/src/smpackage/ZipArchive/ZipPathComponent.h create mode 100644 stepmania/src/smpackage/ZipArchive/ZipPlatform.cpp create mode 100644 stepmania/src/smpackage/ZipArchive/ZipPlatform.h create mode 100644 stepmania/src/smpackage/ZipArchive/ZipPlatformComm.cpp create mode 100644 stepmania/src/smpackage/ZipArchive/ZipString.cpp create mode 100644 stepmania/src/smpackage/ZipArchive/ZipString.h create mode 100644 stepmania/src/smpackage/ZipArchive/__Windows_MFC.zcfg create mode 100644 stepmania/src/smpackage/ZipArchive/_version.txt create mode 100644 stepmania/src/smpackage/ZipArchive/faq.txt create mode 100644 stepmania/src/smpackage/ZipArchive/gpl.txt create mode 100644 stepmania/src/smpackage/ZipArchive/mfc/ZipBaseException.h create mode 100644 stepmania/src/smpackage/ZipArchive/mfc/ZipCollections.h create mode 100644 stepmania/src/smpackage/ZipArchive/mfc/ZipFile.cpp create mode 100644 stepmania/src/smpackage/ZipArchive/mfc/ZipFile.h create mode 100644 stepmania/src/smpackage/ZipArchive/mfc/ZipString.h create mode 100644 stepmania/src/smpackage/ZipArchive/mfc/stdafx.h create mode 100644 stepmania/src/smpackage/ZipArchive/zlib/Makefile create mode 100644 stepmania/src/smpackage/ZipArchive/zlib/adler32.c create mode 100644 stepmania/src/smpackage/ZipArchive/zlib/compress.c create mode 100644 stepmania/src/smpackage/ZipArchive/zlib/crc32.c create mode 100644 stepmania/src/smpackage/ZipArchive/zlib/deflate.c create mode 100644 stepmania/src/smpackage/ZipArchive/zlib/deflate.h create mode 100644 stepmania/src/smpackage/ZipArchive/zlib/gvmat32c.c create mode 100644 stepmania/src/smpackage/ZipArchive/zlib/infblock.c create mode 100644 stepmania/src/smpackage/ZipArchive/zlib/infblock.h create mode 100644 stepmania/src/smpackage/ZipArchive/zlib/infcodes.c create mode 100644 stepmania/src/smpackage/ZipArchive/zlib/infcodes.h create mode 100644 stepmania/src/smpackage/ZipArchive/zlib/inffast.c create mode 100644 stepmania/src/smpackage/ZipArchive/zlib/inffast.h create mode 100644 stepmania/src/smpackage/ZipArchive/zlib/inffixed.h create mode 100644 stepmania/src/smpackage/ZipArchive/zlib/inflate.c create mode 100644 stepmania/src/smpackage/ZipArchive/zlib/inftrees.c create mode 100644 stepmania/src/smpackage/ZipArchive/zlib/inftrees.h create mode 100644 stepmania/src/smpackage/ZipArchive/zlib/infutil.c create mode 100644 stepmania/src/smpackage/ZipArchive/zlib/infutil.h create mode 100644 stepmania/src/smpackage/ZipArchive/zlib/maketree.c create mode 100644 stepmania/src/smpackage/ZipArchive/zlib/trees.c create mode 100644 stepmania/src/smpackage/ZipArchive/zlib/trees.h create mode 100644 stepmania/src/smpackage/ZipArchive/zlib/uncompr.c create mode 100644 stepmania/src/smpackage/ZipArchive/zlib/zconf.h create mode 100644 stepmania/src/smpackage/ZipArchive/zlib/zlib.h create mode 100644 stepmania/src/smpackage/ZipArchive/zlib/zutil.c create mode 100644 stepmania/src/smpackage/ZipArchive/zlib/zutil.h diff --git a/stepmania/src/ArrowEffects.cpp b/stepmania/src/ArrowEffects.cpp new file mode 100644 index 0000000000..9e695e8b51 --- /dev/null +++ b/stepmania/src/ArrowEffects.cpp @@ -0,0 +1,91 @@ +#include "stdafx.h" +/* +----------------------------------------------------------------------------- + File: ArrowEffects.cpp + + Desc: Functions that return properties of arrows based on Style and PlayerOptions + + Copyright (c) 2001-2002 by the names listed below. All rights reserved. + Chris Danford +----------------------------------------------------------------------------- +*/ +#include "ArrowEffects.h" +#include "Steps.h" +#include "ColorArrow.h" +#include "ScreenDimensions.h" + + +float ArrowGetYOffset( const PlayerOptions& po, float fStepIndex, float fSongBeat ) +{ + float fBeatsUntilStep = StepIndexToBeat( fStepIndex ) - fSongBeat; + float fYOffset = fBeatsUntilStep * ARROW_GAP; + switch( po.m_EffectType ) + { + case PlayerOptions::EFFECT_BOOST: + fYOffset *= 1.4f / ((fYOffset+SCREEN_HEIGHT/1.6f)/SCREEN_HEIGHT); + break; + case PlayerOptions::EFFECT_WAVE: + fYOffset += 15.0f*sinf( fYOffset/38.0f ); + break; + } + return fYOffset; +} + +float ArrowGetXPos( const PlayerOptions& po, const Style &style, int iColNum, float fYOffset, float fSongBeat ) +{ + float fColOffsetFromCenter = iColNum - (style.m_iNumColumns-1)/2.0f; + float fPixelOffsetFromCenter = fColOffsetFromCenter * ARROW_SIZE; + + switch( po.m_EffectType ) + { + case PlayerOptions::EFFECT_DRUNK: + fPixelOffsetFromCenter += cosf( (GetTickCount()%1000000)/250.0f + iColNum*0.4f + fYOffset/SCREEN_HEIGHT*4) * ARROW_SIZE/3; + break; + } + return fPixelOffsetFromCenter; +} + +float ArrowGetRotation( const PlayerOptions& po, const Style &style, int iColNum, float fYOffset ) +{ + float fRotation = style.m_ColumnToRotation[iColNum]; + + switch( po.m_EffectType ) + { + case PlayerOptions::EFFECT_DIZZY: + fRotation += fYOffset/SCREEN_HEIGHT*6; + break; + } + + return fRotation; +} + +float ArrowGetYPos( const PlayerOptions& po, float fYOffset ) +{ + return fYOffset * po.m_fArrowScrollSpeed * (po.m_bReverseScroll ? -1 : 1 ); +} + +float ArrowGetAlpha( const PlayerOptions& po, float fYPos ) +{ + float fAlpha; + switch( po.m_AppearanceType ) + { + case PlayerOptions::APPEARANCE_VISIBLE: + fAlpha = 1; + break; + case PlayerOptions::APPEARANCE_HIDDEN: + fAlpha = (fYPos-100)/200; + break; + case PlayerOptions::APPEARANCE_SUDDEN: + fAlpha = ((SCREEN_HEIGHT-fYPos)-280)/200; + break; + case PlayerOptions::APPEARANCE_STEALTH: + fAlpha = 0; + break; + }; + if( fYPos < 0 ) + fAlpha = 1; + + return fAlpha; +}; + + diff --git a/stepmania/src/ArrowEffects.h b/stepmania/src/ArrowEffects.h new file mode 100644 index 0000000000..a7d6b5e348 --- /dev/null +++ b/stepmania/src/ArrowEffects.h @@ -0,0 +1,49 @@ +/* +----------------------------------------------------------------------------- + File: ArrowEffects.h + + Desc: Functions that return properties of arrows based on Style and PlayerOptions + + Copyright (c) 2001-2002 by the names listed below. All rights reserved. + Chris Danford +----------------------------------------------------------------------------- +*/ + +#ifndef _ArrowEffects_H_ +#define _ArrowEffects_H_ + + +#include "GameTypes.h" +#include "Style.h" + + +// fYOffset is a vertical position in pixels relative to the center. +// (positive if has not yet been stepped on, negative if has already passed). +// The ArrowEffect is applied in this stage. +float ArrowGetYOffset( const PlayerOptions& po, float fStepIndex, float fSongBeat ); + + +// fXPos is a horizontal position in pixels relative to the center of the field. +// This depends on the column of the arrow and possibly the Arrow effect and +// fYOffset (in the case of EFFECT_DRUNK). +float ArrowGetXPos( const PlayerOptions& po, const Style &style, int iCol, float fYOffset, float fSongBeat ); + + +// fRotation is Z rotation of an arrow. This will depend on the column of +// the arrow and possibly the Arrow effect and the fYOffset (in the case of +// EFFECT_DIZZY). +float ArrowGetRotation( const PlayerOptions& po, const Style &style, int iCol, float fYOffset ); + + +// fYPos is the position of the note in pixels relative to the center. +// (positive if has not yet been stepped on, negative if has already passed). +// This value is fYOffset with bReverseScroll and fScrollSpeed factored in. +float ArrowGetYPos( const PlayerOptions& po, float fYOffset ); + + +// fAlpha is the transparency of the arrow. It depends on fYPos and the +// ArrowAppearance. +float ArrowGetAlpha( const PlayerOptions& po, float fYPos ); + + +#endif diff --git a/stepmania/src/Player.cpp b/stepmania/src/Player.cpp index 2f0f317b41..ad221ae2f8 100644 --- a/stepmania/src/Player.cpp +++ b/stepmania/src/Player.cpp @@ -15,6 +15,8 @@ #include "Player.h" #include "RageUtil.h" #include "ThemeManager.h" +#include "GameTypes.h" +#include "ArrowEffects.h" const float JUDGEMENT_Y = CENTER_Y; @@ -65,6 +67,7 @@ void Player::Load( const Style& style, PlayerNumber player_no, const Steps& step m_Style = style; m_PlayerNumber = player_no; + m_PlayerOptions = po; Steps steps2 = steps; @@ -77,8 +80,8 @@ void Player::Load( const Style& style, PlayerNumber player_no, const Steps& step steps2.MakeLittle(); m_ColorArrowField.Load( style, steps2, po, 2, 10 ); - m_GrayArrows.Load( style ); - m_GhostArrows.Load( style ); + m_GrayArrows.Load( po, style ); + m_GhostArrows.Load( po, style ); // load step elements for( int i=0; iGetDevice()->SetRenderState( D3DRS_ZENABLE, FALSE ); + SCREEN->GetDevice()->SetRenderState( D3DRS_ZWRITEENABLE, FALSE ); + + // save old view and projection + SCREEN->GetDevice()->GetTransform( D3DTS_VIEW, &matOldView ); + SCREEN->GetDevice()->GetTransform( D3DTS_PROJECTION, &matOldProj ); + + + // construct view and project matrix + D3DXMATRIX matNewView; + D3DXMatrixLookAtLH( &matNewView, &D3DXVECTOR3( CENTER_X, GetY()+800.0f, 300.0f ), + &D3DXVECTOR3( CENTER_X + , GetY()+400.0f, 0.0f ), + &D3DXVECTOR3( 0.0f, -1.0f, 0.0f ) ); + SCREEN->GetDevice()->SetTransform( D3DTS_VIEW, &matNewView ); + + D3DXMATRIX matNewProj; + D3DXMatrixPerspectiveFovLH( &matNewProj, D3DX_PI/4.0f, SCREEN_WIDTH/(float)SCREEN_HEIGHT, 0.0f, 1000.0f ); + SCREEN->GetDevice()->SetTransform( D3DTS_PROJECTION, &matNewProj ); + } + + m_GrayArrows.Draw(); + m_ColorArrowField.Draw(); + m_GhostArrows.Draw(); + + if( m_PlayerOptions.m_EffectType == PlayerOptions::EFFECT_STARS ) + { + // restire old view and projection + SCREEN->GetDevice()->SetTransform( D3DTS_VIEW, &matOldView ); + SCREEN->GetDevice()->SetTransform( D3DTS_PROJECTION, &matOldProj ); + + // turn Z Buffering back on + SCREEN->GetDevice()->SetRenderState( D3DRS_ZENABLE, TRUE ); + SCREEN->GetDevice()->SetRenderState( D3DRS_ZWRITEENABLE, TRUE ); + } + + + m_Judgement.Draw(); + for( int c=0; cSetWindowText( sMessage1 ); - // add all the files in the zip to the message + + // + // Set the text of the second Edit box + // + CString sMessage2; try { - m_zip.Open( m_sPackagePath ); + m_zip.Open( m_sPackagePath, CZipArchive::zipOpenReadOnly ); } catch (CException* e) { @@ -79,28 +89,35 @@ BOOL CSMPackageInstallDlg::OnInitDialog() exit( 1 ); } - for( int i=0; iSetWindowText( sMessage2 ); + + + // + // Set the text of the third Edit box + // TCHAR szCurrentDirectory[MAX_PATH]; GetCurrentDirectory( MAX_PATH, szCurrentDirectory ); - sMessage += ssprintf( - "\r\n" + CString sMessage3 = ssprintf( "The package will be installed in the Stepmania program folder:\r\n" + "\r\n" "\t%s", szCurrentDirectory ); // Set the message - CEdit* pEdit = (CEdit*)GetDlgItem(IDC_EDIT_MESSAGE); - pEdit->SetWindowText( sMessage ); + CEdit* pEdit3 = (CEdit*)GetDlgItem(IDC_EDIT_MESSAGE3); + pEdit3->SetWindowText( sMessage3 ); @@ -147,7 +164,7 @@ void CSMPackageInstallDlg::OnOK() GetCurrentDirectory( MAX_PATH, szCurrentDirectory ); // Unzip the SMzip package into the Stepmania installation folder - for( int i=0; i ver 2.2b (01-2002) + + Bugs fixed: + - while a file recompression (smartness level included CZipArchive::zipsmCheckForEff) if the + AutoFlush feature was enabled, there were redundant bytes added to the archive (thanks to Roman Scherzer) + + ver 2.2a (11-2001) + + Bugs fixed: + - aborting extraction of multi-disk archive caused errors (thanks to Sabina Terenzi) + + + ver 2.2 (10-2001) Time for global changes + + Features added: + - deleting multiple files from the archive is now way faster - the files are not + deleted separately as it was so far, but the library creates a map of holes and continuous areas and moves the data to remain in file over the holes; it means that the data is copied + only once and not for every file to delete. + - callback functions has been replaced by functional objects to make the code cleaner and to make it possible to pass more information during a callback call (see: CZipArchive::SetCallback). The same application written using the library with callback functions + and then with functional objects as callbacks (slightly modified) has proven to be circa 15% faster in the latter case (that's why it's in \e features), i.a. because only data that changes is passed to the callback method, method derived from CZipCallback::Callback can be inlined if defined inside the class declaration). Important issues: + - it affects the following functions parameters: + - CZipArchive::AddNewFile, + - CZipArchive::ExtractFile, + - CZipArchive::TestFile, + - CZipArchive::SetSpanCallback + - the meaning of the parameters passed to a callback functor is different from that what has so far been passed to the callback functions + (see CZipCallback) + - see \ref sectCallb if you're not sure how to use functors + - added callback feature when deleting files + - added callback feature when saving central directory + - added possibility to extract or delete files which filenames match the specified wildcard pattern (see CZipArchive::FindMatches) + - iterating the central directory elements speeded up (hence all the operations that iterate the central directory were speeded up, especially sorting, multiple adding, extracting, testing) + - the library now doesn't throw an exception if the platform the archive was created under is not supported, but it tries to distinguish files from directories + - CZipArchive::Flush can be called now for a disk-spanning archive in creation finalizing it then, and yet allows extracting or testing (see the function description for more) + - function CZipArchive::CloseNewFile can be called after an exception to allow to repair the archive later + - adding files with one of CZipArchive::AddNewFile functions can be safely aborted in a non-disk-spanning archive (the added data is removed from the archive) + - added function CZipException::GetErrorMessage for compatibility with MFC \c CException::GetErrorMessage + - added parameter \e bForce to CZipArchive::SetTempPath that creates the directory if it doesn't exists + - the archive created with the library under Windows can be now correctly extracted under Linux and vice versa without the need for setting the system compatibility of the files + - function CZipArchive::SetIgnoreCRC added to make possible working with the Java TM Archives (jar) + - function CZipArchive::GetFindFastIndex added + - function CZipArchive::GetCentralDirInfo added + - function CZipArchive::GetCentralDirSize added + - function CZipArchive::GetCurrentDisk added + - function CZipArchive::IsReadOnly added + - function CZipFileHeader::CompressionEfficient added + - function CZipFileHeader::GetCompressionRatio added + - \c const keywords added to functions + - TRACE messages are now easier to locate in MSVC++ (double clicking gets you directly to the code now) + + + + Changes: + - if the callback functor's method \c Callback returns \c false, + a CZipException is thrown with code CZipException::abortedAction or CZipException::abortedSafely; + - function CZipArchive::DeleteFiles(const CZipStringArray) uses now FindFast array; added \e bFileNameOnly parameter + - function CZipArchive::GetNoEntries renamed to GetCount (more standard, easier to type and easier to find at the beginning) + - the encrypted file is not recompressed again if the difference in sizes before and after compression is the + length of the encryption header + - function CZipArchive::OpenFile throws exception CZipException::badPassword if the password + was not set for the encrypted file instead of returning \c false; + - versioning shortened + + + Bugs fixed: + - CZipStorage::Flush doesn't call now m_pFile->Flush() (it has proven to slow + down the archive creation speed significantly) - it is called in different places instead + - CZipArchive::TestFile sometimes was not detecting wrong password set + - filenames in zip are now correctly converted after calling CZipArchive::Flush + - fixed value of CZipArchive::zipsmCheckForEffInMem; the bug cause the temporary file to be always created in memory + - ZipPlatform::GetDeviceFreeSpace was not working on Windows with other devices than removable (in spite of what is written in MSDN + it is sometimes needed to add slash when passing drive name to \c GetDiskFreeSpace and sometimes not). + I'm not sure if this bug concerned all Windows platforms (it was detected on Windows 2000) + - crash eliminated when the file modification time could not be retrieved (in case of an impossible value e.g. a year is 28980) + - Unix attributes corrected + - CZipArchive::ExtractFile had wrong value passed to the callback function + + ver 2.1.1 (10-2001) + + Features added: + + - Linux version at the beta stage (thanks to Luiz Rafael Culik for help) + - smart and efficient compression added to CZipArchive::AddNewFile
+ i.a. optional compression to a temporary file first or to memory, in a disk spanning mode, + to see whether the file is smaller after compression and if it is not + then add it without the compression (see also CZipArchive::Smartness) + - integration of the help system with MSDN made possible (see: \ref sectHelp) + - adding a file with the user-specified filename in zip ( CZipArchive::AddNewFile(LPCTSTR , LPCTSTR , int , int , unsigned long ) ) + - adding files from memory and extracting files to memory + ( CZipArchive::AddNewFile(CZipMemFile&, LPCTSTR, int, int, unsigned long) and + CZipArchive::ExtractFile(WORD, CZipMemFile&, DWORD)) + - function CZipArchive::Flush added - increases the safety when working with zip archives (thanks to Brad Kremer for the idea) + - function CZipArchive::SetCaseSensitivity added (see the function description which functions it affects) + - function CZipArchive::PredictFileNameInZip added + - function CZipArchive::PredictExtractedFileName added + - function CZipArchive::FindFile speeded up again, the case-sensitivity parameter meaning changed, added possibility to find a filename only without a path (see the function description) + - function CZipArchive::TrimRootPath function improved + - function CZipArchive::Close allows now to write the central directory to the archive even after exception, which lets you e.g. repair the archive later + - obtaining error descriptions (English only) - see CZipException::GetErrorDescription() + - STL sample application added (a command line archiver which works for both Windows and Linux; located in \e stl/zippie) + - in TestZipDlg sample application added switch in options to allow an effective compression + - several minor enhancements + + Changes: + + - CZipPathComponent functions renamed : GetFullFileName -> GetFileName, GetFileName -> GetFileTitle, SetFileName -> SetFileTitle + - file \e __[...].zcfg is created depending on the current configuration when using scripts to copy files (see a note at \ref secCompil) + + Bugs fixed: + + - when performing a non-case-sensitive search with CZipArchive::FindFile (thanks to Kenny Prole) + - in CZipString (STL) when using a different locale than English and + non-English characters (see \ref stlNotes for info on how to set your locale in the program) + - CZipStorage::Flush call now m_pFile->Flush() as well (it might have caused a zip creation problems sometimes) + + ver 1.6.6 (08-2001) + + Features added: + + - CZipPathComponent understands now a UNC path, so it is possible to + extract files over a network (other operations over a network were + already possible) + - sample application updated to reflect previous (ver 1.6.5) and + current changes (necessary prefix added to a UNC path following + the Windows File Name Conventions : see \ref q11 "FAQ") + + + ver 1.6.5 (07-2001) + + Features added: + + - added function CZipArchive::SetRootPath that allows more flexible path + manipulations when using CZipArchive::AddNewFile and CZipArchive::ExtractFile + - ability to set the archive system compatibility to a value different + than the current system ID with the function CZipArchive::SetSystemCompatibility() + + Bugs fixed: + + - bug which caused not updating the time stamp of an extracted file + and an exception being thrown, if the file had the read-only attribute set + (thanks to Arnon Meydav) + - bugs in conversion of Unix attributes + - directories inside the archive are now recognized properly by Unix archivers + if the archive was created for Unix platform + + + ver 1.6.4 (06-2001) + + - fixed errors that made impossible using CZipMemFile class and + creation of the archives in memory + + + + ver 1.6.3 (05-2001) + + - zlib library sources incorporated into ZipArchive library projects +(eliminates most often link errors) + + + ver 1.6.2 (04-2001) + + - ZipPlatform::SetVolLabel() appends now a directory separator to the drive name (lack of it caused errors sometimes) + - added a simple protection against compiling MFC or STL version without copying the proper files first + - added several preprocessor directives for Borland compilers + + + ver 1.6.1 (03-2001) + + Features added: + + - non MFC dependent version (STL) + - porting to different platforms made easier + - possibility to read zip files created on other platforms than Windows + (correct interpretation of file/directory attributes) + - documentation generated (using + \htmlonly + Doxygen + \endhtmlonly + ) + + Changes: + + - LICENSING CHANGED + - overall tuning + - sample application updated + + ver 1.5.1 (02-2001) + + + Features added: + + - ability to reuse the archive after an exception thrown during extraction + - added progress control possibilities to CZipArchive::AddNewFile, CZipArchive::ExtractFile, CZipArchive::TestFile + - when the central directory was not located, the library throws CZipException::cdirNotFound, which allows distinguish from other exceptions (useful when we want to keep prompting the user to insert the last disk in a multi-disk spanning archive). + + + Changes: + + - CZipArchive::FindFile operation boosted ( thanks to Darin Warling) + - library name changed to ZipArchive + - the sample application updated + + Bugs fixed: + + - removed bug during extracting an encrypted file with 0 size + - fixed bug when extracting a file with an extra field in a local file header (CFileHeader::ReadLocal) + + ver 1.4.1 (01-2001) + - Disk numbering in a disk spanning archive begins now from PKBACK# 001 not PKBACK# 000 + - Adding and extracting without a full path possible in CZipArchive::AddNewFile and CZipArchive::ExtractFile. + - Several minor changes and enhancements + - Changed names for several classes. + + ver 1.3.1 (11-2000) + - Added support for password encryption and decryption. + The encryption used in PKZIP was generously supplied by Roger + Schlafly. + - Testing the archive made easier + - Unicode support added + + ver 1.2.2 (08-2000) + - Bugs fixed + + ver 1.2.1 (06-2000) +\par + the code has been completely rewritten from the very beginning; + the main improvements are: + - multi-disk archive support + - creation of the disk spanning archives with the user-defined volume size + - ability to modify existing archives (add, delete files) + - modification self-extracting archives + - write buffer used for faster disk write operations + - one class for zip and unzip functions + - fast adding, deleting and extracting files with a single function call + + ver 1.1.2 (03-2001) + - international characters in filenames inside archive are now + converted in a compatible way with other archiving programs (they are stored + converted to OEM inside archive). + + ver 1.1.1 (01-2000) +\par + the first version; it is just modified code from zip.c and unzip.c files + written by Gilles Vollant and distributed with zlib library; + the modifications are as follows: + - added class' wrappers + - several bugs fixed + - several enhancements added + - MFC support added + - memory leaks eliminated when write error occurred + - automatically free used memory on destruction or exception + - modern error notification using exceptions + +*/ diff --git a/stepmania/src/smpackage/ZipArchive/License.txt b/stepmania/src/smpackage/ZipArchive/License.txt new file mode 100644 index 0000000000..b55c0d541d --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/License.txt @@ -0,0 +1,64 @@ +/** \page pageLic Licensing information + +ZipArchive library - creation, modification and extraction of "zip" format archives
+Copyright © 2000 - 2002 Tadeusz Dracz.
+E-Mail: \htmlonly tdracz@artpol-software.com
+Web: http://www.artpol-software.com \endhtmlonly + +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 library 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 library; if not, write to the Free Software +Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +
+************************************************************************* +An English version of the \ref pageGPL "GNU GPL" is in the gpl.txt file distributed with +this project. Translations to other languages are available at: +\htmlonly +http://www.gnu.org/copyleft/gpl.html +\endhtmlonly + + +Distributing ZipArchive under GNU GPL implies ZipArchive can only be used +with software that is licensed under conditions compliant with the GPL. +Embedding in proprietary software requires an alternative license. + + +\subsection s1 Alternative license for use with proprietary software + + +If you want to distribute software in a commercial context that incorporates +ZipArchive and you do not want to meet the conditions of GNU GPL +(e.g. an obligation to provide a customer with the source code of your +software that uses the ZipArchive library), you need to have a commercial license. +- The commercial license provides you with the same rights as the GNU GPL, but in +addition allows you to embed ZipArchive library in proprietary software without +affecting the copyright of this software (it removes the GNU GPL obligation +to publish the source code) +- The license does not allow you to transfer these rights +- The license is granted per developer or per company +- It does not depend on the amount of copies of software that uses the library sold +- You won't need to purchase an additional license for the future versions of the library + + +The commercial license is available free of charge for freeware and shareware +programs. If your program is distributed in a similar way to the one of the +above, the commercial license will be granted to you free of charge as well. +
+There is a fee for the commercial license for using the library in the software +not falling into the mentioned categories. +
+It is recommended that you should print two copies of the commercial license +document after you receive it, sign them and send by post. One copy, signed by the author will be sent back to you. +Please \htmlonly contact the author or visit the Artpol Software web site\endhtmlonly to find out more. + +*/ diff --git a/stepmania/src/smpackage/ZipArchive/Readme.txt b/stepmania/src/smpackage/ZipArchive/Readme.txt new file mode 100644 index 0000000000..f8531f3eee --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/Readme.txt @@ -0,0 +1,596 @@ +/* + +For conditions of distribution and use, see the copyright notice in License.txt. +Please read the documentation instead of this document +(it may be difficult to read it due to formatting tags for an automatic documentation generation). +If you do not have it, please download it from http://www.artpol-software.com/ + +*/ + +/** \mainpage ZipArchive library documentation + +\section secGen General Information + + +The ZipArchive library
+ +Copyright © 2000 - 2002 Tadeusz Dracz
+ + +\b Version: 2.2
+\b Date: 10-January-2002 + + +This library adds zip compression and decompression functionality to your program, allowing you to create and modify ZIP files in the compatible way with WinZip and PKZIP. +It's easy and practical interface makes the library suitable for the beginners as well as for the advanced users. + + +\ref pageSyst "Platforms supported:" +- Windows 9x\Me\NT\2000\XP (MFC and STL) - \ref sectVisual "Microsoft Visual C++ 6.0", \ref sectBorl "Borland C++" +- \ref sectLinux "Linux (STL)" + +\author Tadeusz Dracz
+E-Mail: \htmlonly tdracz@artpol-software.com \endhtmlonly
+Web Site: \htmlonly http://www.artpol-software.com \endhtmlonly + +This library uses \htmlonly the zlib library \endhtmlonly by Jean-loup Gailly and Mark Adler to perform inflate and deflate operations. + +\section sectFeat Features Summary: +- work in a compatible way with PKZIP and WinZip (apart from \ref TDSpan "TD disk spanning mode" which is specific to this library) +- create, modify, extract and test zip archives +- create and extract multi-disk archives (on non-removable disks as well) +- password encryption and decryption supported +- possibility to create or extract self-extracting archives +- compression from and decompression to memory, create the whole archive in memory, extract the archive from memory (see \ref sectMemory) +- smart compression, if enabled, prevents the file in the archive to be larger after compression (see CZipArchive::Smartness) +- safe compression with CZipArchive::Flush function +- using functional objects as callback + - to provide easy disk change in a multi-disk archives + - for the progress control when adding, extracting, testing or deleting files or saving archive's central directory +- extracting and deleting using wildcard pattern matching (see CZipArchive::FindMatches) +- UNC and Windows Unicode paths recognized +- wide characters supported +- support for the Java TM Archive (jar) File Format (see CZipArchive::SetIgnoreCRC) +- possibility to integrate help system with MSDN (see \ref sectHelp) +- easy interface +- easy transfer to other system platforms +- speedy +- well documented +- full source code provided +- sample applications provided (for the STL version located in \e stl/zippie, +the MFC version is available separately) + +Suggestions and bug reports are welcome. Drop me a note if you wish to share any. + +\section secQl Quick Links + +\par +\ref pageGen +\par +\ref pageSyst +\par +\ref pageFaq +\par +\ref pageHist +\par +\ref pageLic +\par +\ref pageSubsc + + + */ + +/** + + \page pageSyst Compilation & Integration + + \subsection stlNotes STL version notes + - [Windows only] If your locale is different from English and you wish to use non-English + characters in zip files, you need to set your locale with function + \e std::locale::global(std::locale("")) to set it to be the same as your + system locale or e.g. \e std::locale::global(std::locale("French")) + to set it to the specified value (do not use \e _T() macro here when using + Unicode); \e setlocale() function is not sufficient in this case. + - There is a sample application that compiles under Windows (MSVC) and Linux (see below + to find out \ref stlLinuxTest "how to compile it under Linux"). This sample application demonstrates most of the + ZipArchive library features and is located in \e stl/zippie. + + \subsection MFCsample MFC sample application (ZipArc) notes + MFC sample application using ZipArchive library is available separately. Main features: + - MDI application + - multithreaded - you can work with many zip files at one time + - shell integration (remembers the last application used to open zip files and can restore it correctly) + - drag & drop support + - detailed error reports + - you can open and modify SFX archives + - it demonstrates the use of the following functions (most of them are placed in ZipArcDoc.cpp) : + CZipArchive::AddNewFile, + CZipArchive::Close, + CZipArchive::CloseFile, + CZipArchive::CloseNewFile, + CZipArchive::DeleteFiles, + CZipArchive::EnableFindFast, + CZipArchive::ExtractFile, + CZipArchive::FindFile, + CZipArchive::FindMatches, + CZipArchive::Flush, + CZipArchive::GetArchivePath, + CZipArchive::GetCentralDirInfo, + CZipArchive::GetCentralDirSize, + CZipArchive::GetCurrentDisk, + CZipArchive::GetFileInfo, + CZipArchive::GetFindFastIndex, + CZipArchive::GetGlobalComment, + CZipArchive::GetCount, + CZipArchive::GetPassword, + CZipArchive::GetSpanMode, + CZipArchive::IsClosed, + CZipArchive::IsReadOnly, + CZipArchive::Open, + CZipArchive::PredictExtractedFileName, + CZipArchive::SetAdvanced, + CZipArchive::SetCallback, + CZipArchive::SetFileComment, + CZipArchive::SetGlobalComment, + CZipArchive::SetIgnoreCRC, + CZipArchive::SetPassword, + CZipArchive::SetRootPath, + CZipArchive::SetSpanCallback, + CZipArchive::SetTempPath, + CZipArchive::TestFile,
+ CZipFileHeader::IsEncrypted, + CZipFileHeader::IsDirectory, + CZipFileHeader::GetTime, + CZipFileHeader::GetSystemCompatibility, + CZipFileHeader::GetSystemAttr, + CZipFileHeader::GetSize, + CZipFileHeader::GetFileName, + CZipFileHeader::GetEffComprSize, + CZipFileHeader::GetCompressionRatio, + CZipFileHeader::GetComment, + CZipFileHeader::CompressionEfficient, + + \section secCompil Compiling for different implementations and platforms + + + The files required for all the library versions are located in the program + root directory. You also need to copy additional files to the library + root directory from the two more subfolders. Depending on the configuration + these files are located in: + + + \subsection winMFC Windows MFC + \e \Windows and \e \mfc
+ You can just execute _copy from Win-MFC.bat batch file. + + \subsection winSTL Windows STL + \e \Windows and \e \stl
+ You can just execute _copy from Win-STL.bat batch file. + + \subsection LnxSTL Linux (STL version) + \e \Linux and \e \stl
+ You can just execute _copy_from_Linux.sh script file + (don't forget to set executable rights before e.g. with the command: + chmod +x _copy_from_Linux.sh ). + + \note If you use one of the mentioned scripts to copy the files then for easy + orientation there will be a file \e __[...].zcfg created with the + name depending on the current configuration + + \section sectVisual Visual C++ : integrating with the project + + To add ZipArchive library functionality into your project you need to link + the library to the project. You can do this in at least two ways + (in both cases you need to include ZipArchive.h header in your sources). + + \subsection subsM1 Method 1 + + Add \e ZipArchive.lib with the proper path e.g. ..\ZipArchive\debug\ZipArchive.lib to Project Settings->Link->Input->Object/library modules + and add ZipArchive library directory to the preprocessor searches ( Project Settings -> C++ -> Preprocessor -> Additional include directories ). + + \subsection subsM2 Method 2 (simpler) + Insert Zip project into workspace and set project dependencies: your project dependent on ZipArchive project + ( Project -> Dependencies and then on the dialog that will appear + you select your project name from the combo box and check the box next to ZipArchive project name). + When you use this method, you link configurations in your project with + configurations in the ZipArchive project that have the same name in both projects. So if you need to use + for example "Static Release" configuration from ZipArchive project, you need to create one with the same name + in your application project and make sure that your project uses MFC library and run-time library in same way + ( Project->Settings->General->Microsoft Fundation Classes and Project->Settings-> c/c++ ->Code Generation->Use run-time library ). + + In case you experience linking problems, please see the \ref pageFaq. + + \section sectBorl Borland C++ compatibility + The library contains a project files for Borland C++ 5.0 ( + They were created using Visual C++ Project Conversion Utility (VCTOBPR.EXE). + You can start it with the command Tools->Visual C++ Project Conversion Utility . + - The project \e ZipArchive.bpr was converted from a Release configuration + of the MFC version of the library (\e ZipArchive.dsp). + - The project \e ZipArchive_no_MFC.bpr was converted from a Release configuration + of the non MFC version of the library (\e ZipArchive_no_MFC.dsp). + + \note Be sure to create \e Release subfolder before compiling one of these projects, + otherwise you'll get a write error. + + In case the projects provided don't work for you, you can create your own. You need to copy + to the root directory appropriate files for \ref winMFC "MFC" or \ref winSTL "STL" versions. + You may use the Borland project conversion utility. + + The library contains also \e makefiles which should work with every version of Borland. + + + \subsection subExample Compiling the sample application + There is a Borland C++ project provided with the sample application \c ZipArc.
+ To compile it you need compiled MFC version of ZipArchive library. + + \note Be sure to create \e Release subfolder first, otherwise you'll get + a write error. + + Add the library (\e ZipArchive.lib ) to the project (Project->Add To Project) and compile. + + If you wish to convert Visual C++ project using Visual C++ Project Conversion Utility then after + converting to properly compile the application you need to remove \e odbccp32.lib from the project file + and comment everything out in \e ZipArc_TLB.cpp or remove this file from the project files. + + \section sectLinux Linux platform + + \subsection subsLnxNot Notes + + + \b Usage + + When using the library under Linux you should be aware of a few things: + - after you get the system attributes with CZipFileHeader::GetSystemAttr() function, + you need to shift them right by 16 ( e.g. uAttr = header.GetSystemAttr() >> 16 ) - + the reason for that is the way the attributes are stored in the archive created under (or for) Linux. + - due to lack of implementation of ZipPlatform::IsDriveRemovable(), which has proven to be a kind of difficult to do, + the device containing the archive is always assumed to be removable; the only effect of this + is that you need to set \e iVolumeSize to a value different from 0 when opening with the function + CZipArchive::Open() the archive created in tdSpan mode. + + + \b Compiling + + - the library was tested under g++ version 2.96 + - warnings that use of the \c tempnam and \c mktemp is not safe can be ignored, because the + temporary file is created almost straight away. + + + \subsection subsLnxCom Compiling the library and liniking with the application + - First you need to copy the appropriate files (\ref LnxSTL "see above")
+ - If you haven't got the zlib library already installed on your system, you can install + it using \e Makefile in the \e zlib subdirectory (type \e make and then make install ) + - only static version (you can download a full version of the zlib library from the ZipArchive library site). + If you don't want to install the zlib library, you need to include it in the ZipArchive library + ( edit the \e Makefile in the main directory and change comments, so that + OBJSZLIB is not an empty value but points to zlib library object files) + - Compile the library by typing \e make. The resulting file is a static library \e libziparch.a + - You can copy the library and the headers (if you have an appropriate rights) to \e /usr/lib and + \e /usr/include/ziparchive (you can change them in \e Makefile) with the command make install + - Now you can link the library to your application
+ e.g. with the command (if the library is in the same directory)
+ g++ $I. -o app app.cpp -lstdc++ -lz libziparch.a
+ or if you have the library installed in the /usr subdirectories:
+ g++ $I/usr/include/ziparchive -o app app.cpp -lstdc++ -lz -lziparch
+ If you haven't got the zlib library installed, you need to omit the switch \e -lz in the above commands. + \anchor stlLinuxTest + - There is a test application named \e zippie.cpp (in \e stl/zippie which you can compile typing make zippie + (providing that you have installed the ZipArchive library). If you haven't got the zlib library installed, + you need to switch the comments (comment one line and uncomment another) in the \e Makefile in the section \e "zippie:". + - If you wish to uninstall the library type make uninstall + +*/ + + +/** + +\page pageGen General Information + +\par +\ref sectCompress +\par +\ref sectSpan +\par +\ref sectPass +\par +\ref sectSE +\par +\ref sectExc +\par +\ref sectMemory +\par +\ref sectCallb +\par +\ref sectHelp +\par + + + +\section sectCompress Compression and decompression + +There are some functions defined for fast operations on archive: CZipArchive::AddNewFile, + CZipArchive::ExtractFile, CZipArchive::DeleteFile, CZipArchive::TestFile. + You only need to call functions CZipArchive::Open - before and CZipArchive::Close - after using them. Calling CZipArchive::Close function after you've done modifying the archive is necessary +for the archive to be intact. + +\section sectSpan Multi-disk archives + +This library supports two kinds of multi-disk archives: + +- Disk spanning that is performed in the compatible way with all other main zip programs. It means that: + - the archive can only be created on a removable device, + - the size of the volume is auto-detected + - the label is written to the disk + - you need to define a callback functor for changing disks and set it with CZipArchive::SetSpanCallback function. + +- Disk spanning that is performed in the internal mode, called in the sources TDSpan mode and it means that: + - the archive can be created on non-removable device as well + - you need to define the single volume size + - there is no need to set callback functor in this mode. + +\anchor convertZips +These two disk spanning modes create volumes with compatible internal structure. It means that you can easily convert the volumes created in one mode to the other one by renaming the files (in TDSpan mode each volume but last has a number as an extension). To convert the archive from TD to PKZIP compatible archive, copy each file to the removable media, giving them the extension ".zip". You should also label each disk with the appropriate label starting from "pkback# 001" +(note the space between '#' and '0'). + +There is a limited functions set available while working with multi-disk archives. Only adding is allowed when creating the archive and only extracting and testing after opening an existing one. Deleting files from these archives is not allowed at all. + +Class CZipArchive uses write buffer to make write operations as fast as possible. You can change its size with CZipArchive::SetAdvanced function. While creating a multi-disk archive, set the size of the buffer to the maximum size of the volume for the best performance. + +The popular archivers such as PKZIP and WinZip cannot operate on archive in TDSpan mode. You need to convert them to PKZIP span mode (\ref convertZips "have a look above"). Remember about copying the files to the removable media (it does not comply with Winzip, which can extract a multi-disk archive from any media but only from the fixed location on the drive). + +\section sectPass Password encryption and decryption + +This library supports creating and extracting the password protected archives. There are several issues you should be aware of when using this feature. To set the password for the file to be added or extracted call the function CZipArchive::SetPassword with the password as the argument. To clear the password call this function without arguments or with an empty string argument. The function has no effect on a closed archive and on the currently opened file (whether new or existing) inside archive. During opening the archive the password is cleared. You can set different passwords for different files inside the same archive, but remember to set it BEFORE opening the file. You cannot use ASCII characters with codes above 127 in the password, if you do so, the function CZipArchive::SetPassword returns false and the password is cleared. +You can find out what files are password encrypted by calling CZipArchive::GetFileInfo, which fills the structure CZipFileHeader with data, and then call the method ZipFileHeader::IsEncrypted. If it returns true, the file needs a password to extract. +The successful extraction of the encrypted file doesn't always mean that the password is correct. You also need to check the return value of CZipArchive::CloseFile. You could also check the size of the extracted file since it can be smaller than it should be in case of the bad password. + +\section sectSE Self extract support + +The library is capable of extracting and modifying self-extracting archives. You can create your own SFX archive as well. This is the simplest code responsible for the self-extracting: + +\code +//Windows code + +int APIENTRY WinMain(HINSTANCE hInstance, +HINSTANCE hPrevInstance, +LPSTR lpCmdLine, +int nCmdShow) +{ + CZipArchive zip; + + // get the path of the executable + TCHAR szBuff[_MAX_PATH]; + if (!::GetModuleFileName(hInstance, szBuff, _MAX_PATH)) + return -1; + + CZipString szDest; + // ... + // add some code here to get the destination directory from the user + // for example: + // CBrowseForFolder bf; + // bf.strTitle = _T("Select directory to extract files"); + // if (!bf.GetFolder(szDest)) + // return -1; + // + // class CBrowseForFolder is included in the sample application project + // remember about including the header! + zip.Open(szBuff, CZipArchive::openReadOnly); + // openReadOnly mode is necessary for self extract archives + for (WORD i = 0; i < zip.GetCount(); i++) + zip.ExtractFile(i, szDest); + + zip.Close(); + return 0; + // this code will not work for the encrypted archives since it is needed + // to get the password from the user ( a small addition to the + // existing code I suppose ) +} + +\endcode + +After compiling it and appending a zip archive to it (e.g. with the DOS command: copy /b SelfExtract.exe + ZipFile.zip FinalFile.exe ) you have a self extracting archive. + + +\section sectExc Exceptions + +\subsection excmfc MFX version +The library throws the following exceptions inherited from \c CException: \c CMemoryException*, \c CFileExeption* and \c CZipException*. The first two don't need an explanation. The last is thrown when some internal error occurs. Handling them may be done in the following way: + +\code + +try +{ + // ... + // some operations on the ZipArchive library +} +catch (CException* e) +{ + if (e->IsKindOf( RUNTIME_CLASS( CZipException ))) + { + CZipException* p = (CZipException*) e; + //... and so on + } + else if (e->IsKindOf( RUNTIME_CLASS( CFileException ))) + { + CFileException* p = (CFileException*) e; + //... and so on + } + else + { + // the only possibility is a memory exception I suppose + //... and so on + } + e->Delete(); +} + + +\endcode + +\subsection excstl STL version +The library throws exceptions inherited from \c std::exception. In this case you should catch \c std::exception object (not a pointer to it). + +\section sectMemory Creating and extracting archives from/in memory + +With the function CZipArchive::Open(CZipMemFile&, int) you can create the archive in memory and then write to disk, e.g.: + +\code + +CZipArchive zip; +CZipMemFile mf; +// create archive in memory +zip.Open(mf, CZipArchive::zipCreate); +// ... +// add some files to archive here e.g. by calling CZipArchive::AddNewFile +// ... +zip.Close(); +// write the archive to disk +CZipFile f; +if (f.Open("c:\\temp.zip", CZipFile::modeWrite|CZipFile::modeCreate, false) +{ + int iLen = mf.GetLength(); + BYTE* b = mf.Detach(); + f.Write(b, iLen); + f.Close(); + // we must free the detached memory + free(b); +} +\endcode + +You can as well read the archive from disk and then extract files, e.g.: + +\code +CZipFile f; +if (f.Open("c:\\temp.zip", CZipFile::modeRead, false) +{ + int iLen = f.GetLength(); + BYTE* b = (BYTE*)malloc((UINT)iLen); + f.Read(b, iLen); + f.Close(); + CZipMemFile mf; + mf.Attach(b, iLen); + CZipArchive zip; + zip.Open(mf); + // ... + // extract files here from the archive e.g. by calling CZipArchive::ExtractFile + // ... + zip.Close(); +} +\endcode + +With functions CZipArchive::AddNewFile(CZipMemFile&, LPCTSTR, int, int, unsigned long) and +CZipArchive::ExtractFile(WORD, CZipMemFile&, DWORD) you can add files to archive from memory +and extract them to a memory file. Now a bit larger example: + +\code +// create the archive in memory with two files inside +CZipMemFile mf; +CZipArchive zip; +zip.Open(mf, CZipArchive::zipCreate); +zip.AddNewFile("c:\\testfile1.txt"); +zip.AddNewFile("c:\\testfile2.txt"); +zip.Close(); +//create the archive on disk and add a previously zipped file from memory +zip.Open("c:\\test.zip", CZipArchive::zipCreate); +zip.AddNewFile(mf, "File1.zip"); +zip.Close(); +// we have now zip-in-zip file on the disk, +// let's extract the embedded zip file back to memory +zip.Open("c:\\test.zip"); +// reset the contents of the CZipMemFile object +mf.SetLength(0); +zip.ExtractFile(0, mf); +zip.Close(); +// write the file from memory to disk +CZipFile f; +if (f.Open("c:\\File1.zip", CZipFile::modeWrite|CZipFile::modeCreate, false)) +{ + int iLen = mf.GetLength(); + BYTE* b = mf.Detach(); + f.Write(b, iLen); + f.Close(); + // we must free the detached memory + free(b); +} +\endcode + + +One important thing: when you operate on the archive in memory, you must ensure +that CZipMemory object will not be destroyed before calling CZipArchive::Close. +In some cases you'll need to construct the object using the \c new operator, e.g.: +\code +// ... +CZipMemFile* pmf = new CZipMemFile; +zip.Open(*pmf, CZipArchive::zipCreate); +// ... +zip.Close(); +delete pmf; +\endcode + +\section sectCallb Action progress notifications (callbacks) + +The library has the possibility to notify about the progress of the various actions (see CZipArchive::CallbackType). +To use this feature you need to define a new class derived from CZipActionCallback or from CZipSpanCallback and override +CZipCallback::Callback function. Then you need to declare an object of your class and pass its address to +function CZipArchive::SetCallback or CZipArchive::SetSpanCallback. Make sure that the object exists while the library +performs the action the functor was assigned to. +or tell the library not to use the callback (use the same functions). + + +\section sectHelp Integrating with MSDN + +If you wish to integrate the ZipArchive help system with the MSDN library you need to: +- download from +\htmlonly +the Artpol Software site +\endhtmlonly +ZipArchive HTML Help documentation or ZipArchive HTML documentation if you don't have it. +- in the latter case you need to compile the html files to the HTML Help format +with HTML Web Workshop by Microsoft (at the moment of writing available i.a. +\htmlonly +here) +\endhtmlonly +and using provided \e index.hhp file (it is at the same location as ZipArchive html help files) +- now you should have \e index.chm and \e index.chi files, rename them if you want to and put them +to the directory of your choice +- you need to download a free MSDN Integration Utility by Kirk Stowell; you can download it from +\htmlonly +the Code Project site +or from the Artpol Software site +\endhtmlonly +(Download->ZipArchive) +- use the MSDN Integration Utility for the files you have prepared +- now pressing the F1 key on the ZipArchive library method or class in the Visual Studio brings up the MSDN help; +you have also a searchable ZipArchive collection inside MSDN +\note After integrating the ZipArchive help system with the MSDN library, you need +to be patient when you use the Index for the first time, because it'll be rebuilt then which can +be a lengthy process. +*/ + +/** +\page pageSubsc ZipArchive Newsletter + +To be notified about ZipArchive library updates, enter your +e-mail into the input field below and press \e Subscribe! button. + +\htmlonly + +
+ + + + +
+ + +

Privacy Policy of the ZipArchvie library Newsletter List

+
    +
  • The information you provide, will never be made available to any third party company. +
  • Only the Web Master of the Artpol Software site will have an access to the mailing list. +
  • If at anytime you wish to be removed from the mailing list, you can do it by +following the link that you will receive with every newsletter. +
+ +\endhtmlonly + +*/ + diff --git a/stepmania/src/smpackage/ZipArchive/StdAfx.cpp b/stepmania/src/smpackage/ZipArchive/StdAfx.cpp index 35efe037ed..feaf620604 100644 --- a/stepmania/src/smpackage/ZipArchive/StdAfx.cpp +++ b/stepmania/src/smpackage/ZipArchive/StdAfx.cpp @@ -1,6 +1,20 @@ -// stdafx.cpp : source file that includes just the standard includes -// Zip.pch will be the pre-compiled header -// stdafx.obj will contain the pre-compiled type information +/////////////////////////////////////////////////////////////////////////////// +// $Workfile: stdafx.cpp $ +// $Archive: /ZipArchive/stdafx.cpp $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt +//////////////////////////////////////////////////////////////////////////////// + #include "stdafx.h" + diff --git a/stepmania/src/smpackage/ZipArchive/StdAfx.h b/stepmania/src/smpackage/ZipArchive/StdAfx.h index fef7146336..ea94a961f8 100644 --- a/stepmania/src/smpackage/ZipArchive/StdAfx.h +++ b/stepmania/src/smpackage/ZipArchive/StdAfx.h @@ -1,7 +1,19 @@ -// stdafx.h : include file for standard system include files, -// or project specific include files that are used frequently, but -// are changed infrequently -// +/////////////////////////////////////////////////////////////////////////////// +// $Workfile: stdafx.h $ +// $Archive: /ZipArchive/stdafx.h $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt +//////////////////////////////////////////////////////////////////////////////// + #if !defined(AFX_STDAFX_H__926F70F4_1B34_49AA_9532_498E8D2F3495__INCLUDED_) #define AFX_STDAFX_H__926F70F4_1B34_49AA_9532_498E8D2F3495__INCLUDED_ @@ -10,14 +22,20 @@ #pragma once #endif // _MSC_VER > 1000 -#define VC_EXTRALEAN // Exclude rarely-used stuff from Windows headers +#ifdef __BORLANDC__ +#define ZIPINLINE +#else +#define ZIPINLINE inline +#endif +#define ZIP_ARCHIVE_MFC + +#define VC_EXTRALEAN // Exclude rarely-used stuff from Windows headers #include #include -// TODO: reference additional headers your program requires here - //{{AFX_INSERT_LOCATION}} // Microsoft Visual C++ will insert additional declarations immediately before the previous line. #endif // !defined(AFX_STDAFX_H__926F70F4_1B34_49AA_9532_498E8D2F3495__INCLUDED_) + diff --git a/stepmania/src/smpackage/ZipArchive/Windows/ZipFileMapping.h b/stepmania/src/smpackage/ZipArchive/Windows/ZipFileMapping.h new file mode 100644 index 0000000000..6d1dd50e2c --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/Windows/ZipFileMapping.h @@ -0,0 +1,80 @@ +//////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipFileMapping.h $ +// $Archive: /ZipArchive/ZipFileMapping.h $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt +// +// Check the site http://www.artpol-software.com for the updated version of the library. +//////////////////////////////////////////////////////////////////////////////// + + +#if !defined(AFX_AUTOHANDLE_H__D68326EA_D7FA_4792_AB1F_68D09533E399__INCLUDED_) +#define AFX_AUTOHANDLE_H__D68326EA_D7FA_4792_AB1F_68D09533E399__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#include "ZipFile.h" +namespace ziparchv +{ + + + struct CZipFileMapping + { + CZipFileMapping() + { + m_hFileMap = NULL; + m_pFileMap = NULL; + } + bool CreateMapping(CZipFile* pFile) + { + if (!pFile) + return false; + m_hFileMap = CreateFileMapping((HANDLE)pFile->operator HFILE(), NULL, PAGE_READWRITE, + 0, 0, _T("ZipArchive Mapping File")); + if (!m_hFileMap) + return false; + // Get pointer to memory representing file + m_pFileMap = MapViewOfFile(m_hFileMap, FILE_MAP_WRITE, 0, 0, 0); + return (m_pFileMap != NULL); + } + void RemoveMapping() + { + if (m_pFileMap) + { + UnmapViewOfFile(m_pFileMap); + m_pFileMap = NULL; + } + if (m_hFileMap) + { + CloseHandle(m_hFileMap); + m_hFileMap = NULL; + } + + } + ~CZipFileMapping() + { + RemoveMapping(); + } + char* GetMappedMemory() + { + return reinterpret_cast (m_pFileMap); + } + protected: + HANDLE m_hFileMap; + LPVOID m_pFileMap; + + }; +} + +#endif // !defined(AFX_AUTOHANDLE_H__D68326EA_D7FA_4792_AB1F_68D09533E399__INCLUDED_) diff --git a/stepmania/src/smpackage/ZipArchive/Windows/ZipPathComponent.cpp b/stepmania/src/smpackage/ZipArchive/Windows/ZipPathComponent.cpp new file mode 100644 index 0000000000..1976e23d1b --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/Windows/ZipPathComponent.cpp @@ -0,0 +1,76 @@ +//////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipPathComponent.cpp $ +// $Archive: /ZipArchive/ZipPathComponent.cpp $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt +//////////////////////////////////////////////////////////////////////////////// + +#include "stdafx.h" +#include "ZipPathComponent.h" + +////////////////////////////////////////////////////////////////////// +// Construction/Destruction +////////////////////////////////////////////////////////////////////// + + +CZipPathComponent::~CZipPathComponent() +{ + +} + +void CZipPathComponent::SetFullPath(LPCTSTR lpszFullPath) +{ + + TCHAR szDrive[_MAX_DRIVE]; + TCHAR szDir[_MAX_DIR]; + TCHAR szFname[_MAX_FNAME]; + TCHAR szExt[_MAX_EXT]; + + + CZipString szTempPath(lpszFullPath); + const CZipString szPrefix = _T("\\\\?\\unc\\"); + int i = -1, iLen = szPrefix.GetLength(); + if (iLen > szTempPath.GetLength()) + iLen = szTempPath.GetLength(); + CZipString szPossiblePrefix = szTempPath.Left(iLen); + szPossiblePrefix.MakeLower(); // must perform case insensitive comparison + while (++i < iLen && szPossiblePrefix[i] == szPrefix[i]); + if (i == 2 || i == 4 || i == 8) // unc path, unicode path or unc path meeting windows file name conventions + { + m_szPrefix = szTempPath.Left(i); + szTempPath = szTempPath.Mid(i); + } + else + m_szPrefix.Empty(); + + _tsplitpath(szTempPath, szDrive , szDir, szFname, szExt); + m_szDrive = szDrive; + m_szDirectory = szDir; + + m_szDirectory.TrimLeft(m_cSeparator); + m_szDirectory.TrimRight(m_cSeparator); + SetExtension(szExt); + m_szFileTitle = szFname; +} + + +CZipString CZipPathComponent::GetNoDrive() const +{ + CZipString szPath = m_szDirectory; + CZipString szFileName = GetFileName(); + if (!szFileName.IsEmpty() && !szPath.IsEmpty()) + szPath += m_cSeparator; + + szPath += szFileName; + return szPath; +} + diff --git a/stepmania/src/smpackage/ZipArchive/Windows/ZipPlatform.cpp b/stepmania/src/smpackage/ZipArchive/Windows/ZipPlatform.cpp new file mode 100644 index 0000000000..0affb9e3a1 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/Windows/ZipPlatform.cpp @@ -0,0 +1,351 @@ +//////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipPlatform.cpp $ +// $Archive: /ZipArchive/ZipPlatform.cpp $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt +//////////////////////////////////////////////////////////////////////////////// + + +#include "stdafx.h" +#include "ZipPlatform.h" +#include "ZipFileHeader.h" +#include "ZipException.h" +#include "ZipAutoBuffer.h" +#include + +#if defined _MSC_VER && !defined __BORLANDC__ /*_MSC_VER may be defined in Borland after converting the VC project */ + #include +#else + #include +#endif + +#include +#include +#include +#include "ZipPathComponent.h" +#include "ZipCompatibility.h" + +const TCHAR CZipPathComponent::m_cSeparator = _T('\\'); + + +#ifndef _UTIMBUF_DEFINED +#define _utimbuf utimbuf +#endif + +DWORD ZipPlatform::GetDeviceFreeSpace(LPCTSTR lpszPath) +{ + DWORD SectorsPerCluster, BytesPerSector, NumberOfFreeClusters, TotalNumberOfClusters; + CZipPathComponent zpc (lpszPath); + CZipString szDrive = zpc.GetFileDrive(); + if (!GetDiskFreeSpace( + szDrive, + &SectorsPerCluster, + &BytesPerSector, + &NumberOfFreeClusters, + &TotalNumberOfClusters)) + { + CZipPathComponent::AppendSeparator(szDrive); // in spite of what is written in MSDN it is sometimes needed (on fixed disks) + if (!GetDiskFreeSpace( + szDrive, + &SectorsPerCluster, + &BytesPerSector, + &NumberOfFreeClusters, + &TotalNumberOfClusters)) + + return 0; + } + __int64 total = SectorsPerCluster * BytesPerSector * NumberOfFreeClusters; + return (DWORD)total; +} + +bool ZipPlatform::GetFileSize(LPCTSTR lpszFileName, DWORD& dSize) +{ + HANDLE f = CreateFile(lpszFileName, GENERIC_READ, FILE_SHARE_READ, + NULL, OPEN_EXISTING, 0, NULL); + if (!f) + return false; + DWORD dwSize; + dwSize = ::GetFileSize(f, NULL); + CloseHandle(f); + if (dwSize == 0xFFFFFFFF) + return false; + dSize = dwSize; + return true; +} + +CZipString ZipPlatform::GetTmpFileName(LPCTSTR lpszPath, DWORD iSizeNeeded) +{ + TCHAR empty[] = _T(""); + CZipString tempPath; + bool bCheckTemp = true; + if (lpszPath) + { + tempPath = lpszPath; + bCheckTemp = GetDeviceFreeSpace(tempPath) < iSizeNeeded; + + } + if (bCheckTemp) + { + DWORD size = GetTempPath(0, NULL); + if (size == 0) + return empty; + + GetTempPath(size, tempPath.GetBuffer(size)); + tempPath.ReleaseBuffer(); + if (GetDeviceFreeSpace(tempPath) < iSizeNeeded) + { + if (!GetCurrentDirectory(tempPath) || GetDeviceFreeSpace(tempPath) < iSizeNeeded) + return empty; + } + } + CZipString tempName; + if (!GetTempFileName(tempPath, _T("ZAR"), 0, tempName.GetBuffer(_MAX_PATH))) + return empty; + tempName.ReleaseBuffer(); + return tempName; +} + + +bool ZipPlatform::GetCurrentDirectory(CZipString& sz) +{ + DWORD i = ::GetCurrentDirectory(0, NULL); + if (!i) + return false; + TCHAR* pBuf = new TCHAR[i]; + bool b = true; + if (!::GetCurrentDirectory(i, pBuf)) + b = false; + else + sz = pBuf; + delete[] pBuf; + return b; +} + +bool ZipPlatform::SetFileAttr(LPCTSTR lpFileName, DWORD uAttr) +{ + return ::SetFileAttributes(lpFileName, uAttr) != 0; +} + +bool ZipPlatform::GetFileAttr(LPCTSTR lpFileName, DWORD& uAttr) +{ + // not using MFC due to MFC bug (attr is one byte there) + DWORD temp = ::GetFileAttributes(lpFileName); + if (temp == -1) + return false; + uAttr = temp; + return true; + +} + +bool ZipPlatform::GetFileModTime(LPCTSTR lpFileName, time_t & ttime) +{ +#if defined _MSC_VER && !defined __BORLANDC__ /*_MSC_VER may be defined in Borland after converting the VC project */ + struct _stat st; + if (_tstat(lpFileName, &st) != 0) +#else + struct stat st; + if (stat(lpFileName, &st) != 0) +#endif + return false; + + ttime = st.st_mtime; + return ttime != -1; +} + +bool ZipPlatform::SetFileModTime(LPCTSTR lpFileName, time_t ttime) +{ + struct _utimbuf ub; + ub.actime = time(NULL); + ub.modtime = ttime; + return _tutime(lpFileName, &ub) == 0; +} + + +bool ZipPlatform::ChangeDirectory(LPCTSTR lpDirectory) +{ + return _tchdir(lpDirectory) == 0; // returns 0 if ok +} +int ZipPlatform::FileExists(LPCTSTR lpszName) +{ + if (_taccess(lpszName, 0) == 0) + { + if (DirectoryExists(lpszName)) + return -1; + return 1; + } + else + return 0; + +} + +ZIPINLINE bool ZipPlatform::IsDriveRemovable(LPCTSTR lpszFilePath) +{ + CZipPathComponent zpc(lpszFilePath); + return ::GetDriveType(zpc.GetFileDrive()) == DRIVE_REMOVABLE; +} + +ZIPINLINE bool ZipPlatform::SetVolLabel(LPCTSTR lpszPath, LPCTSTR lpszLabel) +{ + CZipPathComponent zpc(lpszPath); + CZipString szDrive = zpc.GetFileDrive(); + CZipPathComponent::AppendSeparator(szDrive); + return ::SetVolumeLabel(szDrive, lpszLabel) != 0; +} + +ZIPINLINE void ZipPlatform::AnsiOem(CZipAutoBuffer& buffer, bool bAnsiToOem) +{ + if (bAnsiToOem) + CharToOemBuffA(buffer, buffer, buffer.GetSize()); + else + OemToCharBuffA(buffer, buffer, buffer.GetSize()); +} + +ZIPINLINE bool ZipPlatform::RemoveFile(LPCTSTR lpszFileName, bool bThrow) +{ + if (!::DeleteFile((LPTSTR)lpszFileName)) + if (bThrow) + CZipException::Throw(CZipException::notRemoved, lpszFileName); + else + return false; + return true; + +} +ZIPINLINE bool ZipPlatform::RenameFile( LPCTSTR lpszOldName, LPCTSTR lpszNewName, bool bThrow) +{ + if (!::MoveFile((LPTSTR)lpszOldName, (LPTSTR)lpszNewName)) + if (bThrow) + CZipException::Throw(CZipException::notRenamed, lpszOldName); + else + return false; + return true; + +} +ZIPINLINE bool ZipPlatform::IsDirectory(DWORD uAttr) +{ + return (uAttr & FILE_ATTRIBUTE_DIRECTORY) != 0; +} +ZIPINLINE bool ZipPlatform::CreateDirectory(LPCTSTR lpDirectory) +{ + return ::CreateDirectory(lpDirectory, NULL) != 0; +} + +ZIPINLINE DWORD ZipPlatform::GetDefaultAttributes() +{ + return 0x81a40020; // make it readable under Unix +} + +ZIPINLINE DWORD ZipPlatform::GetDefaultDirAttributes() +{ + return 0x41ff0010; // make it readable under Unix +} + +ZIPINLINE int ZipPlatform::GetSystemID() +{ + return ZipCompatibility::zcDosFat; +} + +ZIPINLINE bool ZipPlatform::GetSystemCaseSensitivity() +{ + return false; +} + +#ifdef _UNICODE +int ZipPlatform::WideToSingle(LPCTSTR lpWide, CZipAutoBuffer &szSingle) +{ + size_t wideLen = wcslen(lpWide); + if (wideLen == 0) + { + szSingle.Release(); + return 0; + } + + // iLen does not include terminating character + int iLen = WideCharToMultiByte(CP_ACP,0, lpWide, wideLen, szSingle, + 0, NULL, NULL); + if (iLen > 0) + { + szSingle.Allocate(iLen, true); + iLen = WideCharToMultiByte(CP_ACP,0, lpWide , wideLen, szSingle, + iLen, NULL, NULL); + ASSERT(iLen != 0); + } + else // here it means error + { + szSingle.Release(); + iLen --; + } + return iLen; + +} +int ZipPlatform::SingleToWide(const CZipAutoBuffer &szSingle, CZipString& szWide) +{ + int singleLen = szSingle.GetSize(); + // iLen doesn't include terminating character + int iLen = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, szSingle.GetBuffer(), singleLen, NULL, 0); + if (iLen > 0) + { + iLen = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, szSingle.GetBuffer(), singleLen, + szWide.GetBuffer(iLen) , iLen); + szWide.ReleaseBuffer(iLen); + ASSERT(iLen != 0); + } + else + { + szWide.Empty(); + iLen --; // return -1 + } + return iLen; + +} +#endif + +#ifndef _MFC_VER +#include +#include +bool ZipPlatform::TruncateFile(int iDes, DWORD iSize) +{ + int ret = chsize(iDes, iSize); + return ret != -1; + +} + +int ZipPlatform::OpenFile(LPCTSTR lpszFileName, UINT iMode, int iShareMode) +{ + switch (iShareMode) + { + case (CZipFile::shareDenyWrite & CZipFile::shareDenyRead): + iShareMode = SH_DENYRW; + break; + case (CZipFile::shareDenyRead): + iShareMode = SH_DENYRD; + break; + case (CZipFile::shareDenyWrite): + iShareMode = SH_DENYWR; + break; + default: + iShareMode = SH_DENYNO; + } + return _tsopen(lpszFileName, iMode, iShareMode, S_IREAD | S_IWRITE /*required only when O_CREAT mode*/); +} + +bool ZipPlatform::FlushFile(int iDes) +{ + return _commit(iDes) == 0; +} + +int ZipPlatform::GetFileSystemHandle(int iDes) +{ + return _get_osfhandle(iDes); +} + + +#endif //_MFC_VER diff --git a/stepmania/src/smpackage/ZipArchive/ZipAbstractFile.h b/stepmania/src/smpackage/ZipArchive/ZipAbstractFile.h new file mode 100644 index 0000000000..3c1c83c2a5 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/ZipAbstractFile.h @@ -0,0 +1,52 @@ +/////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipAbstractFile.h $ +// $Archive: /ZipArchive/ZipAbstractFile.h $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt +//////////////////////////////////////////////////////////////////////////////// + +#if !defined(AFX_ZIPABSTRACTFILE_H__46F247DE_21A6_4D12_AF64_B5A6B3CF4D57__INCLUDED_) +#define AFX_ZIPABSTRACTFILE_H__46F247DE_21A6_4D12_AF64_B5A6B3CF4D57__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 +#include "ZipString.h" +class CZipAbstractFile +{ +public: + + enum { begin = SEEK_SET, // 0 + current = SEEK_CUR, // 1 + end = SEEK_END // 2 + }; + CZipAbstractFile(){} + virtual bool Open(LPCTSTR , UINT , bool ){return true;} + virtual void Close() = 0; + virtual void Flush() = 0; + virtual DWORD GetPosition() const = 0; + virtual void SeekToBegin(){Seek(0, begin);} + virtual void SeekToEnd(){Seek(0, end);} + virtual CZipString GetFilePath() const = 0; + virtual void SetLength(long nNewLen) = 0; + virtual UINT Read(void *lpBuf, UINT nCount) = 0; + virtual void Write(const void* lpBuf, UINT nCount) = 0; + virtual long Seek(long lOff, int nFrom) = 0; + virtual bool IsClosed() const = 0; + virtual DWORD GetLength() const = 0; + virtual ~CZipAbstractFile(){}; + +}; + + + +#endif // !defined(AFX_ZIPABSTRACTFILE_H__46F247DE_21A6_4D12_AF64_B5A6B3CF4D57__INCLUDED_) diff --git a/stepmania/src/smpackage/ZipArchive/ZipArchive.cpp b/stepmania/src/smpackage/ZipArchive/ZipArchive.cpp index ccff2a4545..49a03866fa 100644 --- a/stepmania/src/smpackage/ZipArchive/ZipArchive.cpp +++ b/stepmania/src/smpackage/ZipArchive/ZipArchive.cpp @@ -1,15 +1,27 @@ -// ZipArchive.cpp: implementation of the CZipArchive class. -// +/////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipArchive.cpp $ +// $Archive: /ZipArchive/ZipArchive.cpp $ +// $Date$ $Author$ //////////////////////////////////////////////////////////////////////////////// -// Copyright (C) 2000 Tadeusz Dracz. -// For conditions of distribution and use, see copyright notice in ZipArchive.h +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt //////////////////////////////////////////////////////////////////////////////// + #include "stdafx.h" #include "ZipArchive.h" -#include -#include // for qsort +// #include "ZipPathComponent.h" +#include "ZipPlatform.h" +#include "ZipCompatibility.h" +#include #ifndef DEF_MEM_LEVEL #if MAX_MEM_LEVEL >= 8 @@ -18,18 +30,24 @@ # define DEF_MEM_LEVEL MAX_MEM_LEVEL #endif #endif -#define ENCR_HEADER_LEN 12 + ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// -TCHAR CZipArchive::m_gszCopyright[] = {_T("Zip archive creation and modification Copyright 2000 Tadeusz Dracz")}; + + + +const TCHAR CZipArchive::m_gszCopyright[] = {_T("ZipArchive library Copyright 2000 - 2002 Tadeusz Dracz")}; CZipArchive::CZipArchive() { + m_bDetectZlibMemoryLeaks = true; + m_bIgnoreCRC = m_bAutoFlush = false; m_centralDir.m_pStorage= &m_storage; - m_info.m_stream.zalloc = (alloc_func)myalloc; - m_info.m_stream.zfree = (free_func)myfree; + m_info.m_stream.zalloc = (alloc_func)_zliballoc; + m_info.m_stream.zfree = (free_func)_zlibfree; m_iFileOpened = nothing; + SetCaseSensitivity(ZipPlatform::GetSystemCaseSensitivity()); } @@ -37,135 +55,135 @@ CZipArchive::~CZipArchive() { // Close(); // cannot be here: if an exception is thrown strange things can happen EmptyPtrList(); + } + + void CZipArchive::Open(LPCTSTR szPathName, int iMode, int iVolumeSize) { if (!IsClosed()) { - TRACE(_T("ZipArchive already opened.\n")); + TRACE(_T("%s(%i) : ZipArchive already opened.\n"),__FILE__,__LINE__); return; } - m_pszPassword.Release(); - m_iFileOpened = nothing; m_storage.Open(szPathName, iMode, iVolumeSize); - m_centralDir.Init(); - if ((iMode == open) ||(iMode == openReadOnly)) - m_centralDir.Read(); + OpenInternal(iMode); } -void CZipArchive::Open(CMemFile& mf, int iMode) +void CZipArchive::Open(CZipMemFile& mf,int iMode) { if (!IsClosed()) { - TRACE(_T("ZipArchive already opened.\n")); + TRACE(_T("%s(%i) : ZipArchive already opened.\n"),__FILE__,__LINE__); return; } - if (iMode != open && iMode != openReadOnly && iMode != create) + if (iMode != zipOpen && iMode != zipOpenReadOnly && iMode != zipCreate) { - TRACE(_T("Mode not supported.\n")); + TRACE(_T("%s(%i) : Mode not supported.\n"),__FILE__,__LINE__); return; } + m_storage.Open(mf, iMode); + OpenInternal(iMode); +} + + +void CZipArchive::OpenInternal(int iMode) +{ m_pszPassword.Release(); m_iFileOpened = nothing; - m_storage.Open(mf, iMode); m_centralDir.Init(); - if ((iMode == open) ||(iMode == openReadOnly)) + m_iArchiveSystCompatib = ZipPlatform::GetSystemID(); + m_szRootPath.Empty(); + if ((iMode == zipOpen) ||(iMode == zipOpenReadOnly)) + { m_centralDir.Read(); -} - - -bool CZipArchive::IsClosed(bool bArchive) -{ - return bArchive ?(m_storage.GetCurrentDisk() == -1):(!m_storage.m_pFile || m_storage.m_pFile->m_hFile == CFile::hFileNull); -} - - -void CZipArchive::ThrowError(int err) -{ - AfxThrowZipException(err, IsClosed() ? _T("") : m_storage.m_pFile->GetFilePath()); -} - -bool CZipArchive::DeleteFile(WORD uIndex) -{ - if (m_storage.IsSpanMode()) - { - TRACE(_T("You cannot delete files from the disk spannig archive.\n")); - return false; + // if there is at least one file, get system comp. from the first one + if (m_centralDir.IsValidIndex(0)) + { + int iSystemComp = m_centralDir[0]->GetSystemCompatibility(); + if (ZipCompatibility::IsPlatformSupported(iSystemComp)) + m_iArchiveSystCompatib = iSystemComp; + } } - - if (m_iFileOpened) - { - TRACE(_T("You cannot delete files if there is a file opened.\n")); - return false; - } - - if (!m_centralDir.IsValidIndex(uIndex)) - return false; - - m_info.Init(); - m_centralDir.RemoveFromDisk(); - DeleteInternal(uIndex); - m_info.m_pBuffer.Release(); - return true; + } -int CZipArchive::GetNoEntries() + +bool CZipArchive::IsClosed(bool bArchive) const { - return m_centralDir.m_headers.GetSize(); + return bArchive ?(m_storage.GetCurrentDisk() == -1):(!m_storage.m_pFile || m_storage.m_pFile->IsClosed()); } -bool CZipArchive::GetFileInfo(CZipFileHeader & fhInfo, WORD uIndex) +void CZipArchive::ThrowError(int err, bool bZlib) +{ + if (bZlib) + err = CZipException::ZlibErrToZip(err); + CZipException::Throw(err, IsClosed() ? _T("") : (LPCTSTR)m_storage.m_pFile->GetFilePath()); +} + + + +bool CZipArchive::GetFileInfo(CZipFileHeader & fhInfo, WORD uIndex) const { if (IsClosed()) { - TRACE(_T("ZipArchive is closed.\n")); + TRACE(_T("%s(%i) : ZipArchive is closed.\n"),__FILE__,__LINE__); return false; } if (!m_centralDir.IsValidIndex(uIndex)) return false; - fhInfo = *(m_centralDir.m_headers[uIndex]); + fhInfo = *(m_centralDir[uIndex]); m_centralDir.ConvertFileName(true, false, &fhInfo); return true; } -int CZipArchive::FindFile(CString szFileName, bool bCaseSensitive) +int CZipArchive::FindFile(LPCTSTR lpszFileName, int iCaseSensitive, bool bFileNameOnly) { if (IsClosed()) { - TRACE(_T("ZipArchive is closed.\n")); + TRACE(_T("%s(%i) : ZipArchive is closed.\n"),__FILE__,__LINE__); return (int)-1; } - // this is required for fast finding and is done only once - if (!m_centralDir.m_bConvertAfterOpen) + bool bCS; + bool bSporadically; + switch (iCaseSensitive) { - TRACE(_T("Converting all filenames.")); - m_centralDir.ConvertAll(); + case ffCaseSens: + bCS = true; + bSporadically = true; + break; + case ffNoCaseSens: + bCS = false; + bSporadically = true; + break; + default: + bCS = m_bCaseSensitive; + bSporadically = false; } - if (!m_centralDir.m_bFindFastEnabled) - EnableFindFast(); - int iResult = m_centralDir.FindFileNameIndex(szFileName, bCaseSensitive); - return iResult == -1 ? -1 : m_centralDir.m_findarray[iResult].m_uIndex; + return m_centralDir.FindFile(lpszFileName, bCS, bSporadically, bFileNameOnly); } bool CZipArchive::OpenFile(WORD uIndex) -{ +{ if (!m_centralDir.IsValidIndex(uIndex)) + { + ASSERT(FALSE); return false; - + } if (m_storage.IsSpanMode() == 1) { - TRACE(_T("You cannot extract from the span in creation.\n")); + TRACE(_T("%s(%i) : You cannot extract from the span in creation.\n"),__FILE__,__LINE__); return false; } if (m_iFileOpened) { - TRACE(_T("A file already opened.\n")); + TRACE(_T("%s(%i) : A file already opened.\n"),__FILE__,__LINE__); return false; } @@ -176,22 +194,23 @@ bool CZipArchive::OpenFile(WORD uIndex) if (m_pszPassword.GetSize() == 0) { - TRACE(_T("Password not set for the encrypted file.\n")); - return false; + TRACE(_T("%s(%i) : Password not set for the encrypted file.\n"),__FILE__,__LINE__); + ThrowError(CZipException::badPassword); } CryptInitKeys(); if (!CryptCheck()) - ThrowError(ZIP_BADPASSWORD); // invalid password + ThrowError(CZipException::badPassword); } else if (m_pszPassword.GetSize() != 0) { - TRACE(_T("Password set for a not encrypted file. Ignoring password.\n")); + TRACE(_T("%s(%i) : Password set for a not encrypted file. Ignoring password.\n"),__FILE__,__LINE__); } WORD uMethod = CurrentFile()->m_uMethod; + if ((uMethod != 0) &&(uMethod != Z_DEFLATED)) - ThrowError(ZIP_BADZIPFILE); + ThrowError(CZipException::badZipFile); if (uMethod == Z_DEFLATED) { @@ -205,7 +224,7 @@ bool CZipArchive::OpenFile(WORD uIndex) } m_info.m_uComprLeft = CurrentFile()->m_uComprSize; if (CurrentFile()->IsEncrypted()) - m_info.m_uComprLeft -= ENCR_HEADER_LEN; + m_info.m_uComprLeft -= ZIPARCHIVE_ENCR_HEADER_LEN; m_info.m_uUncomprLeft = CurrentFile()->m_uUncomprSize; m_info.m_uCrc32 = 0; m_info.m_stream.total_out = 0; @@ -216,17 +235,17 @@ bool CZipArchive::OpenFile(WORD uIndex) } -int CZipArchive::GetLocalExtraField(char *pBuf, int iSize) +int CZipArchive::GetLocalExtraField(char *pBuf, int iSize)const { if (IsClosed()) { - TRACE(_T("ZipArchive is closed.\n")); + TRACE(_T("%s(%i) : ZipArchive is closed.\n"),__FILE__,__LINE__); return -1; } if (m_iFileOpened != extract) { - TRACE(_T("A file must be opened to get the local extra field.\n")); + TRACE(_T("%s(%i) : A file must be opened to get the local extra field.\n"),__FILE__,__LINE__); return -1; } @@ -241,27 +260,27 @@ int CZipArchive::GetLocalExtraField(char *pBuf, int iSize) return size; } -void* CZipArchive::myalloc(void* opaque, UINT items, UINT size) +void* CZipArchive::_zliballoc(void* opaque, UINT items, UINT size) { void* p = new char[size * items]; if (opaque) { - CPtrList* list = (CPtrList*) opaque; + CZipPtrList* list = (CZipPtrList*) opaque; list->AddTail(p); } return p; } -void CZipArchive::myfree(void* opaque, void* address) +void CZipArchive::_zlibfree(void* opaque, void* address) { if (opaque) { - CPtrList* list = (CPtrList*) opaque; - POSITION pos = list->Find(address); - if (pos) - list->RemoveAt(pos); + CZipPtrList* list = (CZipPtrList*) opaque; + CZipPtrListIter iter = list->Find(address); + if (list->IteratorValid(iter)) + list->RemoveAt(iter); } - delete[] address; + delete[] (char*) address; } void CZipArchive::CheckForError(int iErr) @@ -269,7 +288,7 @@ void CZipArchive::CheckForError(int iErr) if ((iErr == Z_OK) ||(iErr == Z_NEED_DICT)) return; - ThrowError(iErr); + ThrowError(iErr, true); } CZipFileHeader* CZipArchive::CurrentFile() @@ -278,11 +297,12 @@ CZipFileHeader* CZipArchive::CurrentFile() return m_centralDir.m_pOpenedFile; } -DWORD CZipArchive::ReadFile(void *pBuf, DWORD iSize) +DWORD CZipArchive::ReadFile(void *pBuf, + DWORD iSize) { if (m_iFileOpened != extract) { - TRACE(_T("Current file must be opened.\n")); + TRACE(_T("%s(%i) : Current file must be opened.\n"),__FILE__,__LINE__); return 0; } @@ -295,7 +315,7 @@ DWORD CZipArchive::ReadFile(void *pBuf, DWORD iSize) DWORD iRead = 0; - + // may happen when the file is 0 sized bool bForce = m_info.m_stream.avail_out == 0 && m_info.m_uComprLeft > 0; while (m_info.m_stream.avail_out > 0 || (bForce && m_info.m_uComprLeft > 0)) @@ -314,7 +334,7 @@ DWORD CZipArchive::ReadFile(void *pBuf, DWORD iSize) CryptDecodeBuffer(uToRead); m_info.m_uComprLeft -= uToRead; - m_info.m_stream.next_in = (unsigned char*)(char*)m_info.m_pBuffer; + m_info.m_stream.next_in = (Bytef*)(char*)m_info.m_pBuffer; m_info.m_stream.avail_in = uToRead; } @@ -357,59 +377,64 @@ DWORD CZipArchive::ReadFile(void *pBuf, DWORD iSize) return iRead; } -void CZipArchive::Close(bool bAfterException) +void CZipArchive::Close(int iAfterException) { - // if after an exception - the archive may be closed, but the file may be opened - if (IsClosed() && (!bAfterException || IsClosed(false))) + // if after an exception - the archive may be closed, but the file may be opened + if (IsClosed() && (!iAfterException || IsClosed(false))) { - TRACE(_T("ZipArchive is already closed.\n")); + TRACE(_T("%s(%i) : ZipArchive is already closed.\n"),__FILE__,__LINE__); return; } - - if (!bAfterException) - { - if (m_iFileOpened == extract) - CloseFile(NULL); - - if (m_iFileOpened == compress) - CloseNewFile(); - // write central directory - m_centralDir.Write(); - } - else - { - m_info.m_pBuffer.Release(); - m_iFileOpened = nothing; - EmptyPtrList(); - } + if (m_iFileOpened == extract) + CloseFile(NULL, iAfterException != afNoException); + + if (m_iFileOpened == compress) + CloseNewFile(iAfterException != afNoException); + + if (iAfterException != afAfterException && !IsClosed(false)) // in disk spanning when user aborts + WriteCentralDirectory(false); // we will flush in CZipStorage::Close m_centralDir.Clear(); - m_storage.Close(bAfterException); + m_storage.Close(iAfterException == afAfterException); + } -void CZipArchive::SetSpanCallback(ZIPCALLBACKFUN pFunc, void* pData) +void CZipArchive::WriteCentralDirectory(bool bFlush) { - m_storage.m_pZIPCALLBACKFUN = pFunc; - m_storage.m_pCallbackData = pData; + m_centralDir.Write(m_callbacks.Get(cbSave)); + if (bFlush) + m_storage.Flush(); +} + +void CZipArchive::SetCallback(CZipActionCallback* pCallback, int iWhich) +{ + CallbackType cbs[] = {cbAdd, cbAddTmp, cbAddStore,cbExtract,cbDeleteCnt,cbDelete,cbTest,cbSave}; + int iCount = sizeof(cbs)/sizeof(CallbackType); + for (int i = 0; i < iCount; i++) + { + CallbackType iCallback = cbs[i]; + if (iWhich & iCallback) + m_callbacks.Set(pCallback, iCallback); + } } void CZipArchive::SetAdvanced(int iWriteBuffer, int iExtractBuffer, int iSearchBuffer) { if (!IsClosed()) { - TRACE(_T("Set this options before opening the archive.\n")); + TRACE(_T("%s(%i) : Set this options before opening the archive.\n"),__FILE__,__LINE__); return; } m_storage.m_iWriteBufferSize = iWriteBuffer < 1024 ? 1024 : iWriteBuffer; - m_centralDir.m_iBufferSize = iSearchBuffer < 1024 ? 1024 : iSearchBuffer; m_info.m_iBufferSize = iExtractBuffer < 1024 ? 1024 : iExtractBuffer; + m_centralDir.m_iBufferSize = iSearchBuffer < 1024 ? 1024 : iSearchBuffer; } -int CZipArchive::CloseFile(CFile &file) +int CZipArchive::CloseFile(CZipFile &file) { - CString temp = file.GetFilePath(); + CZipString temp = file.GetFilePath(); file.Close(); return CloseFile(temp); } @@ -418,7 +443,7 @@ int CZipArchive::CloseFile(LPCTSTR lpszFilePath, bool bAfterException) { if (m_iFileOpened != extract) { - TRACE(_T("No opened file.\n")); + TRACE(_T("%s(%i) : No opened file.\n"),__FILE__,__LINE__); return false; } @@ -427,8 +452,8 @@ int CZipArchive::CloseFile(LPCTSTR lpszFilePath, bool bAfterException) { if (m_info.m_uUncomprLeft == 0) { - if (m_info.m_uCrc32 != CurrentFile()->m_uCrc32) - ThrowError(ZIP_BADCRC); + if (!m_bIgnoreCRC && m_info.m_uCrc32 != CurrentFile()->m_uCrc32) + ThrowError(CZipException::badCrc); } else iRet = -1; @@ -440,122 +465,141 @@ int CZipArchive::CloseFile(LPCTSTR lpszFilePath, bool bAfterException) if (lpszFilePath) { - try - { - CFileStatus fs; - fs.m_ctime = fs.m_atime = CTime::GetCurrentTime(); - fs.m_attribute = 0; - fs.m_mtime = CurrentFile()->GetTime(); - CFile::SetStatus(lpszFilePath, fs); - if (SetFileAttributes(lpszFilePath, CurrentFile()->m_uExternalAttr) == 0) + + if (!ZipPlatform::SetFileModTime(lpszFilePath, CurrentFile()->GetTime()) + ||!ZipPlatform::SetFileAttr(lpszFilePath, CurrentFile()->GetSystemAttr())) iRet = -2; - } - catch (CException* e) - { - e->Delete(); - return false; - } } + } - m_centralDir.CloseFile(); + + m_centralDir.CloseFile(bAfterException); + m_iFileOpened = nothing; m_info.m_pBuffer.Release(); EmptyPtrList(); return iRet; } -bool CZipArchive::OpenNewFile(CZipFileHeader & header, int iLevel, LPCTSTR lpszFilePath) +bool CZipArchive::OpenNewFile(CZipFileHeader & header, + int iLevel, + LPCTSTR lpszFilePath) { if (IsClosed()) { - TRACE(_T("ZipArchive is closed.\n")); + TRACE(_T("%s(%i) : ZipArchive is closed.\n"),__FILE__,__LINE__); return false; } if (m_iFileOpened) { - TRACE(_T("A file already opened.\n")); + TRACE(_T("%s(%i) : A file already opened.\n"),__FILE__,__LINE__); return false; } if (m_storage.IsSpanMode() == -1) { - TRACE(_T("You cannot add the files to the existing disk spannig archive.\n")); + TRACE(_T("%s(%i) : You cannot add the files to the existing disk spannig archive.\n"),__FILE__,__LINE__); return false; } - if (GetNoEntries() ==(WORD)USHRT_MAX) + if (GetCount() ==(WORD)USHRT_MAX) { - TRACE(_T("Maximum file count inside archive reached.\n")); + TRACE(_T("%s(%i) : Maximum file count inside archive reached.\n"),__FILE__,__LINE__); return false; } + DWORD uAttr = 0; // ..compiler + time_t ttime; + if (lpszFilePath) + { + + if (!ZipPlatform::GetFileAttr(lpszFilePath, uAttr)) + // do not continue - if the file was a directory then not recognizing it will cause + // serious errors (need uAttr to recognize it) + return false; + if (!ZipPlatform::GetFileModTime(lpszFilePath, ttime)) + ttime = time(NULL); + } + + m_info.Init(); + if (lpszFilePath) { - bool bRet = true; - CFileStatus fs; - if (!CFile::GetStatus(lpszFilePath, fs)) - bRet = false; - else - { - header.SetTime(fs.m_mtime); - header.m_uExternalAttr = ::GetFileAttributes(lpszFilePath); // mfc bug: m_attribute is 1-byte - if (header.m_uExternalAttr == -1) - bRet = false; - } - - if (!bRet) - // do not continue - if the file was a directory then not recognizing it will cause - // serious errors - return false; + header.SetTime(ttime); + SetFileHeaderAttr(header, uAttr); // set system compatibility as well } + else + header.SetSystemCompatibility(m_iArchiveSystCompatib); - m_info.Init(); - m_centralDir.AddNewFile(header); - - CString szFileName = CurrentFile()->GetFileName(); - + CZipString szFileName = header.GetFileName(); if (szFileName.IsEmpty()) { - szFileName.Format(_T("file%i"), GetNoEntries());; - CurrentFile()->SetFileName(szFileName); + szFileName.Format(_T("file%i"), GetCount()); + header.SetFileName(szFileName); } + + bool bIsDirectory = header.IsDirectory(); + if (bIsDirectory) + { + CZipString szEnding = szFileName.Right(1); + if (szEnding != _T("/") && szEnding != _T("\\")) + { + szFileName += CZipPathComponent::m_cSeparator; + header.SetFileName(szFileName); + } + } + + + // make sure that all slashes are correct (as the current system default) + // because AddNewFile calls InsertFindFastElement if necessary and + // the find array keeps all the files already converted to the current system standards + // we do not perform Oem->Ansi here, because who would pass oem values here? + // + ZipCompatibility::SlashBackslashChg(header.m_pszFileName, true); + m_centralDir.AddNewFile(header); + // this ensures the conversion will take place anyway (must take because we are going // to write the local header in a moment m_centralDir.ConvertFileName(false, m_centralDir.m_bConvertAfterOpen); - bool bIsDirectory = IsDirectory(CurrentFile()->m_uExternalAttr); + bool bEncrypted = m_pszPassword.GetSize() != 0; + #ifdef _DEBUG if (bIsDirectory && bEncrypted) - TRACE(_T("Warning! Encrypting a directory. Possible but pointless.\n\ - Clear the password before adding a directory.\n")); + TRACE(_T("%s(%i) : Warning! Encrypting a directory. It's pointless.\n\ + Clear the password before adding a directory.\n"),__FILE__,__LINE__); #endif - + if (iLevel < -1 || iLevel > 9) + iLevel = -1; + if (!CurrentFile()->PrepareData(iLevel, m_storage.IsSpanMode() == 1, bEncrypted)) - ThrowError(ZIP_TOOLONGFILENAME); + ThrowError(CZipException::tooLongFileName); CurrentFile()->WriteLocal(m_storage); + // we have written the local header, but if we keep filenames not converted // in memory , we have to restore the non-converted value if (m_centralDir.m_bConvertAfterOpen) CurrentFile()->SetFileName(szFileName); + if (bEncrypted) { - CZipAutoBuffer buf(ENCR_HEADER_LEN); + CZipAutoBuffer buf(ZIPARCHIVE_ENCR_HEADER_LEN); // use pseudo-crc since we don't know it yet CryptCryptHeader((long)header.m_uModTime << 16, buf); - m_storage.Write(buf, ENCR_HEADER_LEN, false); + m_storage.Write(buf, ZIPARCHIVE_ENCR_HEADER_LEN, false); } m_info.m_uComprLeft = 0; m_info.m_stream.avail_in = (uInt)0; m_info.m_stream.avail_out = (uInt)m_info.m_pBuffer.GetSize(); - m_info.m_stream.next_out = (unsigned char*)(char*)m_info.m_pBuffer; + m_info.m_stream.next_out = (Bytef*)(char*)m_info.m_pBuffer; m_info.m_stream.total_in = 0; m_info.m_stream.total_out = 0; @@ -575,155 +619,148 @@ bool CZipArchive::OpenNewFile(CZipFileHeader & header, int iLevel, LPCTSTR lpszF return true; } -CString CZipArchive::GetFilePath(LPCTSTR lpszFilePath) -{ - TCHAR szDir[_MAX_DIR]; - TCHAR szDrive[_MAX_DRIVE]; - _tsplitpath(lpszFilePath, szDrive, szDir, NULL, NULL); - return CString(szDrive) + CString(szDir); -} -CString CZipArchive::GetFileExt(LPCTSTR lpszFilePath) -{ - TCHAR szExt[_MAX_EXT]; - _tsplitpath(lpszFilePath, NULL, NULL, NULL, szExt); - return CString(szExt); -} - -CString CZipArchive::GetFileTitle(LPCTSTR lpszFilePath) -{ - TCHAR szFname[_MAX_FNAME]; - _tsplitpath(lpszFilePath, NULL, NULL, szFname, NULL); - return CString(szFname); -} - -CString CZipArchive::GetFileDirAndName(LPCTSTR lpszFilePath) -{ - TCHAR szDir[_MAX_DIR]; - TCHAR szFname[_MAX_FNAME]; - TCHAR szExt[_MAX_EXT]; - _tsplitpath(lpszFilePath, NULL , szDir, szFname, szExt); - CString Dir = szDir; - Dir.TrimLeft(_T("\\")); - return Dir + szFname + szExt; -} - - -CString CZipArchive::GetFileName(LPCTSTR lpszFilePath) -{ - TCHAR szExt[_MAX_EXT]; - TCHAR szName[_MAX_FNAME]; - _tsplitpath(lpszFilePath, NULL, NULL, szName, szExt); - return CString(szName) + CString(szExt); -} - -bool CZipArchive::ForceDirectory(LPCTSTR lpDirectory) -{ - ASSERT(lpDirectory); - CString szDirectory = lpDirectory; - szDirectory.TrimRight(_T("\\")); - if ((GetFilePath(szDirectory) == szDirectory) || - (FileExists(szDirectory) == -1)) - return true; - if (!ForceDirectory(GetFilePath(szDirectory))) - return false; - if (!CreateDirectory(szDirectory, NULL)) - return false; - return true; -} - -int CZipArchive::FileExists(LPCTSTR lpszName) -{ - CFileFind fileFind; - if (!fileFind.FindFile(lpszName)) - { - if (DirectoryExists(lpszName)) // if root ex. "C:\" - return -1; - return 0; - } - fileFind.FindNextFile(); - return fileFind.IsDirectory() ? -1 : 1; -} - -bool CZipArchive::DirectoryExists(LPCTSTR lpszDir) -{ - TCHAR curPath[_MAX_PATH]; /* Get the current working directory: */ - if (!_tgetcwd(curPath, _MAX_PATH)) - return false; - if (_tchdir(lpszDir)) // retruns 0 if error - return false; - _tchdir(curPath); - return true; -} - -bool CZipArchive::IsFileDirectory(WORD uIndex) -{ - if (IsClosed()) - { - TRACE(_T("ZipArchive is closed.\n")); - return false; - } - - if (!m_centralDir.IsValidIndex(uIndex)) - return false; - - return IsDirectory(m_centralDir.m_headers[uIndex]->m_uExternalAttr); -} -bool CZipArchive::ExtractFile(WORD uIndex, - LPCTSTR lpszPath, +bool CZipArchive::ExtractFile(WORD uIndex, + LPCTSTR lpszPath, bool bFullPath, LPCTSTR lpszNewName, - ZIPCALLBACKFUN pCallback, - void* pUserData, DWORD nBufSize) { + if (!nBufSize && !lpszPath) return false; CZipFileHeader header; GetFileInfo(header, uIndex); // to ensure that slash and oem conversions take place - CString szFile = lpszPath, szFileName = lpszNewName ? lpszNewName : header.GetFileName(); - szFile.TrimRight(_T("\\")); - szFile += _T("\\") + (bFullPath ? GetFileDirAndName(szFileName) - : GetFileName(szFileName)); // just in case in the archive there are file names with drives + CZipString szFileNameInZip = (LPCTSTR)header.GetFileName(); + CZipString szFile = PredictExtractedFileName(szFileNameInZip, lpszPath, bFullPath, lpszNewName); + CZipActionCallback* pCallback = m_callbacks.Get(cbExtract); + if (pCallback) + pCallback->Init(szFileNameInZip, szFile); - if (IsFileDirectory(uIndex)) + + if (header.IsDirectory()) { - ForceDirectory(szFile); - SetFileAttributes(szFile, header.m_uExternalAttr); + if (pCallback) + pCallback->SetTotal(0); // in case of calling LeftToDo afterwards + + ZipPlatform::ForceDirectory(szFile); + ZipPlatform::SetFileAttr(szFile, header.GetSystemAttr()); + + if (pCallback) + pCallback->CallbackEnd(); return true; } else { + if (pCallback) + pCallback->SetTotal(header.m_uUncomprSize); + if (!OpenFile(uIndex)) return false; - ForceDirectory(GetFilePath(szFile)); - CFile f(szFile, CFile::modeWrite | CFile::modeCreate | CFile::shareDenyWrite); - DWORD iRead, iFileLength = pCallback ? header.GetSize() : 0, iSoFar = 0; + CZipPathComponent zpc(szFile); + ZipPlatform::ForceDirectory(zpc.GetFilePath()); + CZipFile f(szFile, CZipFile::modeWrite | + CZipFile::modeCreate | CZipFile::shareDenyWrite); + DWORD iRead; CZipAutoBuffer buf(nBufSize); + int iAborted = 0; do { iRead = ReadFile(buf, buf.GetSize()); if (iRead) { f.Write(buf, iRead); - iSoFar += iRead; if (pCallback) - if (!pCallback(iFileLength, iSoFar, pUserData)) + if (!(*pCallback)(iRead)) + { + if (iRead == buf.GetSize() && ReadFile(buf, 1) != 0) // test one byte if there is something left + iAborted = CZipException::abortedAction; + else + iAborted = CZipException::abortedSafely; // we did it! break; + } + } } while (iRead == buf.GetSize()); - return CloseFile(f) == 1; + bool bRet = CloseFile(f) == 1; + if (!bRet && iAborted == CZipException::abortedSafely) + iAborted = CZipException::abortedAction; // sorry, finished, but not successfull + + if (pCallback) + pCallback->CallbackEnd(); + + if (iAborted) + CZipException::Throw(iAborted, szFile); // throw to distuingiush from other return codes + return bRet; + } } -void CZipArchive::SetExtraField(char *pBuf, WORD iSize) +bool CZipArchive::ExtractFile(WORD uIndex, + CZipMemFile& mf, + DWORD nBufSize) +{ + if (!nBufSize) + return false; + + CZipFileHeader header; + GetFileInfo(header, uIndex); // to ensure that slash and oem conversions take place + CZipActionCallback* pCallback = m_callbacks.Get(cbExtract); + if (pCallback) + { + pCallback->Init(header.GetFileName()); + pCallback->SetTotal(header.m_uUncomprSize); + } + + if (header.IsDirectory() || !OpenFile(uIndex)) + return false; + + + + + CZipAutoBuffer buf(nBufSize); + mf.SeekToEnd(); + DWORD iRead; + int iAborted = 0; + do + { + iRead = ReadFile(buf, buf.GetSize()); + if (iRead) + { + mf.Write(buf, iRead); + if (pCallback) + if (!(*pCallback)(iRead)) + { + if (iRead == buf.GetSize() && ReadFile(buf, 1) != 0) // test one byte if there is something left + iAborted = CZipException::abortedAction; + else + iAborted = CZipException::abortedSafely; // we did it! + break; + } + } + } + while (iRead == buf.GetSize()); + bool bRet = CloseFile() == 1; + if (!bRet && iAborted == CZipException::abortedSafely) + iAborted = CZipException::abortedAction; // sorry, finished, but not successfull + + if (pCallback) + pCallback->CallbackEnd(); + + if (iAborted) + CZipException::Throw(iAborted); // throw to distuingiush from other return codes + return bRet; +} + + +void CZipArchive::SetExtraField(const char *pBuf, WORD iSize) { if (m_iFileOpened != compress) { - TRACE(_T("A new file must be opened.\n")); + TRACE(_T("%s(%i) : A new file must be opened.\n"),__FILE__,__LINE__); return; } if (!pBuf || !iSize) @@ -733,18 +770,18 @@ void CZipArchive::SetExtraField(char *pBuf, WORD iSize) memcpy(CurrentFile()->m_pExtraField, pBuf, iSize); } -bool CZipArchive::WriteNewFile(void *pBuf, DWORD iSize) +bool CZipArchive::WriteNewFile(const void *pBuf, DWORD iSize) { if (m_iFileOpened != compress) { - TRACE(_T("A new file must be opened.\n")); + TRACE(_T("%s(%i) : A new file must be opened.\n"),__FILE__,__LINE__); return false; } - m_info.m_stream.next_in = (unsigned char*)pBuf; + m_info.m_stream.next_in = (Bytef*)pBuf; m_info.m_stream.avail_in = iSize; - CurrentFile()->m_uCrc32 = crc32(CurrentFile()->m_uCrc32, (unsigned char*)pBuf, iSize); + CurrentFile()->m_uCrc32 = crc32(CurrentFile()->m_uCrc32, (Bytef*)pBuf, iSize); while (m_info.m_stream.avail_in > 0) @@ -755,7 +792,7 @@ bool CZipArchive::WriteNewFile(void *pBuf, DWORD iSize) m_storage.Write(m_info.m_pBuffer, m_info.m_uComprLeft, false); m_info.m_uComprLeft = 0; m_info.m_stream.avail_out = m_info.m_pBuffer.GetSize(); - m_info.m_stream.next_out = (unsigned char*)(char*)m_info.m_pBuffer; + m_info.m_stream.next_out = (Bytef*)(char*)m_info.m_pBuffer; } if (CurrentFile()->m_uMethod == Z_DEFLATED) @@ -785,312 +822,872 @@ bool CZipArchive::WriteNewFile(void *pBuf, DWORD iSize) return true; } -bool CZipArchive::CloseNewFile() +bool CZipArchive::CloseNewFile(bool bAfterException) { if (m_iFileOpened != compress) { - TRACE(_T("A new file must be opened.\n")); + TRACE(_T("%s(%i) : A new file must be opened.\n"),__FILE__,__LINE__); return false; } m_info.m_stream.avail_in = 0; - - int err = Z_OK; - if (CurrentFile()->m_uMethod == Z_DEFLATED) - while (err == Z_OK) - { - if (m_info.m_stream.avail_out == 0) + if (!bAfterException) + { + int err = Z_OK; + if (CurrentFile()->m_uMethod == Z_DEFLATED) + while (err == Z_OK) { - CryptEncodeBuffer(); - m_storage.Write(m_info.m_pBuffer, m_info.m_uComprLeft, false); - m_info.m_uComprLeft = 0; - m_info.m_stream.avail_out = m_info.m_pBuffer.GetSize(); - m_info.m_stream.next_out = (unsigned char*)(char*)m_info.m_pBuffer; + if (m_info.m_stream.avail_out == 0) + { + CryptEncodeBuffer(); + m_storage.Write(m_info.m_pBuffer, m_info.m_uComprLeft, false); + m_info.m_uComprLeft = 0; + m_info.m_stream.avail_out = m_info.m_pBuffer.GetSize(); + m_info.m_stream.next_out = (Bytef*)(char*)m_info.m_pBuffer; + } + DWORD uTotal = m_info.m_stream.total_out; + err = deflate(&m_info.m_stream, Z_FINISH); + m_info.m_uComprLeft += m_info.m_stream.total_out - uTotal; } - DWORD uTotal = m_info.m_stream.total_out; - err = deflate(&m_info.m_stream, Z_FINISH); - m_info.m_uComprLeft += m_info.m_stream.total_out - uTotal; + + if (err == Z_STREAM_END) + err = Z_OK; + CheckForError(err); + + if (m_info.m_uComprLeft > 0) + { + CryptEncodeBuffer(); + m_storage.Write(m_info.m_pBuffer, m_info.m_uComprLeft, false); } - if (err == Z_STREAM_END) - err = Z_OK; - CheckForError(err); - - if (m_info.m_uComprLeft > 0) - { - CryptEncodeBuffer(); - m_storage.Write(m_info.m_pBuffer, m_info.m_uComprLeft, false); + if (CurrentFile()->m_uMethod == Z_DEFLATED) + { + err = deflateEnd(&m_info.m_stream); + CheckForError(err); + } + + + // it may be increased by the encrypted header size + CurrentFile()->m_uComprSize += m_info.m_stream.total_out; + CurrentFile()->m_uUncomprSize = m_info.m_stream.total_in; + + m_centralDir.CloseNewFile(); } - - if (CurrentFile()->m_uMethod == Z_DEFLATED) - { - err = deflateEnd(&m_info.m_stream); - CheckForError(err); - } - - - // it may be increased by the encrypted header size - CurrentFile()->m_uComprSize += m_info.m_stream.total_out; - CurrentFile()->m_uUncomprSize = m_info.m_stream.total_in; - - m_centralDir.CloseNewFile(); + else + m_centralDir.m_pOpenedFile = NULL; + m_iFileOpened = nothing; m_info.m_pBuffer.Release(); + EmptyPtrList(); + + if (m_bAutoFlush && !bAfterException) + Flush(); + return true; } -void CZipArchive::DeleteFiles(CStringArray &aNames, bool bCaseSensitive) +void CZipArchive::DeleteFile(WORD uIndex) { - CWordArray indexes; - - for (WORD i = 0; i < GetNoEntries(); i++) + CZipWordArray indexes; + indexes.Add(uIndex); + DeleteFiles(indexes); +} + + +void CZipArchive::DeleteFiles(const CZipStringArray &aNames, bool bFileNameOnly) +{ + CZipWordArray indexes; + + int iSize = aNames.GetSize(); + for (WORD i = 0; i < iSize; i++) { - CZipFileHeader fh; - GetFileInfo(fh, i); - CString szFileName = fh.GetFileName(); - for (int j = 0; j < aNames.GetSize(); j++) - { - bool bEqual = (bCaseSensitive ? aNames[j].Collate(szFileName) - : aNames[j].CollateNoCase(szFileName)) == 0; - if (bEqual) - { - indexes.Add(i); - break; - } - } + int idx = FindFile(aNames[i], ffDefault, bFileNameOnly); + if (idx != -1) + indexes.Add((WORD)idx); } DeleteFiles(indexes); } -void CZipArchive::DeleteFiles(CWordArray &aIndexes) +void CZipArchive::DeleteFiles(CZipWordArray &aIndexes) { if (IsClosed()) { - TRACE(_T("ZipArchive is closed.\n")); + TRACE(_T("%s(%i) : ZipArchive is closed.\n"),__FILE__,__LINE__); return; } if (m_storage.IsSpanMode()) { - TRACE(_T("You cannot delete files from the disk spannig archive.\n")); + TRACE(_T("%s(%i) : You cannot delete files from the disk spannig archive.\n"),__FILE__,__LINE__); return; } if (m_iFileOpened) { - TRACE(_T("You cannot delete files if there is a file opened.\n")); + TRACE(_T("%s(%i) : You cannot delete files if there is a file opened.\n"),__FILE__,__LINE__); return; } - // sorting the index table using qsort + CZipActionCallback* pCallback = m_callbacks.Get(cbDeleteCnt); + if (pCallback) + pCallback->Init(); + int uSize = aIndexes.GetSize(); if (!uSize) + { + TRACE(_T("%s(%i) : The indekses array is empty.\n"),__FILE__,__LINE__); return; - qsort((void*)&aIndexes[0], uSize, sizeof(WORD), CompareWords); + } + + // remove all - that's easy so don't waste a time + if (uSize == GetCount()) + { + pCallback = m_callbacks.Get(cbDelete); + if (pCallback) + { + // make this formal + pCallback->Init(); + pCallback->SetTotal(uSize); + } + + m_centralDir.RemoveFromDisk(); + m_storage.m_pFile->SetLength(m_centralDir.GetBytesBefore()); + m_centralDir.RemoveAll(); + if (m_bAutoFlush) + Flush(); + if (pCallback) + pCallback->CallbackEnd(); + return; + } + + aIndexes.Sort(true); + + CZipArray aInfo; + int iDelIndex = 0; + + + int iStep = 0; // for the compiler + if (pCallback) + { + pCallback->SetTotal(GetCount()); + iStep = CZipActionCallback::m_iStep; // we don't want to wait forever + } + + int i; + int uMaxDelIndex = aIndexes[uSize - 1]; + for (i = aIndexes[0]; i < GetCount(); i++) + { + CZipFileHeader* pHeader = m_centralDir[i]; + bool bDelete; + if (i <= uMaxDelIndex && i == aIndexes[iDelIndex]) + { + iDelIndex++; + bDelete = true; + } + else + bDelete = false; + aInfo.Add(CZipDeleteInfo(pHeader, bDelete)); + if (pCallback && (!(i % iStep))) + if (!(*pCallback)(iStep)) + ThrowError(CZipException::abortedSafely); + } + ASSERT(iDelIndex == uSize); + + uSize = aInfo.GetSize(); + if (!uSize) // it is possible + return; + + // now we start deleting (not safe to break) + pCallback = m_callbacks.Get(cbDelete); + if (pCallback) + pCallback->Init(); + + m_storage.Flush(); m_centralDir.RemoveFromDisk(); + + DWORD uTotalToMoveBytes = 0, uLastOffset = m_storage.m_pFile->GetLength() - m_centralDir.GetBytesBefore(); + // count the number of bytes to move + for (i = uSize - 1; i >=0 ; i--) + { + const CZipDeleteInfo& di = aInfo[i]; + if (!di.m_bDelete) + uTotalToMoveBytes += uLastOffset - di.m_pHeader->m_uOffset; + uLastOffset = di.m_pHeader->m_uOffset; + } + if (pCallback) + pCallback->CallbackEnd(); + + + if (pCallback) + pCallback->SetTotal(uTotalToMoveBytes); + m_info.Init(); - // remove in a reverse order - for (int i = uSize - 1; i >= 0; i--) - DeleteInternal(aIndexes[i]); + + DWORD uMoveBy = 0, uOffsetStart = 0; + for (i = 0; i < uSize; i++) + { + const CZipDeleteInfo& di = aInfo[i]; + if (di.m_bDelete) + { + // next hole + DWORD uTemp = di.m_pHeader->m_uOffset; + m_centralDir.RemoveFile(di.m_pHeader); // first remove + if (uOffsetStart) + { + // copy the files over a previous holes + MovePackedFiles(uOffsetStart, uTemp, uMoveBy); + uOffsetStart = 0; // never be at the beginning, because the first file is always to be deleted + } + if (i == uSize - 1) + uTemp = (m_storage.m_pFile->GetLength() - m_centralDir.GetBytesBefore()) - uTemp; + else + uTemp = aInfo[i+1].m_pHeader->m_uOffset - uTemp; + + uMoveBy += uTemp; + + } + else + { + if (uOffsetStart == 0) // find contiuos area to move + uOffsetStart = di.m_pHeader->m_uOffset; + di.m_pHeader->m_uOffset -= uMoveBy; + } + + } + if (uOffsetStart) + MovePackedFiles(uOffsetStart, + m_storage.m_pFile->GetLength() - m_centralDir.GetBytesBefore(), + uMoveBy); + m_info.m_pBuffer.Release(); + if (uMoveBy) // just in case + m_storage.m_pFile->SetLength(m_storage.m_pFile->GetLength() - uMoveBy); + + if (pCallback) + pCallback->CallbackEnd(); + + if (m_bAutoFlush) + Flush(); } -DWORD CZipArchive::RemovePackedFile(DWORD uStartOffset, DWORD uEndOffset) +bool CZipArchive::MovePackedFiles(DWORD uStartOffset, DWORD uEndOffset, DWORD uMoveBy) { - uStartOffset += m_centralDir.m_uBytesBeforeZip; - uEndOffset += m_centralDir.m_uBytesBeforeZip; - DWORD BytesToCopy = m_storage.m_pFile->GetLength() - uEndOffset; - DWORD uTotalToWrite = BytesToCopy; + uStartOffset += m_centralDir.GetBytesBefore(); + uEndOffset += m_centralDir.GetBytesBefore(); + + DWORD uTotalToMove = uEndOffset - uStartOffset; + DWORD uPack = uTotalToMove > m_info.m_pBuffer.GetSize() ? m_info.m_pBuffer.GetSize() : uTotalToMove; char* buf = (char*)m_info.m_pBuffer; - if (BytesToCopy > m_info.m_pBuffer.GetSize()) - BytesToCopy = m_info.m_pBuffer.GetSize(); - - - DWORD TotalWritten = 0; + DWORD TotalMoved = 0; DWORD size_read; + CZipActionCallback* pCallback = m_callbacks.Get(cbDelete); // already initiated do { - m_storage.m_pFile->Seek(uEndOffset + TotalWritten, CFile::begin); - size_read = m_storage.m_pFile->Read(buf, BytesToCopy); + m_storage.m_pFile->Seek(uStartOffset + TotalMoved, CZipAbstractFile::begin); + size_read = m_storage.m_pFile->Read(buf, uPack); if (size_read > 0) - { - m_storage.m_pFile->Seek(uStartOffset + TotalWritten, CFile::begin); + { + if (TotalMoved + size_read > uTotalToMove) + size_read = uTotalToMove - TotalMoved; + m_storage.m_pFile->Seek(uStartOffset + TotalMoved - uMoveBy, CZipAbstractFile::begin); m_storage.m_pFile->Write(buf, size_read); + TotalMoved += size_read; + if (pCallback) + if (!(*pCallback)(size_read)) + ThrowError(CZipException::abortedAction); } - TotalWritten += size_read; - } - while (size_read == BytesToCopy); - if (uTotalToWrite != TotalWritten) - ThrowError(CZipException::generic); - DWORD uRemoved = (uEndOffset - uStartOffset); - m_storage.m_pFile->SetLength(m_storage.m_pFile->GetLength() - uRemoved); - return uRemoved; -} - - -void CZipArchive::DeleteInternal(WORD uIndex) -{ - CZipFileHeader* pfh = m_centralDir.m_headers[uIndex]; - DWORD uOtherOffsetChanged = 0; - - if (uIndex == GetNoEntries() - 1) // last entry or the only one entry - m_storage.m_pFile->SetLength(pfh->m_uOffset + m_centralDir.m_uBytesBeforeZip); - else - uOtherOffsetChanged = RemovePackedFile(pfh->m_uOffset, m_centralDir.m_headers[uIndex + 1]->m_uOffset); - - - m_centralDir.RemoveFile(uIndex); - - // teraz uaktualnij offsety w pozosta³ych pozycjach central dir - // (update offsets in file headers in the central dir) - if (uOtherOffsetChanged) - for (int i = uIndex; i < GetNoEntries(); i++) - m_centralDir.m_headers[i]->m_uOffset -= uOtherOffsetChanged; -} - -bool CZipArchive::IsDriveRemovable(LPCTSTR lpszFilePath) -{ - return GetDriveType(GetDrive(lpszFilePath)) == DRIVE_REMOVABLE; -} - -CString CZipArchive::GetDrive(LPCTSTR lpszFilePath) -{ - TCHAR szDrive[_MAX_DRIVE]; - _tsplitpath(lpszFilePath, szDrive, NULL, NULL, NULL); - return szDrive; -} - -bool CZipArchive::AddNewFile(LPCTSTR lpszFilePath, - int iLevel, - bool bFullPath, - ZIPCALLBACKFUN pCallback, - void* pUserData, - unsigned long nBufSize) -{ - if (!nBufSize) - return false; - - CZipFileHeader header; - header.SetFileName(bFullPath ? GetFileDirAndName(lpszFilePath) : GetFileName(lpszFilePath)); - if (header.GetFileNameSize() == 0) - return false; - if (!OpenNewFile(header, iLevel, lpszFilePath)) - return false; - - if (!IsDirectory(header.m_uExternalAttr)) - { - CFile f; - CFileException* e = new CFileException; - BOOL bRet = f.Open(lpszFilePath, CFile::modeRead | CFile::shareDenyWrite, e); - e->Delete(); - if (!bRet) - return false; - DWORD iRead, iFileLength = pCallback ? f.GetLength() : 0, iSoFar = 0; - CZipAutoBuffer buf(nBufSize); - do - { - iRead = f.Read(buf, nBufSize); - if (iRead) - { - WriteNewFile(buf, iRead); - iSoFar += iRead; - if (pCallback) - if (!pCallback(iFileLength, iSoFar, pUserData)) - break; - } - } - while (iRead == buf.GetSize()); } - CloseNewFile(); + while (size_read); + return true; } -int CZipArchive::GetSpanMode() + +bool CZipArchive::AddNewFile(LPCTSTR lpszFilePath, + int iLevel, + bool bFullPath, + int iSmartLevel, + unsigned long nBufSize) { - return m_storage.m_iSpanMode * m_storage.IsSpanMode(); + + + CZipString szFilePath(lpszFilePath); + CZipPathComponent::RemoveSeparators(szFilePath); + CZipPathComponent zpc(szFilePath); + + return AddNewFile(lpszFilePath, (LPCTSTR) (bFullPath ? zpc.GetNoDrive() : TrimRootPath(zpc)), + iLevel, iSmartLevel, nBufSize); + } -CString CZipArchive::GetArchivePath() + +bool CZipArchive::AddNewFile(LPCTSTR lpszFilePath, + LPCTSTR lpszFileNameInZip, + int iLevel, + int iSmartLevel, + unsigned long nBufSize) { + + if (!nBufSize) + return false; + + CZipActionCallback* pCallback = m_callbacks.Get((iSmartLevel & zipsmInternal01) ? cbAddStore : cbAdd); + if (pCallback) + pCallback->Init(lpszFileNameInZip, lpszFilePath); + + + CZipString szFilePath(lpszFilePath); + CZipPathComponent::RemoveSeparators(szFilePath); + if (szFilePath.IsEmpty()) + return false; + + DWORD uAttr; + time_t ttime; + if (!ZipPlatform::GetFileAttr(szFilePath, uAttr)) + return false; + if (!ZipPlatform::GetFileModTime(szFilePath, ttime)) + ttime = time(NULL); + + CZipFileHeader header; + header.SetFileName(lpszFileNameInZip); + if (ZipPlatform::GetSystemID() != ZipCompatibility::zcUnix) + uAttr |= ZipCompatibility::ConvertToSystem(uAttr, ZipPlatform::GetSystemID(), ZipCompatibility::zcUnix); // make it readable under Unix as well, since it stores its attributes in HIWORD(uAttr) + SetFileHeaderAttr(header, uAttr); + header.SetTime(ttime); + + if (header.IsDirectory()) + { + if (pCallback) + pCallback->SetTotal(0); // in case of calling LeftToDo afterwards + + // clear password for a directory + bool bRet = false; + CZipSmClrPass smcp; + if (iSmartLevel & zipsmCPassDir) + smcp.ClearPasswordSmartly(this); + bRet = OpenNewFile(header, 0); + CloseNewFile(); + + if (pCallback) + pCallback->CallbackEnd(); + + return bRet; + } + + DWORD iFileSize = DWORD(-1); + CZipSmClrPass smcp; + bool bEff = (iSmartLevel & zipsmCheckForEff)&& (iLevel != 0); + bool bSpan = GetSpanMode() != 0; + if (((iSmartLevel & zipsmCPFile0) && !GetPassword().IsEmpty()) + || ((iSmartLevel & zipsmNotCompSmall) && iLevel != 0) + || (bEff && bSpan)) + { + + if (ZipPlatform::GetFileSize(szFilePath, iFileSize)) + { + if ((iSmartLevel & zipsmNotCompSmall) && iFileSize < 5) + iLevel = 0; + if ((iSmartLevel & zipsmCPFile0) && iFileSize == 0) + smcp.ClearPasswordSmartly(this); + } + else if (bEff) // the file size is needed only when eff. in span mode + bEff = false; + } + + + bool bEffInMem = bEff && (iSmartLevel & zipsmMemoryFlag); + CZipString szTempFileName; + if (bSpan && bEff + && (bEffInMem || !(szTempFileName = ZipPlatform::GetTmpFileName( + m_szTempPath.IsEmpty() ? NULL : (LPCTSTR)m_szTempPath, iFileSize)).IsEmpty())) + + { + CZipMemFile* pmf = NULL; + CZipArchive zip; + try + { + // compress first to a temporary file, if ok - copy the data, if not - add storing + bEff = false; + + if (bEffInMem) + { + pmf = new CZipMemFile; + zip.Open(*pmf, zipCreate); + } + else + zip.Open(szTempFileName, zipCreate); + zip.SetRootPath(m_szRootPath); + zip.SetPassword(GetPassword()); + zip.SetSystemCompatibility(m_iArchiveSystCompatib); + // create a temporary file + if (!zip.AddNewFile(szFilePath, lpszFileNameInZip, iLevel, + zipsmLazy, nBufSize)) + throw false; + CZipFileHeader fh; + zip.GetFileInfo(fh, 0); + if (!fh.CompressionEfficient()) + // compression is pointless, store instead + throw AddNewFile(szFilePath, lpszFileNameInZip, 0, + zipsmInternal01, nBufSize); + + CZipActionCallback* pCallbackTmp = m_callbacks.Get(cbAddTmp); + if (pCallbackTmp) + { + pCallbackTmp->Init(lpszFileNameInZip, lpszFilePath); + pCallbackTmp->SetTotal(fh.m_uComprSize); + } + + m_centralDir.ConvertFileName(false, m_centralDir.m_bConvertAfterOpen, &fh); + fh.WriteLocal(m_storage); // must be written as converted + CZipString szConvertedFileName; + if (!m_centralDir.m_bConvertAfterOpen) + szConvertedFileName = fh.GetFileName(); + fh.SetFileName(lpszFileNameInZip); + CZipAbstractFile* pFile = zip.m_storage.m_pFile; + // skip reading the local file header + pFile->Seek(fh.GetSize(true), CZipAbstractFile::begin); + + DWORD iRead; + CZipAutoBuffer buf(nBufSize); + + + int iAborted = 0; + do + { + iRead = pFile->Read(buf, nBufSize); + if (iRead) + { + m_storage.Write(buf, iRead, false); + if (pCallbackTmp) + if (!(*pCallbackTmp)(iRead)) + { + // todo: we could remove here the bytes of the file partially added if not disk-spanning + if (iRead == buf.GetSize() && pFile->Read(buf, 1) != 0) // test one byte if there is something left + iAborted = CZipException::abortedAction; + else + iAborted = CZipException::abortedSafely; // we did it! + break; + } + + } + + } + while (iRead == buf.GetSize()); + if (iAborted != CZipException::abortedAction) + { + CZipFileHeader* pHeader = m_centralDir.AddNewFile(fh); // must not converted when adding because of InsertFastElement + if (!m_centralDir.m_bConvertAfterOpen) // we keep it converted to internal zip standards + pHeader->SetFileName(szConvertedFileName); + } + + m_centralDir.m_pOpenedFile = NULL; + if (pCallbackTmp) + pCallbackTmp->CallbackEnd(); + + if (iAborted) + CZipException::Throw(iAborted); // throw to distuingiush from other return codes + + throw true; + } + catch (bool bRet) + { + zip.Close(!bRet); // that doesn't really matter how it will be closed + if (pmf) + delete pmf; + if (!bEffInMem) + ZipPlatform::RemoveFile(szTempFileName, false); + return bRet; + } + catch (...) + { + zip.Close(true); + if (pmf) + delete pmf; + if (!bEffInMem) + ZipPlatform::RemoveFile(szTempFileName, false); + throw; + } + } + + + // try to open before adding + CZipFile f; + if (!f.Open(szFilePath, CZipFile::modeRead | CZipFile::shareDenyWrite, false)) + return false; + // call init before opening (in case of exception we have the names) + if (pCallback) + pCallback->SetTotal(f.GetLength()); + + if (!OpenNewFile(header, iLevel)) + return false; + + + CZipAutoBuffer buf(nBufSize); + DWORD iRead; + int iAborted = 0; + do + { + iRead = f.Read(buf, nBufSize); + if (iRead) + { + WriteNewFile(buf, iRead); + if (pCallback) + if (!(*pCallback)(iRead)) + { + // todo: we could remove here the bytes of the file partially added if not disk-spanning + if (iRead == buf.GetSize() && f.Read(buf, 1) != 0) // test one byte if there is something left + { + if (!m_storage.IsSpanMode()) + { + RemoveLast(true); + CloseNewFile(true); + iAborted = CZipException::abortedSafely; + } + else + iAborted = CZipException::abortedAction; + } + else + { + iAborted = CZipException::abortedSafely; // we did it! + CloseNewFile(); + } + break; + } + + } + + } + while (iRead == buf.GetSize()); + if (!iAborted) + CloseNewFile(); + + if (pCallback) + pCallback->CallbackEnd(); + + if (iAborted) + CZipException::Throw(iAborted); // throw to distuingiush from other return codes + + if (bEff) + { + // remove the last file and add it without the compression if needed + f.Close(); + buf.Release(); + if (RemoveLast()) + return AddNewFile(szFilePath, lpszFileNameInZip, 0, + zipsmInternal01, nBufSize); + } + return true; +} + +bool CZipArchive::AddNewFile(CZipMemFile& mf, + LPCTSTR lpszFileNameInZip, + int iLevel, + int iSmartLevel, + unsigned long nBufSize) +{ + + if (!nBufSize) + return false; + + CZipActionCallback* pCallback = m_callbacks.Get((iSmartLevel & zipsmInternal01) ? cbAddStore : cbAdd); + if (pCallback) + pCallback->Init(lpszFileNameInZip); + + CZipFileHeader header; + header.SetFileName(lpszFileNameInZip); + SetFileHeaderAttr(header, ZipPlatform::GetDefaultAttributes()); + header.SetTime(time(NULL)); + + DWORD iFileSize = mf.GetLength(); + + CZipSmClrPass smcp; + bool bEff = (iSmartLevel & zipsmCheckForEff)&& (iLevel != 0); + bool bSpan = GetSpanMode() != 0; + + + if ((iSmartLevel & zipsmNotCompSmall) && iLevel != 0 && iFileSize < 6) + iLevel = 0; + if ((iSmartLevel & zipsmCPFile0) && !GetPassword().IsEmpty() && iFileSize == 0) + smcp.ClearPasswordSmartly(this); + + bool bEffInMem = bEff && (iSmartLevel & zipsmMemoryFlag); + CZipString szTempFileName; + if (bSpan && bEff + && (bEffInMem || !(szTempFileName = ZipPlatform::GetTmpFileName( + m_szTempPath.IsEmpty() ? NULL : (LPCTSTR)m_szTempPath, iFileSize)).IsEmpty())) + + { + CZipMemFile* pmf = NULL; + CZipArchive zip; + try + { + // compress first to a temporary file or memory, if ok - copy the data, if not - add storing + bEff = false; + + if (bEffInMem) + { + pmf = new CZipMemFile; + zip.Open(*pmf, zipCreate); + } + else + zip.Open(szTempFileName, zipCreate); + zip.SetRootPath(m_szRootPath); + zip.SetPassword(GetPassword()); + zip.SetSystemCompatibility(m_iArchiveSystCompatib); + if (!zip.AddNewFile(mf, lpszFileNameInZip, iLevel, + zipsmLazy, nBufSize)) + throw false; + CZipFileHeader fh; + zip.GetFileInfo(fh, 0); + if (!fh.CompressionEfficient()) + // compression is pointless, store instead + throw AddNewFile(mf, lpszFileNameInZip, 0, + zipsmInternal01, nBufSize); + // moving compressed data - new callback + CZipActionCallback* pCallbackTmp = m_callbacks.Get(cbAddTmp); + if (pCallbackTmp) + { + pCallbackTmp->Init(lpszFileNameInZip); + pCallbackTmp->SetTotal(fh.m_uComprSize); + } + + + + m_centralDir.ConvertFileName(false, m_centralDir.m_bConvertAfterOpen, &fh); + fh.WriteLocal(m_storage); // must be written converted + CZipString szConvertedFileName; + if (!m_centralDir.m_bConvertAfterOpen) + szConvertedFileName = fh.GetFileName(); + fh.SetFileName(lpszFileNameInZip); + CZipAbstractFile* pFile = zip.m_storage.m_pFile; + // skip reading the local file header + pFile->Seek(fh.GetSize(true), CZipAbstractFile::begin); + + DWORD iRead; + CZipAutoBuffer buf(nBufSize); + + int iAborted = 0; + do + { + iRead = pFile->Read(buf, nBufSize); + if (iRead) + { + m_storage.Write(buf, iRead, false); + if (pCallbackTmp) + if (!(*pCallbackTmp)(iRead)) + { + if (iRead == buf.GetSize() && pFile->Read(buf, 1) != 0) // test one byte if there is something left + iAborted = CZipException::abortedAction; + else + iAborted = CZipException::abortedSafely; // we did it! + break; + } + } + + } + while (iRead == buf.GetSize()); + + if (iAborted != CZipException::abortedAction) + { + CZipFileHeader* pHeader = m_centralDir.AddNewFile(fh); // must not converted when adding because of InsertFastElement + if (!m_centralDir.m_bConvertAfterOpen) // we keep it converted to internal zip standards + pHeader->SetFileName(szConvertedFileName); + } + + m_centralDir.m_pOpenedFile = NULL; + + if (pCallbackTmp) + pCallbackTmp->CallbackEnd(); + + + if (iAborted) + CZipException::Throw(iAborted); // throw to distuingiush from other return codes + + throw true; + } + catch (bool bRet) + { + zip.Close(!bRet); // that doesn't really matter how it will be closed + if (pmf) + delete pmf; + if (!bEffInMem) + ZipPlatform::RemoveFile(szTempFileName, false); + return bRet; + } + catch (...) + { + zip.Close(true); + if (pmf) + delete pmf; + if (!bEffInMem) + ZipPlatform::RemoveFile(szTempFileName, false); + throw; + } + } + + // normal adding + if (pCallback) + pCallback->SetTotal(mf.GetLength()); + + if (!OpenNewFile(header, iLevel)) + return false; + + + // we cannot Detach CZipMemFile here + CZipAutoBuffer buf(nBufSize); + mf.SeekToBegin(); + DWORD iRead; + int iAborted = 0; + do + { + iRead = mf.Read(buf, nBufSize); + if (iRead) + { + WriteNewFile(buf, iRead); + if (pCallback) + if (!(*pCallback)(iRead)) + { + if (iRead == buf.GetSize() && mf.Read(buf, 1) != 0) // test one byte if there is something left + { + if (!m_storage.IsSpanMode()) + { + RemoveLast(true); + CloseNewFile(true); + iAborted = CZipException::abortedSafely; + } + else + iAborted = CZipException::abortedAction; + } + else + { + iAborted = CZipException::abortedSafely; // we did it! + CloseNewFile(); + } + break; + } + } + + } + while (iRead == buf.GetSize()); + if (!iAborted) + CloseNewFile(); + + if (pCallback) + pCallback->CallbackEnd(); + + + if (iAborted) + CZipException::Throw(iAborted); // throw to distuingiush from other return codes + + if (bEff) + { + // remove the last file and add it without the compression if needed + buf.Release(); + if (RemoveLast()) + return AddNewFile(mf, lpszFileNameInZip, 0, + zipsmInternal01, nBufSize); + } + return true; +} + + +bool CZipArchive::RemoveLast(bool bRemoveAnyway) +{ + int iIndex = GetCount() - 1; + CZipFileHeader* pHeader = m_centralDir[iIndex]; + + if (!bRemoveAnyway && pHeader->CompressionEfficient()) + return false; + + m_centralDir.RemoveLastFile(pHeader, iIndex); + return true; +} + + + + +CZipString CZipArchive::GetArchivePath() const +{ + if (IsClosed(false)) + { + TRACE(_T("%s(%i) : ZipArchive is closed.\n"),__FILE__,__LINE__); + return _T(""); + } return m_storage.m_pFile->GetFilePath(); } -CString CZipArchive::GetGlobalComment() +CZipString CZipArchive::GetGlobalComment() const { if (IsClosed()) { - TRACE(_T("ZipArchive is closed.\n")); + TRACE(_T("%s(%i) : ZipArchive is closed.\n"),__FILE__,__LINE__); return _T(""); } - CString temp; - if (SingleToWide(m_centralDir.m_pszComment, temp) != -1) - return temp; - else - return _T(""); + CZipString temp; + return SingleToWide(m_centralDir.m_pszComment, temp) != -1 ? (LPCTSTR)temp : _T(""); } -bool CZipArchive::SetGlobalComment(const CString &szComment) +bool CZipArchive::SetGlobalComment(LPCTSTR lpszComment) { if (IsClosed()) { - TRACE(_T("ZipArchive is closed.\n")); + TRACE(_T("%s(%i) : ZipArchive is closed.\n"),__FILE__,__LINE__); return false; } if (m_storage.IsSpanMode() == -1) { - TRACE(_T("You cannot modify the global comment of the existing disk spanning archive.\n")); + TRACE(_T("%s(%i) : You cannot modify the global comment of the existing disk spanning archive.\n"),__FILE__,__LINE__); return false; } - WideToSingle(szComment, m_centralDir.m_pszComment); + WideToSingle(lpszComment, m_centralDir.m_pszComment); m_centralDir.RemoveFromDisk(); + if (m_bAutoFlush) + Flush(); + return true; } -bool CZipArchive::IsDirectory(DWORD uAttr) -{ - return (uAttr & FILE_ATTRIBUTE_DIRECTORY) != 0; -} -int CZipArchive::GetCurrentDisk() + +int CZipArchive::GetCurrentDisk() const { return m_storage.GetCurrentDisk() + 1; } -bool CZipArchive::SetFileComment(WORD uIndex, CString szComment) +bool CZipArchive::SetFileComment(WORD uIndex, LPCTSTR lpszComment) { if (IsClosed()) { - TRACE(_T("ZipArchive is closed.\n")); + TRACE(_T("%s(%i) : ZipArchive is closed.\n"),__FILE__,__LINE__); return false; } if (m_storage.IsSpanMode() == -1) { - TRACE(_T("You cannot modify the file comment in the existing disk spanning archive.\n")); + TRACE(_T("%s(%i) : You cannot modify the file comment in the existing disk spanning archive.\n"),__FILE__,__LINE__); return false; } if (!m_centralDir.IsValidIndex(uIndex)) + { + ASSERT(FALSE); return false; - m_centralDir.m_headers[uIndex]->SetComment(szComment); + } + m_centralDir[uIndex]->SetComment(lpszComment); m_centralDir.RemoveFromDisk(); + if (m_bAutoFlush) + Flush(); return true; } -int CZipArchive::CompareWords(const void *pArg1, const void *pArg2) -{ - WORD w1 = *(WORD*)pArg1; - WORD w2 = *(WORD*)pArg2; - return w1 == w2 ? 0 :(w1 < w2 ? - 1 : 1); -} void CZipArchive::CryptInitKeys() { @@ -1114,19 +1711,17 @@ void CZipArchive::CryptUpdateKeys(char c) bool CZipArchive::CryptCheck() { - CZipAutoBuffer buf(ENCR_HEADER_LEN); - m_storage.Read(buf, ENCR_HEADER_LEN, false); + CZipAutoBuffer buf(ZIPARCHIVE_ENCR_HEADER_LEN); + m_storage.Read(buf, ZIPARCHIVE_ENCR_HEADER_LEN, false); BYTE b = 0; - for (int i = 0; i < ENCR_HEADER_LEN; i++) + for (int i = 0; i < ZIPARCHIVE_ENCR_HEADER_LEN; i++) { b = buf[i]; // only temporary CryptDecode((char&)b); } // check the last byte - if (CurrentFile()->IsDataDescr()) // Data descriptor present - return BYTE(CurrentFile()->m_uModTime >> 8) == b; - else - return BYTE(CurrentFile()->m_uCrc32 >> 24) == b; + return CurrentFile()->IsDataDescr() ? + (BYTE(CurrentFile()->m_uModTime >> 8) == b) : (BYTE(CurrentFile()->m_uCrc32 >> 24) == b); } char CZipArchive::CryptDecryptByte() @@ -1145,12 +1740,12 @@ bool CZipArchive::SetPassword(LPCTSTR lpszPassword) { if (m_iFileOpened != nothing) { - TRACE(_T("You cannot change the password when the file is opened\n")); + TRACE(_T("%s(%i) : You cannot change the password when the file is opened.\n"),__FILE__,__LINE__); return false; // it's important not to change the password when the file inside archive is opened } if (IsClosed()) { - TRACE(_T("Setting the password for a closed archive has no effect.\n")); + TRACE(_T("%s(%i) : Setting the password for a closed archive has no effect.\n"),__FILE__,__LINE__); } if (lpszPassword) { @@ -1158,10 +1753,10 @@ bool CZipArchive::SetPassword(LPCTSTR lpszPassword) if (iLen == -1) return false; for (size_t i = 0; (int)i < iLen; i++) - if (m_pszPassword[i] > 127) + if (m_pszPassword[i] <= 0) { m_pszPassword.Release(); - TRACE(_T("The password contains forbidden characters. Password cleared.\n")); + TRACE(_T("%s(%i) : The password contains forbidden characters. Password cleared.\n"),__FILE__,__LINE__); return false; } } @@ -1170,6 +1765,13 @@ bool CZipArchive::SetPassword(LPCTSTR lpszPassword) return true; } +CZipString CZipArchive::GetPassword()const +{ + CZipString temp; + CZipArchive::SingleToWide(m_pszPassword, temp); + return temp; +} + DWORD CZipArchive::CryptCRC32(DWORD l, char c) { const DWORD *CRC_TABLE = get_crc_table(); @@ -1179,10 +1781,10 @@ DWORD CZipArchive::CryptCRC32(DWORD l, char c) void CZipArchive::CryptCryptHeader(long iCrc, CZipAutoBuffer &buf) { CryptInitKeys(); - srand(UINT(GetTickCount()*time(NULL))); + srand(UINT(time(NULL))); // genereate pseudo-random sequence char c; - for (int i = 0; i < ENCR_HEADER_LEN - 2; i++) + for (int i = 0; i < ZIPARCHIVE_ENCR_HEADER_LEN - 2; i++) { int t1 = rand(); c = (char)(t1 >> 6); @@ -1194,10 +1796,10 @@ void CZipArchive::CryptCryptHeader(long iCrc, CZipAutoBuffer &buf) } c = (char)((iCrc >> 16) & 0xff); CryptEncode(c); - buf[ENCR_HEADER_LEN - 2] = c; + buf[ZIPARCHIVE_ENCR_HEADER_LEN - 2] = c; c = (char)((iCrc >> 24) & 0xff); CryptEncode(c); - buf[ENCR_HEADER_LEN - 1] = c; + buf[ZIPARCHIVE_ENCR_HEADER_LEN - 1] = c; } void CZipArchive::CryptEncode(char &c) @@ -1218,7 +1820,7 @@ void CZipArchive::CloseFileAfterTestFailed() { if (m_iFileOpened != extract) { - TRACE(_T("No file opened.\n")); + TRACE(_T("%s(%i) : No file opened.\n"),__FILE__,__LINE__); return; } m_info.m_pBuffer.Release(); @@ -1226,122 +1828,117 @@ void CZipArchive::CloseFileAfterTestFailed() m_iFileOpened = nothing; } -bool CZipArchive::TestFile(WORD uIndex, ZIPCALLBACKFUN pCallback, void* pUserData, DWORD uBufSize) +bool CZipArchive::TestFile(WORD uIndex, DWORD uBufSize) { + if (m_storage.IsSpanMode() == 1) + { + TRACE(_T("%s(%i) : You cannot test the spanning archive in creation.\n"),__FILE__,__LINE__); + return false; + } if (!uBufSize) return false; - CZipFileHeader* pHeader = m_centralDir.m_headers[uIndex]; - if (IsFileDirectory(uIndex)) + + CZipFileHeader* pHeader = m_centralDir[uIndex]; + CZipActionCallback* pCallback = m_callbacks.Get(cbTest); + if (pCallback) { - - // we do not test whether the password for the encrypted directory + pCallback->Init(m_centralDir.GetProperHeaderFileName(pHeader)); + } + + if (pHeader->IsDirectory()) + { + if (pCallback) + pCallback->SetTotal(0); + + // we do not test whether the password for the encrypted directory // is correct, since it seems to be senseless (anyway password // encrypted directories should be avoided - it adds 12 bytes) DWORD iSize = pHeader->m_uComprSize; if ((iSize != 0 || iSize != pHeader->m_uUncomprSize) // different treating compressed directories && !(pHeader->IsEncrypted() && iSize == 12 && !pHeader->m_uUncomprSize)) - ThrowError(CZipException::dirWithSize); + CZipException::Throw(CZipException::dirWithSize); + + if (pCallback) + pCallback->CallbackEnd(); + return true; } else { try - { + { + if (pCallback) + pCallback->SetTotal(pHeader->m_uUncomprSize); + if (!OpenFile(uIndex)) return false; CZipAutoBuffer buf(uBufSize); - DWORD iRead, iSoFar = 0; + DWORD iRead; + int iAborted = 0; do { iRead = ReadFile(buf, buf.GetSize()); - iSoFar += iRead; - if (pCallback) - if (!pCallback(pHeader->m_uUncomprSize, iSoFar, pUserData)) + if (pCallback && iRead) + if (!(*pCallback)(iRead)) + { + if (iRead == buf.GetSize() && ReadFile(buf, 1) != 0) // test one byte if there is something left + iAborted = CZipException::abortedAction; + else + iAborted = CZipException::abortedSafely; // we did it! break; + } } while (iRead == buf.GetSize()); - CloseFile(); + bool bRet = CloseFile() != -1; + if (!bRet && iAborted == CZipException::abortedSafely) + iAborted = CZipException::abortedAction; // sorry, finished, but not successfull + + if (pCallback) + pCallback->CallbackEnd(); + + if (iAborted) + CZipException::Throw(iAborted); // throw to distuingiush from other return codes + return bRet; } - catch(CException*) + catch(...) { CloseFileAfterTestFailed(); throw; } } - return true; - } int CZipArchive::WideToSingle(LPCTSTR lpWide, CZipAutoBuffer &szSingle) { - size_t wideLen = _tcslen(lpWide); - if (wideLen == 0) - { - szSingle.Release(); - return 0; - } - -#ifdef _UNICODE - // iLen does not include terminating character - int iLen = WideCharToMultiByte(CP_ACP,0, lpWide, wideLen, szSingle, - 0, NULL, NULL); - if (iLen > 0) - { - szSingle.Allocate(iLen, true); - iLen = WideCharToMultiByte(CP_ACP,0, lpWide , wideLen, szSingle, - iLen, NULL, NULL); - ASSERT(iLen != 0); - } - else // here it means error - { - szSingle.Release(); - iLen --; - } - return iLen; - -#else // if not UNICODE just copy +#ifdef _UNICODE + return ZipPlatform::WideToSingle(lpWide, szSingle); +#else + + size_t iLen = strlen(lpWide); + // if not UNICODE just copy // iLen does not include the NULL character - szSingle.Allocate(wideLen); - memcpy(szSingle, lpWide, wideLen); - return wideLen; + szSingle.Allocate(iLen); + memcpy(szSingle, lpWide, iLen); + return iLen; #endif } -int CZipArchive::SingleToWide(CZipAutoBuffer &szSingle, CString& szWide) +int CZipArchive::SingleToWide(const CZipAutoBuffer &szSingle, CZipString& szWide) { - int singleLen = szSingle.GetSize(); + #ifdef _UNICODE - // iLen doesn't include terminating character - int iLen = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, szSingle, singleLen, NULL, 0); - if (iLen > 0) - { - iLen = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, szSingle, singleLen, - szWide.GetBuffer(iLen) , iLen); - szWide.ReleaseBuffer(iLen); - ASSERT(iLen != 0); - } - else - { - szWide.Empty(); - iLen --; - } - return iLen; - + return ZipPlatform::SingleToWide(szSingle, szWide); #else // if not UNICODE just copy + int singleLen = szSingle.GetSize(); // iLen does not include the NULL character - memcpy(szWide.GetBuffer(singleLen), szSingle, singleLen); + memcpy(szWide.GetBuffer(singleLen),szSingle.GetBuffer(), singleLen); szWide.ReleaseBuffer(singleLen); return singleLen; #endif } -const DWORD* CZipArchive::GetCRCTable() -{ - return get_crc_table(); -} - void CZipArchive::CryptDecodeBuffer(DWORD uCount) { if (CurrentFile()->IsEncrypted()) @@ -1354,28 +1951,623 @@ void CZipArchive::EmptyPtrList() if (m_list.GetCount()) { // if some memory hasn't been freed due to an error in zlib, so free it now - POSITION pos = m_list.GetHeadPosition(); - while (pos) - delete[] m_list.GetNext(pos); + CZipPtrListIter iter = m_list.GetHeadPosition(); + while (m_list.IteratorValid(iter)) + delete[] (char*) m_list.GetNext(iter); } - + m_list.RemoveAll(); } +void CZipArchive::SetFileHeaderAttr(CZipFileHeader& header, DWORD uAttr) +{ + header.SetSystemCompatibility(m_iArchiveSystCompatib); + header.SetSystemAttr(uAttr); +} + void CZipArchive::EnableFindFast(bool bEnable) { if (IsClosed()) { - TRACE(_T("Set it after opening the archive")); + TRACE(_T("%s(%i) : Set it after opening the archive.\n"),__FILE__,__LINE__); + return; + } + m_centralDir.EnableFindFast(bEnable, m_bCaseSensitive); + +} + +bool CZipArchive::SetSystemCompatibility(int iSystemComp) +{ + if (IsClosed()) + { + TRACE(_T("%s(%i) : Set it after opening the archive.\n"),__FILE__,__LINE__); + return false; + } + + if (m_iFileOpened == compress) + { + TRACE(_T("%s(%i) : Set it before opening a file inside archive.\n"),__FILE__,__LINE__); + return false; + } + + if (!ZipCompatibility::IsPlatformSupported(iSystemComp)) + return false; + m_iArchiveSystCompatib = iSystemComp; + return true; +} + +void CZipArchive::SetRootPath(LPCTSTR szPath) +{ + if (IsClosed()) + { + TRACE(_T("%s(%i) : Set it after opening the archive.\n"),__FILE__,__LINE__); return; } - if (m_centralDir.m_bFindFastEnabled == bEnable) + if (m_iFileOpened != nothing) + { + TRACE(_T("%s(%i) : Set it before opening a file inside archive.\n"),__FILE__,__LINE__); return; - m_centralDir.m_bFindFastEnabled = bEnable; - if (bEnable) - m_centralDir.BuildFindFastArray(); + } + + if (szPath) + { + m_szRootPath = szPath; + CZipPathComponent::RemoveSeparators(m_szRootPath); + } else - m_centralDir.m_findarray.RemoveAll(); + m_szRootPath.Empty(); } + +CZipString CZipArchive::TrimRootPath(CZipPathComponent &zpc)const +{ + if (m_szRootPath.IsEmpty()) + return zpc.GetFileName(); + CZipString szPath = zpc.GetFullPath(); + return RemovePathBeginning(m_szRootPath, szPath, m_pZipCompare) ? szPath : zpc.GetFileName(); +} + +bool CZipArchive::RemovePathBeginning(LPCTSTR lpszBeginning, CZipString& szPath, ZIPSTRINGCOMPARE pCompareFunction) +{ + CZipString szBeginning(lpszBeginning); + CZipPathComponent::RemoveSeparators(szBeginning); + int iRootPathLength = szBeginning.GetLength(); + if (iRootPathLength && szPath.GetLength() >= iRootPathLength && + (szPath.Left(iRootPathLength).*pCompareFunction)(szBeginning) == 0) + { + // the beginning is the same + if (szPath.GetLength() == iRootPathLength) + { + szPath.Empty(); + return true; + } + // is the end of m_szPathRoot only a beginning of a directory name? + // check for a separator + // we know the length is larger, so we can write: + if (CZipPathComponent::IsSeparator(szPath[iRootPathLength])) + { + szPath = szPath.Mid(iRootPathLength); + CZipPathComponent::RemoveSeparatorsLeft(szPath); + return true; + } + } + return false; +} + +void CZipArchive::SetTempPath(LPCTSTR lpszPath, bool bForce) +{ + m_szTempPath = lpszPath; + if (lpszPath && bForce) + ZipPlatform::ForceDirectory(lpszPath); + CZipPathComponent::RemoveSeparators(m_szTempPath); +} + +CZipString CZipArchive::PredictFileNameInZip(LPCTSTR lpszFilePath, + bool bFullPath, int iWhat, bool bAnsiOEM)const +{ + CZipString sz = lpszFilePath; + if (sz.IsEmpty()) + return _T(""); + bool bAppend; + switch (iWhat) + { + case prFile: + bAppend = false; + break; + case prDir: + bAppend = true; + break; + default: + bAppend = CZipPathComponent::IsSeparator(sz[sz.GetLength() - 1]); + } + + // remove for CZipPathComponent treating last name as a file even if dir + CZipPathComponent::RemoveSeparators(sz); + CZipPathComponent zpc(sz); + sz = bFullPath ? zpc.GetNoDrive() : TrimRootPath(zpc); + sz.Replace(_T('\\'), _T('/')); + if (bAppend && !sz.IsEmpty()) + sz += _T('/'); + if (bAnsiOEM) + { + CZipFileHeader fh; // create a temporary object to convert the CZipString to CZipAutoBuffer + fh.SetFileName(sz); + ZipPlatform::AnsiOem(fh.m_pszFileName, true); + return fh.GetFileName(); + } + else + return sz; +} + +CZipString CZipArchive::PredictExtractedFileName(LPCTSTR lpszFileNameInZip, LPCTSTR lpszPath, bool bFullPath, LPCTSTR lpszNewName)const +{ + CZipString szFile = lpszPath; + CZipString sz = lpszNewName ? lpszNewName : lpszFileNameInZip; + if (sz.IsEmpty()) + return szFile; + if (!szFile.IsEmpty()) + CZipPathComponent::AppendSeparator(szFile); + + + // remove for CZipPathComponent treating last name as a file even if dir + CZipPathComponent::RemoveSeparators(sz); + CZipPathComponent zpc(sz); + szFile += bFullPath ? zpc.GetNoDrive() : TrimRootPath(zpc); + return szFile; +} + + +void CZipArchive::SetAutoFlush(bool bAutoFlush) +{ + if (IsClosed()) + { + TRACE(_T("%s(%i) : ZipArchive not yet opened.\n"),__FILE__,__LINE__); + return; + } + if (m_storage.IsSpanMode() != 0) + { + TRACE(_T("%s(%i) : Cannot set auto-flush for the disk spanning archive.\n"),__FILE__,__LINE__); + return; + } + m_bAutoFlush = bAutoFlush; +} + +void CZipArchive::Flush() +{ + if (IsClosed()) + { + TRACE(_T("%s(%i) : ZipArchive not yet opened.\n"),__FILE__,__LINE__); + return; + } + + if (m_storage.IsSpanMode() < 0) + { + TRACE(_T("%s(%i) : Cannot flush an existing disk spanning archive.\n"),__FILE__,__LINE__); + return; + } + WriteCentralDirectory(); + m_storage.FlushFile(); + if (m_storage.IsSpanMode() > 0) // try to finalize disk-spanning archive without closing it + m_storage.FinalizeSpan(); +} + + +void CZipArchive::GetCentralDirInfo(CZipCentralDir::Info& info)const +{ + if (IsClosed()) + { + TRACE(_T("%s(%i) : ZipArchive not yet opened.\n"),__FILE__,__LINE__); + return; + + } + m_centralDir.GetInfo(info); + if (GetSpanMode() > 0) + info.m_uDiskEntriesNo = m_storage.GetCurrentDisk(); +} + +bool CZipArchive::CWildcard::IsPatternValid(LPCTSTR lpszPattern, int* iErrorType) +{ + try + { + /* loop through pattern to EOS */ + while (*lpszPattern) + { + /* determine pattern type */ + switch (*lpszPattern) + { + /* check literal escape, it cannot be at end of pattern */ + case _T('\\'): + if (!*++lpszPattern) + throw patternEsc; + lpszPattern++; + break; + + /* the [..] construct must be well formed */ + case _T('['): + lpszPattern++; + + /* if the next character is ']' then bad pattern */ + if (*lpszPattern == _T(']')) + throw patternEmpty; + + /* if end of pattern here then bad pattern */ + if (!*lpszPattern) + throw patternClose; + + /* loop to end of [..] construct */ + while (*lpszPattern != _T(']')) + { + /* check for literal escape */ + if (*lpszPattern == _T('\\')) + { + lpszPattern++; + + /* if end of pattern here then bad pattern */ + if (!*lpszPattern++) + throw patternEsc; + } + else lpszPattern++; + + /* if end of pattern here then bad pattern */ + if (!*lpszPattern) + throw patternClose; + + /* if this a range */ + if (*lpszPattern == _T('-')) + { + /* we must have an end of range */ + if (!*++lpszPattern || *lpszPattern == ']') + throw patternRange; + else + { + + /* check for literal escape */ + if (*lpszPattern == _T('\\')) + lpszPattern++; + + /* if end of pattern here + then bad pattern */ + if (!*lpszPattern++) + throw patternEsc; + } + } + } + break; + + /* all other characters are valid pattern elements */ + case '*': + case '?': + default: + lpszPattern++; /* "normal" character */ + break; + } + } + throw patternValid; + } + catch (int i) + { + if (iErrorType) + *iErrorType = i; + return i == patternValid; + } + + +} + +bool CZipArchive::CWildcard::IsPattern(LPCTSTR lpszPattern) +{ + while (*lpszPattern) + { + switch (*lpszPattern++) + { + case _T('?'): + case _T('*'): + case _T('['): + case _T('\\'): + return true; + } + } + return false; + +} + +bool CZipArchive::CWildcard::IsMatch(LPCTSTR lpszText, int *iRetCode) +{ + CZipString sz; + if (!m_bCaseSensitive) + { + sz = lpszText; + sz.MakeLower(); + lpszText = (LPCTSTR)sz; + } + int i = Match((LPCTSTR)m_szPattern, lpszText); + if (iRetCode) + *iRetCode = i; + return i == matchValid; +} + +int CZipArchive::CWildcard::MatchAfterStar(LPCTSTR p, LPCTSTR t) +{ + int iMatch = matchNone; + TCHAR nextp; + + /* pass over existing ? and * in pattern */ + + while ( *p == _T('?') || *p == _T('*') ) + { + /* take one char for each ? and + */ + + if (*p == _T('?')) + { + /* if end of text then no match */ + if (!*t++) + return matchAbort; + } + + /* move to next char in pattern */ + + p++; + } + + /* if end of pattern we have matched regardless of text left */ + + if (!*p) + return matchValid; + + /* get the next character to match which must be a literal or '[' */ + + nextp = *p; + if (nextp == _T('\\')) + { + nextp = p[1]; + + /* if end of text then we have a bad pattern */ + + if (!nextp) + return matchPattern; + } + + /* Continue until we run out of text or definite result seen */ + + do + { + /* a precondition for matching is that the next character + in the pattern match the next character in the text or that + the next pattern char is the beginning of a range. Increment + text pointer as we go here */ + + if (nextp == *t || nextp == _T('[')) + iMatch = Match(p, t); + + /* if the end of text is reached then no iMatch */ + + if (!*t++) + iMatch = matchAbort; + + } while ( iMatch != matchValid && + iMatch != matchAbort && + iMatch != matchPattern); + + /* return result */ + + return iMatch; +} + + +int CZipArchive::CWildcard::Match(LPCTSTR lpszPattern, LPCTSTR lpszText) +{ + + TCHAR range_start, range_end; /* start and end in range */ + + bool bInvert; /* is this [..] or [!..] */ + bool bMemberMatch; /* have I matched the [..] construct? */ + bool bLoop; /* should I terminate? */ + + for ( ; *lpszPattern; lpszPattern++, lpszText++) + { + /* if this is the end of the text + then this is the end of the match */ + + if (!*lpszText) + { + if ( *lpszPattern == _T('*') && *++lpszPattern == _T('\0') ) + return matchValid; + else + return matchAbort; + } + + /* determine and react to pattern type */ + + switch (*lpszPattern) + { + case _T('?'): /* single any character match */ + break; + + case _T('*'): /* multiple any character match */ + return MatchAfterStar (lpszPattern, lpszText); + + /* [..] construct, single member/exclusion character match */ + case _T('['): + { + /* move to beginning of range */ + + lpszPattern++; + + /* check if this is a member match or exclusion match */ + + bInvert = false; + if (*lpszPattern == _T('!') || *lpszPattern == _T('^')) + { + bInvert = true; + lpszPattern++; + } + + /* if closing bracket here or at range start then we have a + malformed pattern */ + + if (*lpszPattern == _T(']')) + return matchPattern; + + bMemberMatch = false; + bLoop = true; + + while (bLoop) + { + /* if end of construct then bLoop is done */ + + if (*lpszPattern == _T(']')) + { + bLoop = false; + continue; + } + + /* matching a '!', '^', '-', '\' or a ']' */ + + if (*lpszPattern == _T('\\')) + range_start = range_end = *++lpszPattern; + else + range_start = range_end = *lpszPattern; + + /* if end of pattern then bad pattern (Missing ']') */ + + if (!*lpszPattern) + return matchPattern; + + /* check for range bar */ + if (*++lpszPattern == _T('-')) + { + /* get the range end */ + + range_end = *++lpszPattern; + + /* if end of pattern or construct + then bad pattern */ + + if (range_end == _T('\0') || range_end == _T(']')) + return matchPattern; + /* special character range end */ + if (range_end == _T('\\')) + { + range_end = *++lpszPattern; + + /* if end of text then + we have a bad pattern */ + if (!range_end) + return matchPattern; + } + + /* move just beyond this range */ + lpszPattern++; + } + + /* if the text character is in range then match found. + make sure the range letters have the proper + relationship to one another before comparison */ + + if (range_start < range_end) + { + if (*lpszText >= range_start && *lpszText <= range_end) + { + bMemberMatch = true; + bLoop = false; + } + } + else + { + if (*lpszText >= range_end && *lpszText <= range_start) + { + bMemberMatch = true; + bLoop = false; + } + } + } + + /* if there was a match in an exclusion set then no match */ + /* if there was no match in a member set then no match */ + + if ((bInvert && bMemberMatch) || !(bInvert || bMemberMatch)) + return matchRange; + + /* if this is not an exclusion then skip the rest of + the [...] construct that already matched. */ + + if (bMemberMatch) + { + while (*lpszPattern != _T(']')) + { + /* bad pattern (Missing ']') */ + if (!*lpszPattern) + return matchPattern; + + /* skip exact match */ + if (*lpszPattern == _T('\\')) + { + lpszPattern++; + + /* if end of text then + we have a bad pattern */ + + if (!*lpszPattern) + return matchPattern; + } + + /* move to next pattern char */ + + lpszPattern++; + } + } + break; + } + case _T('\\'): /* next character is quoted and must match exactly */ + + /* move pattern pointer to quoted char and fall through */ + + lpszPattern++; + + /* if end of text then we have a bad pattern */ + + if (!*lpszPattern) + return matchPattern; + + /* must match this character exactly */ + + default: + if (*lpszPattern != *lpszText) + return matchPattern; + } + } + /* if end of text not reached then the pattern fails */ + + if (*lpszText) + return matchEnd; + else + return matchValid; +} + +void CZipArchive::FindMatches(LPCTSTR lpszPattern, CZipWordArray &ar, bool bFullPath) const +{ + if (IsClosed()) + { + TRACE(_T("%s(%i) : ZipArchive is closed.\n"),__FILE__,__LINE__); + return; + } + + // ar.RemoveAll(); don't do this + int iCount = GetCount(); + CWildcard wc(lpszPattern, m_bCaseSensitive); + for (int i = 0; i < iCount; i++) + { + const CZipFileHeader* pHeader = m_centralDir[i]; + CZipString sz = m_centralDir.GetProperHeaderFileName(pHeader); + if (!bFullPath) + { + CZipPathComponent::RemoveSeparators(sz); + CZipPathComponent zpc(sz); + sz = zpc.GetFileName(); + } + if (wc.IsMatch(sz)) + ar.Add(i); + } +} + \ No newline at end of file diff --git a/stepmania/src/smpackage/ZipArchive/ZipArchive.dox b/stepmania/src/smpackage/ZipArchive/ZipArchive.dox new file mode 100644 index 0000000000..285ef4fff1 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/ZipArchive.dox @@ -0,0 +1,913 @@ +# Doxyfile 1.2.13.1 + +# This file describes the settings to be used by the documentation system +# doxygen (www.doxygen.org) for a project +# +# All text after a hash (#) is considered a comment and will be ignored +# The format is: +# TAG = value [value, ...] +# For lists items can also be appended using: +# TAG += value [value, ...] +# Values that contain spaces should be placed between quotes (" ") + +#--------------------------------------------------------------------------- +# General configuration options +#--------------------------------------------------------------------------- + +# The PROJECT_NAME tag is a single word (or a sequence of words surrounded +# by quotes) that should identify the project. + +PROJECT_NAME = ZipArchive + +# The PROJECT_NUMBER tag can be used to enter a project or revision number. +# This could be handy for archiving the generated documentation or +# if some version control system is used. + +PROJECT_NUMBER = + +# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) +# base path where the generated documentation will be put. +# If a relative path is entered, it will be relative to the location +# where doxygen was started. If left blank the current directory will be used. + +OUTPUT_DIRECTORY = .\Doc + +# The OUTPUT_LANGUAGE tag is used to specify the language in which all +# documentation generated by doxygen is written. Doxygen will use this +# information to generate all constant output in the proper language. +# The default language is English, other supported languages are: +# Brazilian, Chinese, Croatian, Czech, Danish, Dutch, Finnish, French, +# German, Greek, Hungarian, Italian, Japanese, Korean, Norwegian, Polish, +# Portuguese, Romanian, Russian, Slovak, Slovene, Spanish and Swedish. + +OUTPUT_LANGUAGE = English + +# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in +# documentation are documented, even if no documentation was available. +# Private class members and static file members will be hidden unless +# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES + +EXTRACT_ALL = NO + +# If the EXTRACT_PRIVATE tag is set to YES all private members of a class +# will be included in the documentation. + +EXTRACT_PRIVATE = NO + +# If the EXTRACT_STATIC tag is set to YES all static members of a file +# will be included in the documentation. + +EXTRACT_STATIC = NO + +# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) +# defined locally in source files will be included in the documentation. +# If set to NO only classes defined in header files are included. + +EXTRACT_LOCAL_CLASSES = YES + +# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all +# undocumented members of documented classes, files or namespaces. +# If set to NO (the default) these members will be included in the +# various overviews, but no documentation section is generated. +# This option has no effect if EXTRACT_ALL is enabled. + +HIDE_UNDOC_MEMBERS = NO + +# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all +# undocumented classes that are normally visible in the class hierarchy. +# If set to NO (the default) these class will be included in the various +# overviews. This option has no effect if EXTRACT_ALL is enabled. + +HIDE_UNDOC_CLASSES = NO + +# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will +# include brief member descriptions after the members that are listed in +# the file and class documentation (similar to JavaDoc). +# Set to NO to disable this. + +BRIEF_MEMBER_DESC = YES + +# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend +# the brief description of a member or function before the detailed description. +# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the +# brief descriptions will be completely suppressed. + +REPEAT_BRIEF = YES + +# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then +# Doxygen will generate a detailed section even if there is only a brief +# description. + +ALWAYS_DETAILED_SEC = NO + +# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all inherited +# members of a class in the documentation of that class as if those members were +# ordinary class members. Constructors, destructors and assignment operators of +# the base classes will not be shown. + +INLINE_INHERITED_MEMB = NO + +# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full +# path before files name in the file list and in the header files. If set +# to NO the shortest path that makes the file name unique will be used. + +FULL_PATH_NAMES = NO + +# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag +# can be used to strip a user defined part of the path. Stripping is +# only done if one of the specified strings matches the left-hand part of +# the path. It is allowed to use relative paths in the argument list. + +STRIP_FROM_PATH = $(PWD)/ + +# The INTERNAL_DOCS tag determines if documentation +# that is typed after a \internal command is included. If the tag is set +# to NO (the default) then the documentation will be excluded. +# Set it to YES to include the internal documentation. + +INTERNAL_DOCS = NO + +# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct +# doxygen to hide any special comment blocks from generated source code +# fragments. Normal C and C++ comments will always remain visible. + +STRIP_CODE_COMMENTS = YES + +# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate +# file names in lower case letters. If set to YES upper case letters are also +# allowed. This is useful if you have classes or files whose names only differ +# in case and if your file system supports case sensitive file names. Windows +# users are adviced to set this option to NO. + +CASE_SENSE_NAMES = YES + +# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter +# (but less readable) file names. This can be useful is your file systems +# doesn't support long names like on DOS, Mac, or CD-ROM. + +SHORT_NAMES = NO + +# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen +# will show members with their full class and namespace scopes in the +# documentation. If set to YES the scope will be hidden. + +HIDE_SCOPE_NAMES = NO + +# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen +# will generate a verbatim copy of the header file for each class for +# which an include is specified. Set to NO to disable this. + +VERBATIM_HEADERS = YES + +# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen +# will put list of the files that are included by a file in the documentation +# of that file. + +SHOW_INCLUDE_FILES = YES + +# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen +# will interpret the first line (until the first dot) of a JavaDoc-style +# comment as the brief description. If set to NO, the JavaDoc +# comments will behave just like the Qt-style comments (thus requiring an +# explict @brief command for a brief description. + +JAVADOC_AUTOBRIEF = YES + +# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented +# member inherits the documentation from any documented member that it +# reimplements. + +INHERIT_DOCS = YES + +# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] +# is inserted in the documentation for inline members. + +INLINE_INFO = YES + +# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen +# will sort the (detailed) documentation of file and class members +# alphabetically by member name. If set to NO the members will appear in +# declaration order. + +SORT_MEMBER_DOCS = YES + +# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC +# tag is set to YES, then doxygen will reuse the documentation of the first +# member in the group (if any) for the other members of the group. By default +# all members of a group must be documented explicitly. + +DISTRIBUTE_GROUP_DOC = NO + +# The TAB_SIZE tag can be used to set the number of spaces in a tab. +# Doxygen uses this value to replace tabs by spaces in code fragments. + +TAB_SIZE = 8 + +# The GENERATE_TODOLIST tag can be used to enable (YES) or +# disable (NO) the todo list. This list is created by putting \todo +# commands in the documentation. + +GENERATE_TODOLIST = YES + +# The GENERATE_TESTLIST tag can be used to enable (YES) or +# disable (NO) the test list. This list is created by putting \test +# commands in the documentation. + +GENERATE_TESTLIST = YES + +# The GENERATE_BUGLIST tag can be used to enable (YES) or +# disable (NO) the bug list. This list is created by putting \bug +# commands in the documentation. + +GENERATE_BUGLIST = YES + +# This tag can be used to specify a number of aliases that acts +# as commands in the documentation. An alias has the form "name=value". +# For example adding "sideeffect=\par Side Effects:\n" will allow you to +# put the command \sideeffect (or @sideeffect) in the documentation, which +# will result in a user defined paragraph with heading "Side Effects:". +# You can put \n's in the value part of an alias to insert newlines. + +ALIASES = + +# The ENABLED_SECTIONS tag can be used to enable conditional +# documentation sections, marked by \if sectionname ... \endif. + +ENABLED_SECTIONS = YES + +# The MAX_INITIALIZER_LINES tag determines the maximum number of lines +# the initial value of a variable or define consist of for it to appear in +# the documentation. If the initializer consists of more lines than specified +# here it will be hidden. Use a value of 0 to hide initializers completely. +# The appearance of the initializer of individual variables and defines in the +# documentation can be controlled using \showinitializer or \hideinitializer +# command in the documentation regardless of this setting. + +MAX_INITIALIZER_LINES = 30 + +# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources +# only. Doxygen will then generate output that is more tailored for C. +# For instance some of the names that are used will be different. The list +# of all members will be omitted, etc. + +OPTIMIZE_OUTPUT_FOR_C = NO + +# Set the SHOW_USED_FILES tag to NO to disable the list of files generated +# at the bottom of the documentation of classes and structs. If set to YES the +# list will mention the files that were used to generate the documentation. + +SHOW_USED_FILES = YES + +#--------------------------------------------------------------------------- +# configuration options related to warning and progress messages +#--------------------------------------------------------------------------- + +# The QUIET tag can be used to turn on/off the messages that are generated +# by doxygen. Possible values are YES and NO. If left blank NO is used. + +QUIET = NO + +# The WARNINGS tag can be used to turn on/off the warning messages that are +# generated by doxygen. Possible values are YES and NO. If left blank +# NO is used. + +WARNINGS = YES + +# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings +# for undocumented members. If EXTRACT_ALL is set to YES then this flag will +# automatically be disabled. + +WARN_IF_UNDOCUMENTED = NO + +# The WARN_FORMAT tag determines the format of the warning messages that +# doxygen can produce. The string should contain the $file, $line, and $text +# tags, which will be replaced by the file and line number from which the +# warning originated and the warning text. + +WARN_FORMAT = "$file:$line: $text" + +# The WARN_LOGFILE tag can be used to specify a file to which warning +# and error messages should be written. If left blank the output is written +# to stderr. + +WARN_LOGFILE = + +#--------------------------------------------------------------------------- +# configuration options related to the input files +#--------------------------------------------------------------------------- + +# The INPUT tag can be used to specify the files and/or directories that contain +# documented source files. You may enter file names like "myfile.cpp" or +# directories like "/usr/src/myproject". Separate the files or directories +# with spaces. + +INPUT = .\ZipArchive.h \ + .\ZipAutoBuffer.h \ + .\ZipCentralDir.h \ + .\ZipCompatibility.h \ + .\ZipException.h \ + .\ZipFileHeader.h \ + .\ZipPlatform.h \ + .\ZipInternalInfo.h \ + .\ZipMemFile.h \ + .\ZipPathComponent.h \ + .\ZipStorage.h \ + .\changelog.txt \ + .\faq.txt \ + .\License.txt \ + .\gpl.txt \ + .\Readme.txt + +# If the value of the INPUT tag contains directories, you can use the +# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp +# and *.h) to filter out the source-files in the directories. If left +# blank the following patterns are tested: +# *.c *.cc *.cxx *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx *.hpp +# *.h++ *.idl + +FILE_PATTERNS = + +# The RECURSIVE tag can be used to turn specify whether or not subdirectories +# should be searched for input files as well. Possible values are YES and NO. +# If left blank NO is used. + +RECURSIVE = NO + +# The EXCLUDE tag can be used to specify files and/or directories that should +# excluded from the INPUT source files. This way you can easily exclude a +# subdirectory from a directory tree whose root is specified with the INPUT tag. + +EXCLUDE = + +# If the value of the INPUT tag contains directories, you can use the +# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude +# certain files from those directories. + +EXCLUDE_PATTERNS = + +# The EXAMPLE_PATH tag can be used to specify one or more files or +# directories that contain example code fragments that are included (see +# the \include command). + +EXAMPLE_PATH = + +# If the value of the EXAMPLE_PATH tag contains directories, you can use the +# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp +# and *.h) to filter out the source-files in the directories. If left +# blank all files are included. + +EXAMPLE_PATTERNS = + +# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be +# searched for input files to be used with the \include or \dontinclude +# commands irrespective of the value of the RECURSIVE tag. +# Possible values are YES and NO. If left blank NO is used. + +EXAMPLE_RECURSIVE = NO + +# The IMAGE_PATH tag can be used to specify one or more files or +# directories that contain image that are included in the documentation (see +# the \image command). + +IMAGE_PATH = + +# The INPUT_FILTER tag can be used to specify a program that doxygen should +# invoke to filter for each input file. Doxygen will invoke the filter program +# by executing (via popen()) the command , where +# is the value of the INPUT_FILTER tag, and is the name of an +# input file. Doxygen will then use the output that the filter program writes +# to standard output. + +INPUT_FILTER = + +# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using +# INPUT_FILTER) will be used to filter the input files when producing source +# files to browse. + +FILTER_SOURCE_FILES = NO + +#--------------------------------------------------------------------------- +# configuration options related to source browsing +#--------------------------------------------------------------------------- + +# If the SOURCE_BROWSER tag is set to YES then a list of source files will +# be generated. Documented entities will be cross-referenced with these sources. + +SOURCE_BROWSER = NO + +# Setting the INLINE_SOURCES tag to YES will include the body +# of functions and classes directly in the documentation. + +INLINE_SOURCES = NO + +# If the REFERENCED_BY_RELATION tag is set to YES (the default) +# then for each documented function all documented +# functions referencing it will be listed. + +REFERENCED_BY_RELATION = YES + +# If the REFERENCES_RELATION tag is set to YES (the default) +# then for each documented function all documented entities +# called/used by that function will be listed. + +REFERENCES_RELATION = YES + +#--------------------------------------------------------------------------- +# configuration options related to the alphabetical class index +#--------------------------------------------------------------------------- + +# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index +# of all compounds will be generated. Enable this if the project +# contains a lot of classes, structs, unions or interfaces. + +ALPHABETICAL_INDEX = YES + +# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then +# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns +# in which this list will be split (can be a number in the range [1..20]) + +COLS_IN_ALPHA_INDEX = 5 + +# In case all classes in a project start with a common prefix, all +# classes will be put under the same header in the alphabetical index. +# The IGNORE_PREFIX tag can be used to specify one or more prefixes that +# should be ignored while generating the index headers. + +IGNORE_PREFIX = + +#--------------------------------------------------------------------------- +# configuration options related to the HTML output +#--------------------------------------------------------------------------- + +# If the GENERATE_HTML tag is set to YES (the default) Doxygen will +# generate HTML output. + +GENERATE_HTML = YES + +# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `html' will be used as the default path. + +HTML_OUTPUT = . + +# The HTML_HEADER tag can be used to specify a personal HTML header for +# each generated HTML page. If it is left blank doxygen will generate a +# standard header. + +HTML_HEADER = "c:\Program Files\Doxygen\header.html" + +# The HTML_FOOTER tag can be used to specify a personal HTML footer for +# each generated HTML page. If it is left blank doxygen will generate a +# standard footer. + +HTML_FOOTER = "c:\Program Files\Doxygen\footer.html" + +# The HTML_STYLESHEET tag can be used to specify a user defined cascading +# style sheet that is used by each HTML page. It can be used to +# fine-tune the look of the HTML output. If the tag is left blank doxygen +# will generate a default style sheet + +HTML_STYLESHEET = + +# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, +# files or namespaces will be aligned in HTML using tables. If set to +# NO a bullet list will be used. + +HTML_ALIGN_MEMBERS = YES + +# If the GENERATE_HTMLHELP tag is set to YES, additional index files +# will be generated that can be used as input for tools like the +# Microsoft HTML help workshop to generate a compressed HTML help file (.chm) +# of the generated HTML documentation. + +GENERATE_HTMLHELP = YES + +# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag +# controls if a separate .chi index file is generated (YES) or that +# it should be included in the master .chm file (NO). + +GENERATE_CHI = YES + +# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag +# controls whether a binary table of contents is generated (YES) or a +# normal table of contents (NO) in the .chm file. + +BINARY_TOC = YES + +# The TOC_EXPAND flag can be set to YES to add extra items for group members +# to the contents of the Html help documentation and to the tree view. + +TOC_EXPAND = YES + +# The DISABLE_INDEX tag can be used to turn on/off the condensed index at +# top of each HTML page. The value NO (the default) enables the index and +# the value YES disables it. + +DISABLE_INDEX = NO + +# This tag can be used to set the number of enum values (range [1..20]) +# that doxygen will group on one line in the generated HTML documentation. + +ENUM_VALUES_PER_LINE = 4 + +# If the GENERATE_TREEVIEW tag is set to YES, a side panel will be +# generated containing a tree-like index structure (just like the one that +# is generated for HTML Help). For this to work a browser that supports +# JavaScript and frames is required (for instance Mozilla, Netscape 4.0+, +# or Internet explorer 4.0+). Note that for large projects the tree generation +# can take a very long time. In such cases it is better to disable this feature. +# Windows users are probably better off using the HTML help feature. + +GENERATE_TREEVIEW = NO + +# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be +# used to set the initial width (in pixels) of the frame in which the tree +# is shown. + +TREEVIEW_WIDTH = 250 + +#--------------------------------------------------------------------------- +# configuration options related to the LaTeX output +#--------------------------------------------------------------------------- + +# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will +# generate Latex output. + +GENERATE_LATEX = NO + +# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `latex' will be used as the default path. + +LATEX_OUTPUT = + +# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact +# LaTeX documents. This may be useful for small projects and may help to +# save some trees in general. + +COMPACT_LATEX = NO + +# The PAPER_TYPE tag can be used to set the paper type that is used +# by the printer. Possible values are: a4, a4wide, letter, legal and +# executive. If left blank a4wide will be used. + +PAPER_TYPE = a4wide + +# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX +# packages that should be included in the LaTeX output. + +EXTRA_PACKAGES = + +# The LATEX_HEADER tag can be used to specify a personal LaTeX header for +# the generated latex document. The header should contain everything until +# the first chapter. If it is left blank doxygen will generate a +# standard header. Notice: only use this tag if you know what you are doing! + +LATEX_HEADER = + +# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated +# is prepared for conversion to pdf (using ps2pdf). The pdf file will +# contain links (just like the HTML output) instead of page references +# This makes the output suitable for online browsing using a pdf viewer. + +PDF_HYPERLINKS = NO + +# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of +# plain latex in the generated Makefile. Set this option to YES to get a +# higher quality PDF documentation. + +USE_PDFLATEX = NO + +# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. +# command to the generated LaTeX files. This will instruct LaTeX to keep +# running if errors occur, instead of asking the user for help. +# This option is also used when generating formulas in HTML. + +LATEX_BATCHMODE = NO + +#--------------------------------------------------------------------------- +# configuration options related to the RTF output +#--------------------------------------------------------------------------- + +# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output +# The RTF output is optimised for Word 97 and may not look very pretty with +# other RTF readers or editors. + +GENERATE_RTF = NO + +# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `rtf' will be used as the default path. + +RTF_OUTPUT = + +# If the COMPACT_RTF tag is set to YES Doxygen generates more compact +# RTF documents. This may be useful for small projects and may help to +# save some trees in general. + +COMPACT_RTF = NO + +# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated +# will contain hyperlink fields. The RTF file will +# contain links (just like the HTML output) instead of page references. +# This makes the output suitable for online browsing using WORD or other +# programs which support those fields. +# Note: wordpad (write) and others do not support links. + +RTF_HYPERLINKS = NO + +# Load stylesheet definitions from file. Syntax is similar to doxygen's +# config file, i.e. a series of assigments. You only have to provide +# replacements, missing definitions are set to their default value. + +RTF_STYLESHEET_FILE = + +# Set optional variables used in the generation of an rtf document. +# Syntax is similar to doxygen's config file. + +RTF_EXTENSIONS_FILE = + +#--------------------------------------------------------------------------- +# configuration options related to the man page output +#--------------------------------------------------------------------------- + +# If the GENERATE_MAN tag is set to YES (the default) Doxygen will +# generate man pages + +GENERATE_MAN = NO + +# The MAN_OUTPUT tag is used to specify where the man pages will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `man' will be used as the default path. + +MAN_OUTPUT = + +# The MAN_EXTENSION tag determines the extension that is added to +# the generated man pages (default is the subroutine's section .3) + +MAN_EXTENSION = .3 + +# If the MAN_LINKS tag is set to YES and Doxygen generates man output, +# then it will generate one additional man file for each entity +# documented in the real man page(s). These additional files +# only source the real man page, but without them the man command +# would be unable to find the correct page. The default is NO. + +MAN_LINKS = NO + +#--------------------------------------------------------------------------- +# configuration options related to the XML output +#--------------------------------------------------------------------------- + +# If the GENERATE_XML tag is set to YES Doxygen will +# generate an XML file that captures the structure of +# the code including all documentation. Note that this +# feature is still experimental and incomplete at the +# moment. + +GENERATE_XML = NO + +#--------------------------------------------------------------------------- +# configuration options for the AutoGen Definitions output +#--------------------------------------------------------------------------- + +# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will +# generate an AutoGen Definitions (see autogen.sf.net) file +# that captures the structure of the code including all +# documentation. Note that this feature is still experimental +# and incomplete at the moment. + +GENERATE_AUTOGEN_DEF = NO + +#--------------------------------------------------------------------------- +# Configuration options related to the preprocessor +#--------------------------------------------------------------------------- + +# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will +# evaluate all C-preprocessor directives found in the sources and include +# files. + +ENABLE_PREPROCESSING = NO + +# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro +# names in the source code. If set to NO (the default) only conditional +# compilation will be performed. Macro expansion can be done in a controlled +# way by setting EXPAND_ONLY_PREDEF to YES. + +MACRO_EXPANSION = NO + +# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES +# then the macro expansion is limited to the macros specified with the +# PREDEFINED and EXPAND_AS_PREDEFINED tags. + +EXPAND_ONLY_PREDEF = YES + +# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files +# in the INCLUDE_PATH (see below) will be search if a #include is found. + +SEARCH_INCLUDES = YES + +# The INCLUDE_PATH tag can be used to specify one or more directories that +# contain include files that are not input files but should be processed by +# the preprocessor. + +INCLUDE_PATH = + +# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard +# patterns (like *.h and *.hpp) to filter out the header-files in the +# directories. If left blank, the patterns specified with FILE_PATTERNS will +# be used. + +INCLUDE_FILE_PATTERNS = + +# The PREDEFINED tag can be used to specify one or more macro names that +# are defined before the preprocessor is started (similar to the -D option of +# gcc). The argument of the tag is a list of macros of the form: name +# or name=definition (no spaces). If the definition and the = are +# omitted =1 is assumed. + +PREDEFINED = + +# If the MACRO_EXPANSION and EXPAND_PREDEF_ONLY tags are set to YES then +# this tag can be used to specify a list of macro names that should be expanded. +# The macro definition that is found in the sources will be used. +# Use the PREDEFINED tag if you want to use a different macro definition. + +EXPAND_AS_DEFINED = + +# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then +# doxygen's preprocessor will remove all function-like macros that are alone +# on a line and do not end with a semicolon. Such function macros are typically +# used for boiler-plate code, and will confuse the parser if not removed. + +SKIP_FUNCTION_MACROS = YES + +#--------------------------------------------------------------------------- +# Configuration::addtions related to external references +#--------------------------------------------------------------------------- + +# The TAGFILES tag can be used to specify one or more tagfiles. + +TAGFILES = + +# When a file name is specified after GENERATE_TAGFILE, doxygen will create +# a tag file that is based on the input files it reads. + +GENERATE_TAGFILE = NO + +# If the ALLEXTERNALS tag is set to YES all external classes will be listed +# in the class index. If set to NO only the inherited external classes +# will be listed. + +ALLEXTERNALS = YES + +# The PERL_PATH should be the absolute path and name of the perl script +# interpreter (i.e. the result of `which perl'). + +PERL_PATH = /usr/bin/perl + +#--------------------------------------------------------------------------- +# Configuration options related to the dot tool +#--------------------------------------------------------------------------- + +# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will +# generate a inheritance diagram (in Html, RTF and LaTeX) for classes with base or +# super classes. Setting the tag to NO turns the diagrams off. Note that this +# option is superceded by the HAVE_DOT option below. This is only a fallback. It is +# recommended to install and use dot, since it yield more powerful graphs. + +CLASS_DIAGRAMS = YES + +# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is +# available from the path. This tool is part of Graphviz, a graph visualization +# toolkit from AT&T and Lucent Bell Labs. The other options in this section +# have no effect if this option is set to NO (the default) + +HAVE_DOT = NO + +# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for each documented class showing the direct and +# indirect inheritance relations. Setting this tag to YES will force the +# the CLASS_DIAGRAMS tag to NO. + +CLASS_GRAPH = YES + +# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for each documented class showing the direct and +# indirect implementation dependencies (inheritance, containment, and +# class references variables) of the class with other documented classes. + +COLLABORATION_GRAPH = YES + +# If set to YES, the inheritance and collaboration graphs will show the +# relations between templates and their instances. + +TEMPLATE_RELATIONS = YES + +# If set to YES, the inheritance and collaboration graphs will hide +# inheritance and usage relations if the target is undocumented +# or is not a class. + +HIDE_UNDOC_RELATIONS = YES + +# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT +# tags are set to YES then doxygen will generate a graph for each documented +# file showing the direct and indirect include dependencies of the file with +# other documented files. + +INCLUDE_GRAPH = YES + +# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and +# HAVE_DOT tags are set to YES then doxygen will generate a graph for each +# documented header file showing the documented files that directly or +# indirectly include this file. + +INCLUDED_BY_GRAPH = NO + +# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen +# will graphical hierarchy of all classes instead of a textual one. + +GRAPHICAL_HIERARCHY = YES + +# The tag DOT_PATH can be used to specify the path where the dot tool can be +# found. If left blank, it is assumed the dot tool can be found on the path. + +DOT_PATH = + +# The DOTFILE_DIRS tag can be used to specify one or more directories that +# contain dot files that are included in the documentation (see the +# \dotfile command). + +DOTFILE_DIRS = + +# The MAX_DOT_GRAPH_WIDTH tag can be used to set the maximum allowed width +# (in pixels) of the graphs generated by dot. If a graph becomes larger than +# this value, doxygen will try to truncate the graph, so that it fits within +# the specified constraint. Beware that most browsers cannot cope with very +# large images. + +MAX_DOT_GRAPH_WIDTH = 1024 + +# The MAX_DOT_GRAPH_HEIGHT tag can be used to set the maximum allows height +# (in pixels) of the graphs generated by dot. If a graph becomes larger than +# this value, doxygen will try to truncate the graph, so that it fits within +# the specified constraint. Beware that most browsers cannot cope with very +# large images. + +MAX_DOT_GRAPH_HEIGHT = 1024 + +# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will +# generate a legend page explaining the meaning of the various boxes and +# arrows in the dot generated graphs. + +GENERATE_LEGEND = YES + +# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will +# remove the intermedate dot files that are used to generate +# the various graphs. + +DOT_CLEANUP = YES + +#--------------------------------------------------------------------------- +# Configuration::addtions related to the search engine +#--------------------------------------------------------------------------- + +# The SEARCHENGINE tag specifies whether or not a search engine should be +# used. If set to NO the values of all tags below this one will be ignored. + +SEARCHENGINE = NO + +# The CGI_NAME tag should be the name of the CGI script that +# starts the search engine (doxysearch) with the correct parameters. +# A script with this name will be generated by doxygen. + +CGI_NAME = search.cgi + +# The CGI_URL tag should be the absolute URL to the directory where the +# cgi binaries are located. See the documentation of your http daemon for +# details. + +CGI_URL = + +# The DOC_URL tag should be the absolute URL to the directory where the +# documentation is located. If left blank the absolute path to the +# documentation, with file:// prepended to it, will be used. + +DOC_URL = + +# The DOC_ABSPATH tag should be the absolute path to the directory where the +# documentation is located. If left blank the directory on the local machine +# will be used. + +DOC_ABSPATH = + +# The BIN_ABSPATH tag must point to the directory where the doxysearch binary +# is installed. + +BIN_ABSPATH = /usr/local/bin/ + +# The EXT_DOC_PATHS tag can be used to specify one or more paths to +# documentation generated for other projects. This allows doxysearch to search +# the documentation for these projects as well. + +EXT_DOC_PATHS = diff --git a/stepmania/src/smpackage/ZipArchive/ZipArchive.dsp b/stepmania/src/smpackage/ZipArchive/ZipArchive.dsp index a2cfd40326..c9288f830e 100644 --- a/stepmania/src/smpackage/ZipArchive/ZipArchive.dsp +++ b/stepmania/src/smpackage/ZipArchive/ZipArchive.dsp @@ -4,7 +4,7 @@ # TARGTYPE "Win32 (x86) Static Library" 0x0104 -CFG=ZipArchive - Win32 Unicode Debug +CFG=ZipArchive - Win32 Static Debug !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE @@ -13,7 +13,7 @@ CFG=ZipArchive - Win32 Unicode Debug !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE -!MESSAGE NMAKE /f "ZipArchive.mak" CFG="ZipArchive - Win32 Unicode Debug" +!MESSAGE NMAKE /f "ZipArchive.mak" CFG="ZipArchive - Win32 Static Debug" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE @@ -23,12 +23,13 @@ CFG=ZipArchive - Win32 Unicode Debug !MESSAGE "ZipArchive - Win32 Unicode Debug" (based on "Win32 (x86) Static Library") !MESSAGE "ZipArchive - Win32 Unicode Release" (based on "Win32 (x86) Static Library") !MESSAGE "ZipArchive - Win32 Unicode Static Release" (based on "Win32 (x86) Static Library") +!MESSAGE "ZipArchive - Win32 Static Debug" (based on "Win32 (x86) Static Library") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 -# PROP Scc_ProjName "" -# PROP Scc_LocalPath "" +# PROP Scc_ProjName "ZipArchive" +# PROP Scc_LocalPath "." CPP=cl.exe RSC=rc.exe @@ -45,9 +46,9 @@ RSC=rc.exe # PROP Intermediate_Dir "Release" # PROP Target_Dir "" # ADD BASE CPP /nologo /MD /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_AFXDLL" /Yu"stdafx.h" /FD /c -# ADD CPP /nologo /MD /W4 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "ZLIB_DLL" /D "_AFXDLL" /Yu"stdafx.h" /FD /c +# ADD CPP /nologo /MD /W3 /GX /O2 /D "NDEBUG" /D "_MBCS" /D "WIN32" /D "_WINDOWS" /D "ZLIB_DLL" /D "ZIP_ARCHIVE_MFC_PROJ" /D "_AFXDLL" /YX"stdafx.h" /FD /c # ADD BASE RSC /l 0x415 /d "NDEBUG" /d "_AFXDLL" -# ADD RSC /l 0x415 /d "NDEBUG" /d "_AFXDLL" +# ADD RSC /l 0x409 /d "NDEBUG" /d "_AFXDLL" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo @@ -68,9 +69,9 @@ LIB32=link.exe -lib # PROP Intermediate_Dir "Debug" # PROP Target_Dir "" # ADD BASE CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_AFXDLL" /Yu"stdafx.h" /FD /GZ /c -# ADD CPP /nologo /MDd /W4 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "ZLIB_DLL" /D "_AFXDLL" /Fr /Yu"stdafx.h" /FD /GZ /c +# ADD CPP /nologo /MDd /W4 /Gm /GX /ZI /Od /D "_DEBUG" /D "_AFXDLL" /D "_MBCS" /D "WIN32" /D "_WINDOWS" /D "ZLIB_DLL" /D "ZIP_ARCHIVE_MFC_PROJ" /Fr /YX"stdafx.h" /FD /GZ /c # ADD BASE RSC /l 0x415 /d "_DEBUG" /d "_AFXDLL" -# ADD RSC /l 0x415 /d "_DEBUG" /d "_AFXDLL" +# ADD RSC /l 0x409 /d "_DEBUG" /d "_AFXDLL" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo @@ -91,9 +92,9 @@ LIB32=link.exe -lib # PROP Intermediate_Dir "Static_Release" # PROP Target_Dir "" # ADD BASE CPP /nologo /MD /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "ZLIB_DLL" /D "_AFXDLL" /Yu"stdafx.h" /FD /c -# ADD CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "ZLIB_DLL" /Yu"stdafx.h" /FD /c +# ADD CPP /nologo /MT /W3 /GX /O2 /D "NDEBUG" /D "_MBCS" /D "WIN32" /D "_WINDOWS" /D "ZLIB_DLL" /D "ZIP_ARCHIVE_MFC_PROJ" /YX"stdafx.h" /FD /c # ADD BASE RSC /l 0x415 /d "NDEBUG" /d "_AFXDLL" -# ADD RSC /l 0x415 /d "NDEBUG" +# ADD RSC /l 0x409 /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo @@ -114,9 +115,9 @@ LIB32=link.exe -lib # PROP Intermediate_Dir "Unicode_Debug" # PROP Target_Dir "" # ADD BASE CPP /nologo /MDd /W4 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_AFXDLL" /D "_MBCS" /D "ZLIB_DLL" /Fr /Yu"stdafx.h" /FD /GZ /c -# ADD CPP /nologo /MDd /W4 /Gm /GX /ZI /Od /D "ZLIB_DLL" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_AFXDLL" /D "_MBCS" /D "_UNICODE" /Fr /Yu"stdafx.h" /FD /GZ /c +# ADD CPP /nologo /MDd /W4 /Gm /GX /ZI /Od /D "_DEBUG" /D "_AFXDLL" /D "_UNICODE" /D "WIN32" /D "_WINDOWS" /D "ZLIB_DLL" /D "ZIP_ARCHIVE_MFC_PROJ" /Fr /YX"stdafx.h" /FD /GZ /c # ADD BASE RSC /l 0x415 /d "_DEBUG" /d "_AFXDLL" -# ADD RSC /l 0x415 /d "_DEBUG" /d "_AFXDLL" +# ADD RSC /l 0x409 /d "_DEBUG" /d "_AFXDLL" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo @@ -137,9 +138,9 @@ LIB32=link.exe -lib # PROP Intermediate_Dir "Unicode_Release" # PROP Target_Dir "" # ADD BASE CPP /nologo /MD /W4 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "ZLIB_DLL" /D "_AFXDLL" /Yu"stdafx.h" /FD /c -# ADD CPP /nologo /MD /W4 /GX /O2 /D "ZLIB_DLL" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_AFXDLL" /D "_UNICODE" /Yu"stdafx.h" /FD /c +# ADD CPP /nologo /MD /W4 /GX /O2 /D "NDEBUG" /D "_AFXDLL" /D "_UNICODE" /D "WIN32" /D "_WINDOWS" /D "ZLIB_DLL" /D "ZIP_ARCHIVE_MFC_PROJ" /YX"stdafx.h" /FD /c # ADD BASE RSC /l 0x415 /d "NDEBUG" /d "_AFXDLL" -# ADD RSC /l 0x415 /d "NDEBUG" /d "_AFXDLL" +# ADD RSC /l 0x409 /d "NDEBUG" /d "_AFXDLL" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo @@ -160,9 +161,32 @@ LIB32=link.exe -lib # PROP Intermediate_Dir "Unicode_Static_Release" # PROP Target_Dir "" # ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "ZLIB_DLL" /Yu"stdafx.h" /FD /c -# ADD CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "ZLIB_DLL" /D "_UNICODE" /Yu"stdafx.h" /FD /c +# ADD CPP /nologo /MT /W3 /GX /O2 /D "NDEBUG" /D "_UNICODE" /D "WIN32" /D "_WINDOWS" /D "ZLIB_DLL" /D "ZIP_ARCHIVE_MFC_PROJ" /YX"stdafx.h" /FD /c # ADD BASE RSC /l 0x415 /d "NDEBUG" -# ADD RSC /l 0x415 /d "NDEBUG" +# ADD RSC /l 0x409 /d "NDEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LIB32=link.exe -lib +# ADD BASE LIB32 /nologo +# ADD LIB32 /nologo + +!ELSEIF "$(CFG)" == "ZipArchive - Win32 Static Debug" + +# PROP BASE Use_MFC 2 +# PROP BASE Use_Debug_Libraries 1 +# PROP BASE Output_Dir "ZipArchive___Win32_Static_Debug" +# PROP BASE Intermediate_Dir "ZipArchive___Win32_Static_Debug" +# PROP BASE Target_Dir "" +# PROP Use_MFC 1 +# PROP Use_Debug_Libraries 1 +# PROP Output_Dir "Static_Debug" +# PROP Intermediate_Dir "Static_Debug" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /MDd /W4 /Gm /GX /ZI /Od /D "_DEBUG" /D "_AFXDLL" /D "_MBCS" /D "WIN32" /D "_WINDOWS" /D "ZLIB_DLL" /D "ZIP_ARCHIVE_MFC_PROJ" /Fr /YX"stdafx.h" /FD /GZ /c +# ADD CPP /nologo /MTd /W4 /Gm /GX /ZI /Od /D "_DEBUG" /D "_MBCS" /D "WIN32" /D "_WINDOWS" /D "ZLIB_DLL" /D "ZIP_ARCHIVE_MFC_PROJ" /D "NDEBUG" /Fr /YX"stdafx.h" /FD /GZ /c +# ADD BASE RSC /l 0x415 /d "_DEBUG" /d "_AFXDLL" +# ADD RSC /l 0x409 /d "_DEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo @@ -180,12 +204,77 @@ LIB32=link.exe -lib # Name "ZipArchive - Win32 Unicode Debug" # Name "ZipArchive - Win32 Unicode Release" # Name "ZipArchive - Win32 Unicode Static Release" +# Name "ZipArchive - Win32 Static Debug" # Begin Group "Source Files" # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" +# Begin Group "zlib_c" + +# PROP Default_Filter "" # Begin Source File -SOURCE=.\StdAfx.cpp +SOURCE=.\zlib\adler32.c +# End Source File +# Begin Source File + +SOURCE=.\zlib\compress.c +# End Source File +# Begin Source File + +SOURCE=.\zlib\crc32.c +# End Source File +# Begin Source File + +SOURCE=.\zlib\deflate.c +# End Source File +# Begin Source File + +SOURCE=.\zlib\gvmat32c.c +# End Source File +# Begin Source File + +SOURCE=.\zlib\infblock.c +# End Source File +# Begin Source File + +SOURCE=.\zlib\infcodes.c +# End Source File +# Begin Source File + +SOURCE=.\zlib\inffast.c +# End Source File +# Begin Source File + +SOURCE=.\zlib\inflate.c +# End Source File +# Begin Source File + +SOURCE=.\zlib\inftrees.c +# End Source File +# Begin Source File + +SOURCE=.\zlib\infutil.c +# End Source File +# Begin Source File + +SOURCE=.\zlib\maketree.c +# End Source File +# Begin Source File + +SOURCE=.\zlib\trees.c +# End Source File +# Begin Source File + +SOURCE=.\zlib\uncompr.c +# End Source File +# Begin Source File + +SOURCE=.\zlib\zutil.c +# End Source File +# End Group +# Begin Source File + +SOURCE=.\stdafx.cpp # ADD CPP /Yc"stdafx.h" # End Source File # Begin Source File @@ -198,18 +287,22 @@ SOURCE=.\ZipAutoBuffer.cpp # End Source File # Begin Source File -SOURCE=.\ZipBigFile.cpp -# End Source File -# Begin Source File - SOURCE=.\ZipCentralDir.cpp # End Source File # Begin Source File +SOURCE=.\ZipCompatibility.cpp +# End Source File +# Begin Source File + SOURCE=.\ZipException.cpp # End Source File # Begin Source File +SOURCE=.\ZipFile.cpp +# End Source File +# Begin Source File + SOURCE=.\ZipFileHeader.cpp # End Source File # Begin Source File @@ -218,19 +311,87 @@ SOURCE=.\ZipInternalInfo.cpp # End Source File # Begin Source File +SOURCE=.\ZipMemFile.cpp +# End Source File +# Begin Source File + +SOURCE=.\ZipPathComponent.cpp +# End Source File +# Begin Source File + +SOURCE=.\ZipPlatform.cpp +# End Source File +# Begin Source File + +SOURCE=.\ZipPlatformComm.cpp +# End Source File +# Begin Source File + SOURCE=.\ZipStorage.cpp # End Source File +# Begin Source File + +SOURCE=.\ZipString.cpp +# End Source File # End Group # Begin Group "Header Files" # PROP Default_Filter "h;hpp;hxx;hm;inl" +# Begin Group "zlib_h" + +# PROP Default_Filter "" # Begin Source File -SOURCE=.\StdAfx.h +SOURCE=.\zlib\deflate.h # End Source File # Begin Source File -SOURCE=.\zconf.h +SOURCE=.\zlib\infblock.h +# End Source File +# Begin Source File + +SOURCE=.\zlib\infcodes.h +# End Source File +# Begin Source File + +SOURCE=.\zlib\inffast.h +# End Source File +# Begin Source File + +SOURCE=.\zlib\inffixed.h +# End Source File +# Begin Source File + +SOURCE=.\zlib\inftrees.h +# End Source File +# Begin Source File + +SOURCE=.\zlib\infutil.h +# End Source File +# Begin Source File + +SOURCE=.\zlib\trees.h +# End Source File +# Begin Source File + +SOURCE=.\zlib\zconf.h +# End Source File +# Begin Source File + +SOURCE=.\zlib\zlib.h +# End Source File +# Begin Source File + +SOURCE=.\zlib\zutil.h +# End Source File +# End Group +# Begin Source File + +SOURCE=.\stdafx.h +# End Source File +# Begin Source File + +SOURCE=.\ZipAbstractFile.h # End Source File # Begin Source File @@ -242,7 +403,7 @@ SOURCE=.\ZipAutoBuffer.h # End Source File # Begin Source File -SOURCE=.\ZipBigFile.h +SOURCE=.\ZipBaseException.h # End Source File # Begin Source File @@ -250,34 +411,86 @@ SOURCE=.\ZipCentralDir.h # End Source File # Begin Source File +SOURCE=.\ZipCollections.h +# End Source File +# Begin Source File + +SOURCE=.\ZipCompatibility.h +# End Source File +# Begin Source File + SOURCE=.\ZipException.h # End Source File # Begin Source File +SOURCE=.\ZipFile.h +# End Source File +# Begin Source File + SOURCE=.\ZipFileHeader.h # End Source File # Begin Source File +SOURCE=.\ZipFileMapping.h +# End Source File +# Begin Source File + SOURCE=.\ZipInternalInfo.h # End Source File # Begin Source File +SOURCE=.\ZipMemFile.h +# End Source File +# Begin Source File + +SOURCE=.\ZipPathComponent.h +# End Source File +# Begin Source File + +SOURCE=.\ZipPlatform.h +# End Source File +# Begin Source File + SOURCE=.\ZipStorage.h # End Source File +# Begin Source File + +SOURCE=.\ZipString.h +# End Source File # End Group +# Begin Group "Information" + +# PROP Default_Filter "txt" # Begin Source File SOURCE=.\Appnote.txt # End Source File # Begin Source File -SOURCE=.\zlib.lib +SOURCE=.\ChangeLog.txt # End Source File +# Begin Source File + +SOURCE=.\faq.txt +# End Source File +# Begin Source File + +SOURCE=.\gpl.txt +# End Source File +# Begin Source File + +SOURCE=.\License.txt +# End Source File +# Begin Source File + +SOURCE=.\Readme.txt +# End Source File +# End Group # End Target # End Project # Section ZipArchive : {427B9281-D5E8-11D3-B7C7-E75054E13747} # 2:12:AutoBuffer.h:AutoBuffer.h # 2:18:CLASS: CAutoBuffer:CAutoBuffer -# 2:19:Application Include:Zip.h +# 2:19:Application Include:ZipArchive.h # 2:14:AutoBuffer.cpp:AutoBuffer.cpp # End Section diff --git a/stepmania/src/smpackage/ZipArchive/ZipArchive.h b/stepmania/src/smpackage/ZipArchive/ZipArchive.h index 9f9eef92de..b719cf6636 100644 --- a/stepmania/src/smpackage/ZipArchive/ZipArchive.h +++ b/stepmania/src/smpackage/ZipArchive/ZipArchive.h @@ -1,405 +1,648 @@ -// ZipArchive.h: interface for the CZipArchive class. +/////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipArchive.h $ +// $Archive: /ZipArchive_STL/ZipArchive.h $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt // -////////////////////////////////////////////////////////////////////// -// ZipArchive 1.5.1, March 2001 -// -// -// This library allows to crate ZIP files in the compatible way with -// PKZIP version 2.6. Some important issues: -// - multiple disk spanning is supported -// - encyption is not supported -// - allows to create disk spanning archive also on non removable devices -// and with user-defined volume size -// - this library uses the zlib library by Jean-loup Gailly and Mark Adler -// to perform inflate, deflate operations -// -// -// -// Copyright (C) 2000 - 2001 Tadeusz Dracz -// -// -// Permission is granted to anyone to use this software for any purpose -// and to alter it and redistribute it freely, subject to the -// following restrictions: -// -// 1. Using this software in commercial applications requires an author permission. -// The permission will be granted to everyone excluding the cases when -// someone simply tries to resell the code. -// -// 2. The origin of this software must not be misrepresented; you must not -// claim that you wrote the original software. If you use this software -// in a product, an acknowledgment in the product documentation would be -// appreciated but is not required. -// -// 3. Altered source versions must be plainly marked as such, and must not be -// misrepresented as being the original software. -// -// 4. This notice may not be removed or altered from any source distribution. -// -// -// You can contact me at: -// tdracz@artpol.com.pl +// Check the site http://www.artpol-software.com for the updated version of the library. +//////////////////////////////////////////////////////////////////////////////// +// +// The following information files are distributed along with this library: +// License.txt - licensing information +// gpl.txt - General Public License text +// Readme.txt - general information +// ChangeLog.txt - revision history +// faq.txt - frequently asked questions +// Appnote.txt - details on the zip format +// ( also available at ftp://ftp.pkware.com/appnote.zip) // -// For new versions check the site: -// http://software.artpol.com.pl // -// History: -// 03.2001 -// -// - when the central directory was not located, the library throws CZipException::cdirNotFound, -// which allows distinguish from other exceptions (useful when we want to keep prompting -// the user to insert the last disk in a multi-disk spanning archive). -// -// -// 02.2001 -// Features added: -// - ability to reuse the archive after an exception thrown during extraction -// - added progress control possibilities to CZipArchive::AddNewFile, CZipArchive::ExtractFile, CZipArchive::TestFile -// Changes: -// - CZipArchive::FindFile operation boosted ( thanks to Darin Warling for the idea) -// - library name changed to ZipArchive -// Bugs fixed: -// - removed bug during extracting an encrypted file with 0 size -// - fixed bug when extracting a file with an extra field in a local file header (CZipFileHeader::ReadLocal) -// -// 01.2001 -// - Disk numbering in a disk spanning archive begins now from PKBACK# 001 not PKBACK# 000 -// - Adding and extracting without a full path possible in CZipArchive::AddNewFile and CZipArchive::ExtractFile. -// - Several minor changes and enhancements -// - Changed names for several classes. -// -// 11.2000 -// - Added support for password encryption and decryption. -// The encryption used in PKZIP was generously supplied by Roger -// Schlafly. -// - Testing the archive made easier -// - Unicode support added -// -// 08.2000 -// - Bugs fixed -// -// 06.2000 -// -// the code has been completely rewritten since the very beginning; -// the main improvements are: -// - multi-disk archive support -// - creation of the disk spanning archives with the user-defined volume size -// - ability to modify existing archives (add, delete files) -// - modification self-extracting archives -// - write buffer used for faster disk write operations -// - one class for zip and unzip functions -// - fast adding, deleting and extracting files with a single function call -// -// 03.2000 -// - international characters in filenames inside archive are now -// converted in a compatible way with other archiving programs (they are stored -// converted to OEM inside archive). -// -// 01.2000 -// -// first version; it is just modified code from zip.c and unzip.c files -// written by Gilles Vollant and distributed with zlib library; -// the modifications are as follows: -// - added class' wrappers -// - several bugs fixed -// - several enhancements added -// - MFC support added -// - memory leaks eliminated when write error occurred -// - automatically free used memory on destruction or exception -// - modern error notification using exceptions -// -// for more info about .ZIP format, see -// ftp://ftp.pkware.com/appnote.zip -// the unpacked file (appnote.txt) from this archive is a part of this project -// -// -// Note: -// if a file added to the archive is bigger after compressing -// (e.g. it is an other archive) it should be delted from the archive and -// added once again with store method (it may be done only on the files -// not divided between volumes) + +/** +* \file ZipArchive.h +* Interface for the CZipArchive class. +* +*/ #if !defined(AFX_ZIPARCHIVE_H__A7F528A6_1872_4071_BE66_D56CC2DDE0E6__INCLUDED_) #define AFX_ZIPARCHIVE_H__A7F528A6_1872_4071_BE66_D56CC2DDE0E6__INCLUDED_ -#include "ZipStorage.h" // Added by ClassView -#if _MSC_VER > 1000 -#pragma once -#endif // _MSC_VER > 1000 +/** + \namespace ziparchv + A helper namespace. + \par Members + - CZipFileMapping + +*/ + + + + +/** + \struct CZipFileMapping ZipFileMapping.h + + Maps a file to the memory. A system-specific implementation. + Stored in ziparchv namespace. + + \c #include "ZipFileMapping.h" +*/ + + +// to ensure that the correct files are copied +// (see "Compatibility" chapter in the documentation). +// Rebuild the project after copying the files. +#ifdef ZIP_ARCHIVE_MFC_PROJ + #ifndef ZIP_ARCHIVE_MFC + #error You need to copy files from the MFC subdirectory\ + to the ZipArchive root directory and rebuild the project + #endif +#elif defined ZIP_ARCHIVE_STL_PROJ + #ifndef ZIP_ARCHIVE_STL + #error You need to copy files from the STL subdirectory\ + to the ZipArchive root directory and rebuild the project + #endif +#endif // #include "ZipException.h" -#include "ZipCentralDir.h" // Added by ClassView -#include "ZipInternalInfo.h" // Added by ClassView +#include "ZipCentralDir.h" +#include "ZipStorage.h" +#include "ZipInternalInfo.h" +#include "ZipPathComponent.h" +#include "ZipString.h" -////////////////////////////////////////////////////////////////////////// -///////////////////// CZipArchive ///////////////////////////////////// +/** + The representation of the zip archive file. + This class provides all the operations on the zip archive. +*/ class CZipArchive { + public: - static int SingleToWide(CZipAutoBuffer &szSingle, CString& szWide); + + + CZipArchive(); + virtual ~CZipArchive(); + +/** + In non-UNICODE version just copy \e szSingle to \e szWide. + In UNICODE version works the same way as ZipPlatform::SingleToWide + \param szSingle + \param szWide + + \return (in non-UNICODE version the number of characters copied) + \see ZipPlatform::SingleToWide +*/ + static int SingleToWide(const CZipAutoBuffer &szSingle, CZipString& szWide); + +/** + In non-UNICODE version just copy \e lpWide to \e szSingle. + In UNICODE version works the same way as ZipPlatform::WideToSingle + \param lpWide + \param szSingle + \return (in non-UNICODE version the number of characters copied) + \see ZipPlatform::WideToSingle + +*/ static int WideToSingle(LPCTSTR lpWide, CZipAutoBuffer &szSingle); -// Function name : TestFile -// Description : Test the file with the given index -// the function throws CException*, but performs all the necessary cleanup -// before, so that the next file can be tested after catchig the exception -// and examining it for the reason of error. -// Return type : bool -// return false if the incorrect action has been taken by -// the user or the programmer (it is when OpenFile(WORD nIndex) or -// GetFileInfo(CZipFileHeader & fhInfo, WORD uIndex) return false or uBufSize -// is 0 -// Argument : WORD uIndex -// index of the file to test -// Argument : ZIPCALLBACKFUN pCallback = NULL -// See the description at AddNewFile -// Argument : void* pUserData = NULL -// Argument : DWORD uBufSize = 65535 -// the size of the buffer used during extraction - bool TestFile(WORD uIndex, ZIPCALLBACKFUN pCallback = NULL, void* pUserData = NULL, DWORD uBufSize = 65535); -// Function name : CloseFileAfterTestFailed -// Description : Perform the necessary cleanup after the exception -// while testing the archive so that next files in the archive can be tested -// Return type : void - void CloseFileAfterTestFailed(); +/** + Set the password for the file to be opened or created. + Use this method BEFORE opening or adding a file + \param lpszPassword + set it to NULL to clear password + \return \c false if the password contains ASCII characters + with values 128 or higher or the file inside archive is opened - -// Function name : SetPassword -// Description : set the password for the file that is going to be opened or created -// use this function BEFORE opening or adding a file -// Return type : bool -// return false if the password contains ASCII characters -// with values 128 or higher or the file inside archive is -// opened -// Argument : LPCTSTR lpszPassword = NULL -// set it to NULL to clear password +*/ bool SetPassword(LPCTSTR lpszPassword = NULL); -// Function name : SetAdvanced -// Description : set advanced options -// Return type : void -// Argument : int iWriteBuffer = 65535 -// buffer used during write operation to the disk, the bigger, the better; -// it is pointless, however, to set it bigger than the size of the volume; -// the optimal size is the size of the volume -// Argument : int iExtractBuffer = 16384 -// set the size of the buffer used in extracting and compressing files -// default 16384, must not be < 1024 -// set it before opening the archive -// Argument : int iSearchBuffer = 32768 -// set the size of the buffer used in searching for the central dir -// useful with big archives, default 32768, must not be < 1024 +/** + \return the current archive password or an empty string if there is no password +*/ + CZipString GetPassword()const ; + +/** + Set the buffer sizes. No buffer can be set smaller than 1024. + Use this method before opening the archive. The optimal size for + the write buffer in the disk spanning archive is the size of the volume. + + \param iWriteBuffer + buffer used during write operation to the disk + \see CZipStorage::m_iWriteBufferSize + \param iExtractBuffer + buffer used in extracting and compressing files + \see CZipInternalInfo::m_iBufferSize + \param iSearchBuffer + the buffer used in searching for the central dir + \see CZipCentralDir::m_iBufferSize +*/ void SetAdvanced(int iWriteBuffer = 65535, int iExtractBuffer = 16384, int iSearchBuffer = 32768); -// Function name : SetSpanCallback -// Description : set callback function used during operations on a -// pkzip compatible disk spanning archive to change disks; -// set it usualy before opening the archive for reading -// Return type : void -// Argument : ZIPCALLBACKFUN pFunc -// for the description of callback function see CZipStorage.h -// Argument : void* pData -// user data to be passed to the callback function as the last parameter - void SetSpanCallback(ZIPCALLBACKFUN pFunc, void* pData = NULL); + /** + Enum values used as \e iWhich parameter in #SetCallback function. + You can assign several values to the same functor (OR them) + \see CZipActionCallback + */ + enum CallbackType + { + cbNothing = 0x0000, ///< you can use it for your own purposes + cbAdd = 0x0001, ///< called when adding a file with one of #AddNewFile functions + cbAddTmp = 0x0002, ///< called while adding a file (only on a disk-spanning archive) when the smartness level contains CZipArchive::zipsmCheckForEff or CZipArchive::zipsmCheckForEffInMem + ///< and if just compressed file is being moved from a temporary place (file or memory) to the archive + cbAddStore = 0x0004, ///< called while adding a file and if it's compressing has proven to be inefficient and it is now being stored (instead of compressed) in the archive; + ///< smartness level must contain CZipArchive::zipsmCheckForEff or CZipArchive::zipsmCheckForEffInMem; the archive can be disk-spanning or not -// archive open modes - enum {open, openReadOnly, create, createSpan}; + cbExtract = 0x0008, ///< called when extracting a file with one of #ExtractFile functions -// Disk spanning archive modes: -// pkzip compatible mode (pkSpan): -// - only on removeble devices -// - autodetect the size of the volume -// - write a label to the disk -// - there is a need to set the span callback function -// TD mode (tdSpan): -// - may be created on non removable devices -// - uses user-defined volume size -// - no need to set the span callback function + cbDeleteCnt = 0x0010, ///< called before the actual deletion takes place and the map of holes and continuous areas is being created (it safe to break it by returning \c false from the callback method) + cbDelete = 0x0020, ///< called when moving data while deleting file(s) with function #DeleteFile or one of #DeleteFiles functions -// Function name : Open -// Description : Open a zip archive -// Return type : void -// Argument : LPCTSTR szPathName -// Path to the archive -// Argument : int iMode= CZipArchive::open; -// open mode flags: -// open open an existing archive -// openReadOnly open an existing archive as read only file -// (this mode is intended to use in self extract code) -// if you try to add or delete a file in this mode, an exception will be thrown -// create create a new archive -// createSpan create a disk spanning archive -// Argument : int iVolumeSize = 0 -// if iMode == createSpan and iVolumeSize <= 0 then create disk spanning -// archive in pkzip mode -// if iMode == createSpan and iVolumeSize > 0 then create disk spanning -// archive in TD mode -// if iMode == open and the exisitng archive is a spanned archive -// the pkSpan mode is assumed if the archive is on a removable device -// or tdSpan otherwise; -// if you want to open tdSpan archive on a removable device, set iVolumeSize -// to a value different from 0 -// if iMode == create this argument doesn't matter - void Open(LPCTSTR szPathName, int iMode = open, int iVolumeSize = 0); + cbTest = 0x0040, ///< called when testing a file with #TestFile function + cbSave = 0x0080, ///< called when saving the central directory with CZipCentralDir::Write (usually on close or flush); it is safe to break on non-disk spanning archive - the saved part of + ///< the central directory will be removed from disk -// Function name : Open -// Description : Open or create an archive in CMemFile -// Return type : void -// Argument : CMemFile& mf -// Argument : int iMode = open -// the following modes are valid: open, openReadOnly, create - void Open(CMemFile& mf, int iMode = open); + cbSubActions= cbAddTmp | cbAddStore | cbDeleteCnt, ///< sub actions - they are part of bigger actions (#cbAddTmp | #cbAddStore | #cbDeleteCnt) + cbActions = cbAdd | cbExtract | cbDelete | cbTest | cbSave, ///< main actions (#cbAdd | #cbExtract | #cbDelete | #cbTest | #cbSave) + cbAll = cbActions | cbSubActions ///< assign all callbacks to the same functor + }; -// Function name : AddNewFile -// Description : add quickly a new file to the archive -// Return type : bool -// Argument : LPCTSTR lpszFilePath -// file to be added -// Argument : int iLevel = Z_DEFAULT_COMPRESSION -// the compression level (see OpenNewFile() for detailed desciption) -// Argument : bool bFullPath -// if true, include full path of the file inside the archive -// Argument : ZIPCALLBACKFUN pCallback = NULL -// callback function (may be NULL) -// To set the callback function for this operation pass its pointer as the -// argument (do not use SetSpanCallback for it - its for different purposes). -// The callback function, if set, is called after reading and writing one portion of data. -// - the first argument (DWORD): -// total number of bytes to read (the size of the file) -// - the second one (int) : -// total number bytes already read -// - the third argument (void*): -// pUserData argument passed to #AddNewFile -// Argument : void* pUserData = NULL -// user - defined data passed on to the callback function -// (doesn't matter if there is no callback function defined) -// Argument : DWORD nBufSize = 65535 -// the size of the buffer used during compression + /** + + Set callback functors for the following operations on the zip archive: adding, extracting, testing or deleting files. + See \ref sectCallb information on how to use functors. + \param pCallback + the address of the functional object which class is derived from CZipActionCallback + (you need to override member function CZipCallback::Callback in the derived class) + Set it to \c NULL to clear callback for the selected actions. + \param iWhich + can be one or more (use logical OR) #CallbackType values. -/* + \see CZipActionCallback + + */ + void SetCallback(CZipActionCallback* pCallback = NULL, int iWhich = cbAll); + + /** + Set the callback functor used during operations on a + PKZIP compatible disk spanning archive to change disks. + Set it before opening the archive. If you open the archive + in the \ref PKSpan "PKZIP compatible mode" and don't set the callback functor, + the exception CZipException::noCallback will be thrown. + + Callback functor's method CZipSpanCallback::Callback is called when there is a need for a disk change. + Calling CZipArchive methods from inside this method may result in an unexpected behavior. + \param pCallback + the address of the functional object which class is derived from CZipSpanCallback + (you need to override member function CZipCallback::Callback in the derived class) + Set it to \c NULL to clear the callback. + + \see CZipSpanCallback + */ + void SetSpanCallback(CZipSpanCallback* pCallback = NULL){m_storage.m_pChangeDiskFunc = pCallback;} + + + + /** + Archive open modes used in #Open(LPCTSTR , int , int ) + and #Open(CZipMemFile, int ) + */ + enum OpenMode + { + zipOpen, ///< open an existing archive + /** + Open an existing archive as a read only file. + This mode is intended to use in a self extract code or opening + archive on storage without write access (e.g. CD-ROMS), + If you try to modify the archive in this mode, + an exception will be thrown. + */ + zipOpenReadOnly, + zipCreate, ///< create a new archive + zipCreateSpan ///< create a disk spanning archive + }; + + + +/** + Open or create a zip archive. + + The archive creation mode depends on \e iMode and \e iVolumesSize values: + - if \e iMode == #zipCreateSpan and \e iVolumeSize <= 0 then create disk spanning + archive in \ref PKSpan "PKZIP compatible mode" (pkzipSpan) + - if \e iMode == #zipCreateSpan and \e iVolumeSize > 0 then create disk spanning + archive in \ref TDSpan "TD compatible mode" (tdSpan) + - if \e iMode == #zipOpen and the existing archive is a spanned archive + then pkzipSpan mode is assumed if the archive is on a removable device + or tdSpan otherwise;
+ if you want to open tdSpan archive on a removable device, set \e iVolumeSize + to a value different from 0 + - if \e iMode == #zipCreate then \e iVolumeSize doesn't matter + + \param szPathName + the path to the archive + \param iMode + one of the #OpenMode values + \param iVolumeSize + the volume size in the disk spanning archive + \note Throws exceptions. + \see Open(CZipMemFile&, int); + \see GetSpanMode */ - bool AddNewFile(LPCTSTR lpszFilePath, int iLevel = -1, bool bFullPath = true, ZIPCALLBACKFUN pCallback = NULL, void* pUserData = NULL, unsigned long nBufSize = 65535); + void Open(LPCTSTR szPathName, int iMode = zipOpen, int iVolumeSize = 0); -// Function name : OpenNewFile -// Description : add a new file to the zip archive -// Return type : bool -// return false in the following cases: -// - the lpszFilePath is not NULL and the file attributes and data was not correctly retreived -// - a file is already opened for extraction or compression -// - archive is an existing disk span archive -// - maximum file count inside archive reached (65535) -// Argument : CZipFileHeader & header -// structure that have addtional information; the following fields are valid: -// - m_uMethod - file compression method; can be 0 (storing) or Z_DEFLATE (deflating) -// otherwise Z_DEFLATE is assumed -// - m_uModDate, m_uModTime - use SetTime method of CFileHeadeer to set them -// if lpszFilePath is not NULL this fields are updated automaticaly -// - m_uExternalAttr - attributes of the file -// if lpszFilePath is not NULL this field is updated automaticaly -// - m_szFileName - file name (may be with path) to be stored inside archive -// to represent this file -// - m_szComment - file comment -// - m_pExtraField - LOCAL extra field, use SetExtraField() after opening -// a new file, but before closing it to set the extra field -// in the header in the central directory -// other fields are ignored - they are updated automaticaly -// Argument : int iLevel = Z_DEFAULT_COMPRESSION -// the level of compression (-1, 0 - 9); named values: -// Z_DEFAULT_COMPRESSION : -1 -// Z_NO_COMPRESSION : 0 -// Z_BEST_SPEED : 1 -// Z_BEST_COMPRESSION : 9 -// Argument : LPCTSTR lpszFilePath = NULL -// the path to the file to retreive date and attributes from + +/** + Open or create the archive in memory. The CZipMemFile object is not closed + after closing the archive, so that is it possible to work with it afterwards. + \param mf + CZipMemFile structure to create archive in or extract from + \note This is important: you shouldn't destroy CZipMemFile object before + closing the archive, because you'll get an error; + \param iMode + Open mode. + The following modes are valid: #zipOpen, #zipOpenReadOnly, #zipCreate + \note Throws exceptions. + \see Open(LPCTSTR, int, int); +*/ + void Open(CZipMemFile& mf, int iMode = zipOpen); + +/** + Set #m_szRootPath to a specified value. Use it if you don't want to set + \e bFullPath argument in #AddNewFile or #ExtractFile to true and you + don't want to strip the whole path neither, but only a specific beginning. + Use it AFTER opening the archive and before using #AddNewFile or #ExtractFile. + See \ref q9 "the FAQ" for the example of use. + \param szPath + Set it to the string that you want to be omitted from the beginning of the path of the file + in the archive
+ if \c NULL - clears the #m_szRootPath and no path beginning will be matched against it + + \note set the case-sensitivity with #SetCaseSensitivity + + \see AddNewFile + \see ExtractFile + \see GetRootPath + +*/ + void SetRootPath(LPCTSTR szPath = NULL); + + + /** + Return the current value of #m_szRootPath + + \param none + + \return CZipString + */ + CZipString GetRootPath()const + { + return m_szRootPath; + } + + /** + The levels of smartness of the adding files action (see #AddNewFile) + \note if you wish to use \e zipsmCheckForEff, you should use + \e zipsmNotCompSmall as well, because it will save you the time + ( the small file will be surely larger after compression, so that + we can add it not compressed straight away);the compression level + is always ignored for a directory and set to 0 + */ + + enum Smartness + { + zipsmLazy = 0x0000, ///< do not bother (you know what you're doing after all) + zipsmCPassDir = 0x0001, ///< clear password for directories + zipsmCPFile0 = 0x0002, ///< clear password for files of 0 size + zipsmNotCompSmall = 0x0004, ///< do not compress files smaller than 5 bytes (they are always stored larger than uncompressed) + zipsmCheckForEff = 0x0008, ///< check whether the compressed file is larger than uncompressed and if so, remove it and store without the compression; + ///< in the disk spanning mode, the temporary file is used for that: if the file compression is efficient, the data is not compressed + ///< again, but moved from the temporary file to the archive; you can use #SetTempPath() to set the path where the + ///< file will be created or you can let the library figure it out (the library tries first the system default temporary directory, + ///< if it is not present or there is not enough space there, it tries the current directory, if it fails, no temporary file is created + ///< and the compression goes the usual way + + zipsmMemoryFlag = 0x0010, ///< combine it with zipsmCheckForEff or use zipsmCheckForEffInMem + + zipsmCheckForEffInMem = zipsmMemoryFlag | zipsmCheckForEff, ///< the same as #zipsmCheckForEff, but the temporary file is created created in memory instead (the temporary directory set with #SetTempPath() is ignored); has the meaning only with a disk-spanning archive, + ///< non-disk spanning archives don't need a temporary file + zipsmSmartPass = zipsmCPassDir | zipsmCPFile0, ///< smart password policy (a combination of \e zipsmCPassDir and \e zipsmCPFile0) + zipsmSmartAdd = zipsmNotCompSmall | zipsmCheckForEff, ///< smart adding (a combination of \e zipsmNotCompSmall and \e zipsmCheckForEff) + zipsmSafeSmart = zipsmSmartPass | zipsmNotCompSmall, ///< safe smart (smartest without checking for efficiency) + zipsmSmartest = zipsmSmartPass | zipsmSmartAdd, ///< smart at its best + + + zipsmInternal01 = 0xf000 ///< for internal use only + + }; + + + +/** + Add a new file to the archive. You can set the callback functor with #SetCallback. + + \param lpszFilePath + the full path to the file to be added + \param iLevel + the compression level, see #OpenNewFile + \param bFullPath
+ - if \c true, include full path of the file inside the archive (even if #m_szRootPath is set); + - if \c false only the filename without a path is stored in the archive
+ in this case if #m_szRootPath is set previously with #SetRootPath + and if the beginning of \e lpszFilePath equals #m_szRootPath + then the filename is set to the remaining part of \e lpszFilePath + (you can say to \e lpszFilePath minus #m_szRootPath) + \param iSmartLevel + the level of smartness of the library; can be one or more #Smartness + values (you can OR them)
+ if zipsmCheckForEff is specified and due to it the file needs to be + reinserted into the archive without a compression and the callback + functor is specified, the callback functor's method Callback is called with the first argument set to + DWORD (-1) (you need to remember the last argument if you need the size of the file) + \param nBufSize + the size of the buffer used + \return \c if it returns false then the file was not added, but the internal + state allows you to add other files (which is not possible after throwing + an exception) + \note Throws exceptions. + \note If you abort while adding a file in a non-disk-spanning archive, the added data will be removed from the archive + \see SetCallback + \see AddNewFile(LPCTSTR, LPCTSTR, int, int, unsigned long) + \see AddNewFile(CZipMemFile&, LPCTSTR, int, int, unsigned long) + \todo Replacing files in the archive +*/ + bool AddNewFile(LPCTSTR lpszFilePath, int iLevel = -1, bool bFullPath = true, + int iSmartLevel = zipsmSafeSmart, unsigned long nBufSize = 65535); + + +/** + Add a new file to the archive. + The same as #AddNewFile(LPCTSTR, int, bool, int, unsigned long) + but differs by one argument: + + \param lpszFileNameInZip + the file name that will be stored in the archive (to the directories, + there is a path separator automatically added at the end); #SetRootPath + function has no effect on this parameter + + \see AddNewFile(CZipMemFile&, LPCTSTR, int, int, unsigned long) + +*/ + bool AddNewFile(LPCTSTR lpszFilePath, + LPCTSTR lpszFileNameInZip, + int iLevel = -1, + int iSmartLevel = zipsmSafeSmart, + unsigned long nBufSize = 65535); + + /** + Add a new file to the archive. + The same as #AddNewFile(LPCTSTR, LPCTSTR, int, int, unsigned long) + but differs by one argument: + + \param mf + instead of from the physical file, the data for compression is taken from the CZipMemFile object + + \note + - the time of the file in zip is set to the current time, and the attributes to the default + file attributes (depending on the system) + - you cannot add directories with this function + \see AddNewFile(LPCTSTR, int, bool, int, unsigned long) + + */ + bool AddNewFile(CZipMemFile& mf, + LPCTSTR lpszFileNameInZip, + int iLevel = -1, + int iSmartLevel = zipsmSafeSmart, + unsigned long nBufSize = 65535); + + + +/** + Add a new file to the opened zip archive. The zip archive cannot be + an existing disk spanning archive (existing at the moment of opening archive), + because modifying such an archive is not possible (at least not with this + version ). + + \param header + The structure that provides additional information about the added file. + The following fields are valid: + - \e m_uMethod - file compression method; can be 0 (storing) or Z_DEFLATE (deflating) + otherwise Z_DEFLATE is assumed + - \e m_uModDate, \e m_uModTime - Use CZipFileHeader::SetTime to set them. + If \e lpszFilePath is not NULL this fields are overwritten and updated automatically. + See CZipFileHeader::SetTime + - \e m_uExternalAttr - Attributes of the file. + If \e lpszFilePath is not NULL this field is overwritten and updated automatically. + Use #SetFileHeaderAttr to set them. See #SetFileHeaderAttr. + - \e m_szFileName - A filename (may be with path) to be stored inside archive + to represent this file. See CZipFileHeader::SetFileName + - \e m_szComment - A file comment. See CZipFileHeader::SetComment + - \e m_pExtraField - LOCAL extra field, use #SetExtraField after opening + a new file, but before closing it to set the not local extra field + in the header in the central directory. See #SetExtraField
+ Other fields are ignored - they are updated automatically. + If the function returns \c true, \link #GetSystemCompatibility + system compatibility \endlink for this object is + set to the correct value (the same as #m_iArchiveSystCompatib), + additionally if \e lpszFilePath was not NULL, the attributes and + the time fields are filled with information retrieved from + the file pointed by \e lpszFilePath. + \param iLevel + The level of compression (-1, 0 - 9). + The are several preset values for the compression level: + - Z_DEFAULT_COMPRESSION : -1 (equals 6) + - Z_NO_COMPRESSION : 0 + - Z_BEST_SPEED : 1 + - Z_BEST_COMPRESSION : 9 + \param lpszFilePath + The path to the file to retrieve date stamp and attributes from. + These values are stored inside the archive. + + \return \c false in the following cases: + - the \e lpszFilePath is not NULL and the file attributes and data was not correctly retrieved + - a file is already opened for extraction or compression + - archive is an existing disk span archive + - maximum file count inside archive already reached (65535) + \note Throws exceptions. + +*/ bool OpenNewFile(CZipFileHeader & header, int iLevel = Z_DEFAULT_COMPRESSION, LPCTSTR lpszFilePath = NULL); -// Function name : WriteNewFile -// Description : compress the contents of the buffer and write it to a new file -// Return type : bool -// return false if the new file hasn't been opened -// Argument : void *pBuf -// buffer containing the data to be compressed and written -// Argument : DWORD iSize -// the size of the buffer - bool WriteNewFile(void *pBuf, DWORD iSize); +/** + Compress the contents of the buffer and write it to a new file. + \param pBuf + the buffer containing the data to be compressed and written + \param iSize + the number of bytes to be written from the buffer + \return \c false if the new file hasn't been opened yet + \note Throws exceptions. + \see OpenNewFile +*/ + bool WriteNewFile(const void *pBuf, DWORD iSize); -// Function name : SetExtraField -// Description : set the extra field in the file header in the central directory -// must be used after opening a new file in the archive, but before closing it -// Return type : void -// Argument : char *pBuf -// bufer with the data to be copied -// Argument : DWORD iSize -// size of the buffer - void SetExtraField(char *pBuf, WORD iSize); -// Function name : CloseNewFile -// Description : close the new file in the archive -// Return type : bool -// return false if no new file is opened -// Argument : bool bAfterException = false -// set it to true if you want to reuse CZipArchive after is has thrown an exception - bool CloseNewFile(); +/** + Set the extra field in the central directory of the currently opened file. + Must be used after opening a new file in the archive, but before closing it + To set the local extra field, set it in the CZipFileHeader structure passed + as the argument to the #OpenNewFile + \param pBuf + the bufer with the data to be copied + \param iSize + the size of the extra field in the buffer + \see OpenNewFile +*/ + void SetExtraField(const char *pBuf, WORD iSize); -// Function name : ExtractFile -// Description : fast extracting -// Return type : bool -// Argument : WORD uIndex -// the index of the file -// Argument : LPCTSTR lpszPath -// PATH only to extract the file to -// Argument : bool bFullPath = true -// extract the file with full path (if there is a path stored with the filename) -// or just with the filename alone -// (it means that the resulting file path is lpszPath + one of the above) -// Argument : LPCTSTR lpszNewName = NULL -// if NULL the default file name is taken (from the archive) -// Argument : ZIPCALLBACKFUN pCallback = NULL -// See the description at AddNewFile -// Argument : void* pUserData = NULL -// Argument : DWORD nBufSize = 65535 -// the size of the buffer used during extraction - bool ExtractFile(WORD uIndex, LPCTSTR lpszPath, bool bFullPath = true, LPCTSTR lpszNewName = NULL, ZIPCALLBACKFUN pCallback = NULL, void* pUserData = NULL, DWORD nBufSize = 65535); +/** + Close the new file in the archive. + \return \c false if there is no new file opened + \param bAfterException + it will close the new file without writing anything (call it also + with this parameter set to \c true after an exception other than CZipException::abortedSafely was + thrown from one of \e AddNewFile functions) + \note Throws exceptions. + \see OpenNewFile +*/ + bool CloseNewFile(bool bAfterException = false); -// Function name : OpenFile -// Description : open the file with the given index in the archive for extracting -// Argument : WORD uIndex -// Return type : bool +/** + Extract the file from the archive. You can set the callback functor with #SetCallback. + The argument \e lpszNewName may point to the full path and is influenced by \e bFullPath + argument (if \e lpszNewName contains drive specification then it is removed) + \param uIndex + the index of the file to extract + \param lpszPath + The PATH only to extract the file to. May not be NULL. If you wish to + use UNC path you need to replace \\\\ at the beginning of UNC path with \\\\?\UNC\ . + \param bFullPath
+ - if \c true, then extract with the full path - in this case the resulting + file path is \e lpszPath plus the path stored in the archive or plus \e lpszNewName + if \e lpszNewName is not NULL.
+ If the path of the file stored in the archive or \e lpszNewName contains a drive letter, + it is removed. + - if \c false, the destination file path is \e lpszPath + \e the filename only + extracted from the path stored in the archive or from \e lpszNewName if + \e lpszNewName is specified;
+ if #m_szRootPath is set previously with #SetRootPath then to \e lpszPath + is added the path stored in the archive (or \e lpszNewName if + \e lpszNewName is specified) that has removed the beginning that equals + #m_szRootPath (if there is no common beginning then is behaves like + #m_szRootPath was empty) + \param lpszNewName + The new name of the file after extraction. + If NULL the original filename stored in the archive is used. + May point to the full path but, if \e bFullPath is \c false, only the filename is extracted from this argument, + if the \e bFullPath is \c true, the drive letter (if exists) is removed. + \param nBufSize + the size of the buffer used + \return \c true if successful + \note to extract files which filenames match a specified pattern, use #FindMatches function + \note Throws exceptions. + \see SetCallback + \see ExtractFile(WORD, CZipMemFile&, DWORD) + \see FindMatches +*/ + bool ExtractFile(WORD uIndex, LPCTSTR lpszPath, bool bFullPath = true, + LPCTSTR lpszNewName = NULL, DWORD nBufSize = 65535); + + + /** + The same as #ExtractFile(WORD , LPCTSTR , bool , LPCTSTR , DWORD ) + but instead to a physical file, this function decompress the data into CZipMemFile object + \note + - if you pass CZipMemFile object already with data, its contents are NOT overwirtten, but the decompressed data is appended at the end + - if you try to extract a directory, the function will return \c false + */ + bool ExtractFile(WORD uIndex, CZipMemFile& mf, DWORD nBufSize = 65535); + +/** + Open the file with the given index in the archive for extracting. + Not successful opening the file doesn't lock the whole archive, so + you can try to open another one (after catching an exception if it was + thrown). Throw exception CZipException::badPassword if the password + was not set for the encrypted file. + \param uIndex + the index of the file + \return \c true if successful + \note Throws exceptions. +*/ bool OpenFile(WORD uIndex); -// Function name : ReadFile -// Description : decompress currently opened file to the bufor -// Return type : DWORD -// number of bytes read -// Argument : void *pBuf -// buffer to receive data -// Argument : DWORD iSize -// the size of the buffer +/** + Decompress currently opened file to the buffer. + \param pBuf + buffer to receive data + \param iSize + the size of the buffer + \return the number of bytes read + \see OpenFile + \note Throws exceptions. +*/ DWORD ReadFile(void *pBuf, DWORD iSize); -// Function name : GetLocalExtraField -// Description : get the local extra filed of the currently opened -// for extraction file in the archive -// Return type : int -// if pBuf == NULL return the size of the local extra field -// Argument : char* pBuf -// the buffer to receive the data -// Argument : int iSize -// the size of the buffer - int GetLocalExtraField(char* pBuf, int iSize); -// Function name : CloseFile -// Description : close current file and update -// date and attribute information of CFile, closes CFile -// Return type : int -// see below -// Argument : CFile & file -// OPENED CFile structure of the extracted file - int CloseFile(CFile &file); +/** + Test the file with the given index for the integrity. You can set the callback functor with #SetCallback. + The method throws exceptions but performs all the necessary cleanup + before, so that the next file can be tested after catching the exception. + \param uIndex + index of the file to test + \param uBufSize + the size of the buffer used during extraction + \return \c false if the incorrect action has been taken by + the user or the programmer (it is when #OpenFile or #GetFileInfo returned \c false or \e uBufSize is 0). + If the file didn't passed the test or there was a disk I/O error, an exception is thrown. + \note Throws exceptions. + \see SetCallback + +*/ + bool TestFile(WORD uIndex, DWORD uBufSize = 65535); + +/** + Perform the necessary cleanup after an exception was thrown + while testing the archive so that next files in the archive can be tested. + Called by #TestFile. Does not remove the file headers + information from the central directory. + \see TestFile + \see CZipCentralDir::Clear +*/ + void CloseFileAfterTestFailed(); + +/** + Get the local extra filed of the currently opened + for extraction file in the archive. + \param pBuf + the buffer to receive the data + \param iSize + the size of the buffer + \return If \e pBuf is NULL or iSize is 0, returns the size of the local extra field. + Returns -1 if there is no file opened for the extraction. +*/ + int GetLocalExtraField(char* pBuf, int iSize)const ; + +/** + The same as CZipArchive::CloseFile(LPCTSTR), but additionally + closes \e file. + \param file + OPENED CZipFile structure of the extracted file + \return + \note Throws exceptions. + \see CZipArchive::CloseFile(LPCTSTR) +*/ + int CloseFile(CZipFile &file); /** @@ -412,287 +655,1067 @@ public: thrown, to allow futher operations on the archive. \warning Close the file pointed by \e lpszFilePath before using this method, because the system may not be able to retrieve information from it. - \return + \return
- "1" = ok - "-1" = some bytes left to uncompress - probably due to a bad password - "-2" = setting extracted file date and attributes was not successful \note Throws exceptions. -*/ +*/ int CloseFile(LPCTSTR lpszFilePath = NULL, bool bAfterException = false); -// Function name : DeleteFile -// Description : delete the file with the given index -// Return type : bool -// Argument : WORD uIndex -// index of the file to be deleted - bool DeleteFile(WORD uIndex); - -/* delete files from the archive opened in the Delete mode specified by aIndexes - or aNames - - aIndexes is a array of indexes of the files inside the archive; - the index no. 0 is the first file in the archive - - aNames is a array of file names inside the archive; they must be the - same as they apppear in the archive (the name and the path (if persists) - is required, lower and upper case are not distinguished) - +/** + Delete the file from the archive with the given index. + You can set the callback functor with #SetCallback. + \param uIndex + a zero-based index + \note Throws exceptions. + \see SetCallback + \see DeleteFiles(CZipWordArray&) + \see DeleteFiles(const CZipStringArray&) + \see FindMatches */ - void DeleteFiles(CWordArray &aIndexes); - void DeleteFiles(CStringArray &aNames, bool bCaseSensitive = false); + void DeleteFile(WORD uIndex); - -// Function name : SetGlobalComment -// Description : set the global comment in the archive -// Return type : bool -// return false if the archive is closed or if it is an existing disk spanning archive -// Argument : const CString& szComment - bool SetGlobalComment(const CString& szComment); - -// Function name : GetGlobalComment -// Description : get the global commment -// Return type : CString -// return an empty string if the archive is closed - CString GetGlobalComment(); - - -// Function name : SetFileComment -// Description : set the comment of the file with the given index -// Return type : bool -// return false if the comment change is imposible -// Argument : WORD uIndex -// index of the file -// Argument : CString szComment -// comment to add - bool SetFileComment(WORD uIndex, CString szComment); - -// Function name : GetArchivePath -// Description : return the path of the currently opended archive volume -// Return type : CString - CString GetArchivePath(); - -// Function name : GetCurrentDisk -// Description : return the zero-base number of the current disk -// Return type : int -// return -1 if there is no current disk (archive is closed) - int GetCurrentDisk(); - -// Function name : GetSpanMode -// Description : return the disk spanning mode of the cuurrent archive -// Return type : int -// CZipStorage::tdSpan == - 2 - exisitng TD compatible disk spanning -// CZipStorage::pkzipSpan == - 1 - exisitng pkzip compatible disk spanning -// CZipStorage::noSpan == 0 - no disk spanning -// CZipStorage::pkzipSpan == 1 - pkzip compatible disk spanning in creation -// CZipStorage::tdSpan == 2 - TD compatible disk spanning in creation - int GetSpanMode(); - -// Function name : IsFileDirectory -// Description : check if the file with the given index is a directory -// Argument : WORD uIndex -// index of the file -// Return type : bool -// return true if the file is a directory -// return false if the file is not a directory or if there is no file -// with the given index - bool IsFileDirectory(WORD uIndex); - -// Function name : FindFile -// Description : find the file in the archive -// This function requires CZipCentralDir::m_bFindFastEnabled set to true -// Use EnableFindFast() -// Return type : int -// the index of the file found or -1 if no file was found -// Argument : CString szFileName -// the name of the file to be found -// Argument : bool bCaseSensitive = false -// if true - perform case sensitive search - int FindFile(CString szFileName, bool bCaseSensitive = false); - - -/* - Function name : EnableFindFast - Description : - Enable fast finding by the file name of the files inside the archive. - Set CZipCentralDir::m_bFindFastEnabled to true, which is required by FindFile. - Do not enable it, if you don't plan to use FindFile function - - Return type : void - Argument : bool bEnable = true +/** + Delete files from the archive. + You can set the callback functor with #SetCallback. + Sort \e aIndexes array in an ascending order. + \param aIndexes + an array of zero-based indexes of the files inside the archive + \note to remove files which filenames match a specified pattern, use #FindMatches function + \note Throws exceptions. + \see SetCallback + \see DeleteFile + \see DeleteFiles(const CZipStringArray& ) + \see FindMatches */ - void EnableFindFast(bool bEnable = true); + void DeleteFiles(CZipWordArray &aIndexes); -/* - Function name : SetConvertAfterOpen - Description : Set CZipCentralDir::m_bConvertAfterOpen value. Use before opening the archive - see CZipCentralDir::m_bConvertAfterOpen - Return type : void - Argument : bool bConvertAfterOpen +/** + Delete files from the archive. + You can set the callback functor with #SetCallback. + \param &aNames + an array of filenames inside the archive; + \param bFileNameOnly + the same as in #FindFile + \note set the case-sensitivity with #SetCaseSensitivity + \note Enables FindFast if not enabled + \note Throws exceptions. + \see SetCallback + \see DeleteFile + \see DeleteFiles(CZipWordArray&) + \see EnableFindFast +*/ + void DeleteFiles(const CZipStringArray &aNames, bool bFileNameOnly = false); + + +/** + Set the global comment in the archive. + \param lpszComment + the file comment + \return \c false if the archive is closed or if it is an existing disk spanning archive + \note Throws exceptions. +*/ + bool SetGlobalComment(LPCTSTR lpszComment); + + +/** + \return the global comment or an empty string if the archive is closed +*/ + CZipString GetGlobalComment()const ; + + +/** + Set the comment of the file with the given index inside the archive. + \param uIndex + zero-based index of the file in the archive + \param lpszComment + a comment to add + \return \c false if the comment change is impossible + \note Throws exceptions. +*/ + bool SetFileComment(WORD uIndex, LPCTSTR lpszComment); + +/** + \return the path of the currently opened archive volume +*/ + CZipString GetArchivePath()const; + +/** + \return
+ - a one-based number of the current disk + - 0 if there is no current disk (the archive is closed) + \note Useful mostly while working with the disk-spanning archive in creation to find out + how many disks were already created. To find out how many disks are in an existing disk-spanning archive, + use the function #GetCentralDirInfo +*/ + int GetCurrentDisk()const ; + +/** + Return the disk spanning mode of the current archive. + + Disk spanning archive modes: + + \anchor PKSpan + PKZIP compatible mode (pkzipSpan): + - only on removable devices + - auto-detect the size of the volume + - write a label to the disk + - there is a need to set a span callback functor (use #SetSpanCallback) + + \anchor TDSpan + TD mode (tdSpan): + - may be created on non removable devices + - uses user-defined volume size + - no need to set a span callback functor + + \return
+ - -2 - existing TD mode compatible disk spanning archive + - -1 - existing PKZIP compatible + - 0 - no disk spanning + - 1 - PKZIP compatible in creation + - 2 - TD compatible in creation + + This two disk spanning modes create volumes with compatible internal + structure. It means that you can easily convert the volumes created + in one mode to the other one by renaming the files + (in TD mode each volume but last has a number as an extension). + To convert the archive from TD to PKZIP compatible archive, + Copy each file to the removable media, giving them the extension. + ".zip". You should also label each disk with the appropriate label + starting from "pkback# 001". +*/ + int GetSpanMode()const + { + return m_storage.m_iSpanMode * m_storage.IsSpanMode(); + } + + /** + case-sensitivity values used as argument \e iCaseSensitive in #FindFile + */ + enum FFCaseSens + { + ffDefault, ///< use the default case-sensitivity as set with #SetCaseSensitivity function; + ///< if CZipCentralDir::m_findarray was build before with a different case-sensitivity, + ///< it is rebuild again, if it hasn't been build so far, it is build now with the + ///< default case-sensitivity + ffCaseSens, ///< perform a case-sensitive search (if the \c CZipArchive is non-case-sensitive, + ///< a less effective search is perfomed); does not rebuild CZipCentralDir::m_findarray, + ///< but if the array hasn't been built yet, it is build now as \b non-case-sensitive + ///< (you can use \c SetCaseSensitivity(true) and then #ffDefault to build it as case-sensitive) + ffNoCaseSens ///< perform a non-case-sensitive search (if the \c CZipArchive is case-sensitive, + ///< a less effective search is performed); does not rebuild CZipCentralDir::m_findarray, + ///< but if the array hasn't been built yet, it is build now as \b case-sensitive + ///< (you can use \c SetCaseSensitivity(false) and then #ffDefault to build it as non-case-sensitive) + + }; + +/** + Find the file in the archive. + If the archive wasn't opened with #m_bConvertAfterOpen set to \c true, + this function automatically convert all the filenames with the function + CZipCentralDir::ConvertAll and set #m_bConvertAfterOpen to \c true. + This function requires \link CZipCentralDir::m_bFindFastEnabled FindFast \endlink + feature enabled. + \param lpszFileName + the name of the file to be found in the archive; must be with path unless + you set \e bFileNameOnly to \c true. Use path separators the same as they are for your system + (\e "\" for Windows and \e "/" for Unix/Linux) + \param iCaseSensitive can be one of #FFCaseSens values + \param bFileNameOnly + if \c true, the function tries to find a filename without a path (a less effective search is performed); if you wish to find + a directory name, do not end it with the path separator, which is required if you + set \e bFileName to \c false + + \return
+ - the index of the file found + - -1 if there is no such a file in the archive + \see CZipCentralDir::FindFileNameIndex + \see EnableFindFast + \see CZipCentralDir::ConvertAll + \see SetConvertAfterOpen +*/ + int FindFile(LPCTSTR lpszFileName, int iCaseSensitive = ffDefault, bool bFileNameOnly = false); + +/** + Get the info of the file with the given index. + \param fhInfo + the structure to receive info + \param uIndex + a zero-based index of the file inside the archive + \return \c true if successful +*/ + bool GetFileInfo(CZipFileHeader & fhInfo, WORD uIndex) const; + + +/** + \return the number of files in the archive +*/ + int GetCount()const {return m_centralDir.m_headers.GetSize();} + + /** + values used in #Close function as parameter \e iAfterException + */ + enum CloseAfterException + { + afNoException, ///< normal close, no exception was thrown before by CZipArchive object + afAfterException, ///< an exception has been thrown, don't write any data but perform necessary cleaning to reuse CZipArchive object for another archive + afWriteDir ///< the same as above, but write the central directory end structure to the archive, so that we can save at least the files that have + ///< been added properly and maybe try to repair the archive later + }; + +/** + Close the archive. + \param iAfterException + one of #CloseAfterException enum values + \note Throws exceptions if \e iAfterException is different from \c afAfterException +*/ + void Close(int iAfterException = afNoException); + + +/** + Test if the archive is closed (a whole or the current volume only) + \param bArchive
+ - \c true: test for the whole archive + - \c false: test for the volume file only + + \return \c true if closed +*/ + bool IsClosed(bool bArchive = true)const ; + + /** + Write the central directory to the archive and flushes the internal buffers to the disk, + so that the archive is finalized on the disk, but you can still modify it. Use it after + opening (or creating) and modifying the archive if you want to prevent the loss + of the data you've compressed so far in case of the program crash.
+ If you use it on a disk spanning archive in creation it will not be closed, but its state + will be changed from "archive in creation" to "an existing span archive". Use it when you finish adding files to the disk-spanning archive and want to + begin extracting or testing it. It follows that you can call it only once in this case. However, if + after finalizing the disk spanning archive it turns out that it is one disk only, it is converted to + a normal archive and you can use it as such. If you want to know what is the state of the archive after using + this function call #GetSpanMode. + \note Cannot be used on existing disk spanning archives (they are not modifable anyway) + \note If you have an archive with a huge central directory, it'll influence the perfomance calling this function without a reason. + \note Throws exceptions. + \see GetSpanMode + \see SetAutoFlush + \see GetAutoFlush + + */ + void Flush(); + + + /** + Set the CZipArchive object to call #Flush after each operation that modifies the archive + (adding a new file, deleting file(s), modifying the global or a file comment). + It is useful when we want to prevent the loss of data in case of the program crash - the zip file will be then finalized on the disk. + Use it after opening the archive. + \note You can set AutoFlush only for non-disk spanning archives, however you can call #Flush once for a disk-spanning archive in creation. + \note If you have an archive with a huge central directory, setting Auto-Flush will influence the performance. + \see Flush + \see GetAutoFlush + */ + void SetAutoFlush(bool bAutoFlush = true); + + + /** + return the current #m_bAutoFlush value + \see Flush + \see SetAutoFlush + */ + bool GetAutoFlush()const {return m_bAutoFlush;} + +/** + Return the system compatibility of the current archive. + System compatibility value for the single file in the archive + (represented by CZipFileHeader) influences file attributes conversion + (the file attributes are defined differently across the platforms). + When opening an existing archive CZipArchive assumes the system compatibility + of the whole archive to be the same as of the first file in the archive + (if present). In other cases the current system value is assumed which is + taken from ZipPlatform::GetSystemID during creating or opening an archive + \remark + If the existing archive during opening is empty, ZipPlatform::GetSystemID + is assumed to be the default system for the files that will be added to the archive. + + \return + one of the enum values defined in \link ZipCompatibility::ZipPlatforms + ZipCompatibility.h \endlink + \see ZipCompatibility::ZipPlatforms + \see ZipPlatform::GetSystemID + \see CZipFileHeader::GetSystemCompatibility +*/ + int GetSystemCompatibility() const {return m_iArchiveSystCompatib;} + +/** + Set the system compatibility of the archive. By default it is set to the + current system value (the one returned by ZipPlatform::GetSystemID() function). + Use it after opening the archive, but before adding a new file or using + SetFileHeaderAttr() function + \param iSystemComp + can be one of ZipCompatibility::ZipPlatforms values + \return + return \c false if the value \e iSystemComp is not supported + (ZipCompatibility::IsPlatformSupported returns \c false for the value) + or it is not possible to set it right now +*/ + bool SetSystemCompatibility(int iSystemComp); + +/** + Set the attributes for CZipFileHeader structure to be used + in #OpenNewFile method as an argument. + This special procedure is taken, because the system compatibility must + be set for CZipFileHeader prior to the value, which must be identical to + the return value of #GetSystemCompatibility method. + \param header + the structure to have attributes set + \param uAttr + attributes to set + \note Throws exceptions if the archive system or the current system + is not supported by the ZipArchive library. + \see GetSystemCompatibility +*/ + void SetFileHeaderAttr(CZipFileHeader& header, DWORD uAttr); + + +/** + A helper for a various purposes (needed e.g. by the program that + cracks the zip archives password) + \return the pointer to the static CRC table in the zlib library + +*/ + static const DWORD* GetCRCTable() + { + return get_crc_table(); + } + +/** + Return the underlying archive storage medium. + \warning A method for a very advanced use - you normally never need it. + \return the pointer to #m_storage + \see CZipStorage +*/ + CZipStorage* GetStorage(){return &m_storage;} + + +/** + Set #m_bDetectZlibMemoryLeaks value. + \param bDetect + \note Use before opening a file in the archive. + \see m_bDetectZlibMemoryLeaks + +*/ + void SetDetectZlibMemoryLeaks(bool bDetect) + { + if (m_iFileOpened != nothing) + { + TRACE(_T("CZipArchive::SetDetectZlibMemoryLeaks: Set it before opening a file in the archive")); + return; + } + m_bDetectZlibMemoryLeaks = bDetect; + + } + +/** + Set CZipCentralDir::m_bConvertAfterOpen value. + The default value is \c true. + Setting this value to \c false is generally not effective and is intended + only for quick and short operations on archives with lots of files inside + (e.g. open archive, make an operation on a file which index you already know + and close the archive - using #FindFile function already makes setting this + value to \c false inefficient) + + \param bConvertAfterOpen + \note Use before opening the archive. + \see CZipCentralDir::m_bConvertAfterOpen */ void SetConvertAfterOpen (bool bConvertAfterOpen) { if (!IsClosed()) { - TRACE(_T("Set it before opening the archive")); + TRACE(_T("CZipArchive::SetConvertAfterOpen: Set it before opening the archive")); return; } m_centralDir.m_bConvertAfterOpen = bConvertAfterOpen; } - -// Function name : GetFileInfo -// Description : get the info of the file with the given index -// Return type : bool -// true if successful -// Argument : CZipFileHeader & fhInfo -// structure to receive info -// Argument : WORD uIndex -// zero-based index of the file - bool GetFileInfo(CZipFileHeader & fhInfo, WORD uIndex); +/** + Enable fast finding by the file name of the files inside the archive. + Set CZipCentralDir::m_bFindFastEnabled to \c true, which is required by #FindFile. + #FindFileIt is called by #FindFileif necessary. It builds CZipCentralDir::m_findarray + with the default case-sensitivity (set with #SetCaseSensitivity) + \note call after opening the archive. + \param bEnable + \see CZipCentralDir::m_bFindFastEnabled + \see FindFile +*/ + void EnableFindFast(bool bEnable = true); -// Function name : GetNoEntries -// Description : get number of files in the archive -// Return type : int - int GetNoEntries(); + /** + After you enable FindFast feature with #EnableFindFast, you can retrieve + how the files are sorted in CZipCentralDir::m_findarray (you can use it + in your own program if you need to display the sorted list and do not want + to duplicate data) + + \param iFindFastIndex + index in CZipCentralDir::m_findarray (not necessary the same as the one you'd + pass to #GetFileInfo); the number of items in this array is the same + as the number of files in the archive (you can retrieve it with + #GetCount) + + \return + index of the file in central directory (now you can call #GetFileInfo to get + the information); if the value is \c -1 then you have not called + #EnableFindFast before or the archive is closed or the \e iFindFastIndex + is out of range) + */ + int GetFindFastIndex(int iFindFastIndex) const + { + if (IsClosed()) + { + TRACE(_T("CZipArchive::GetFindFastIndex: ZipArchive not yet opened.\n")); + return -1; + } + + return m_centralDir.GetFindFastIndex(iFindFastIndex); + } -// Function name : Close -// Description : close archive -// Return type : void -// Argument : bool bAfterException = false -// set it to true if you want to close and reuse CZipArchive after is has thrown an exception -// ( it doesn't write any data to the file but only makes some cleaning then) - void Close(bool bAfterException = false); + + /** + Set a temporary path used when compressing files and #zipsmCheckForEff + is specified as an argument in #AddNewFile and the disk spanning archive + is in creation. + \param lpszPath set it to NULL to clear the temporary path and let the + library figure it out (it uses the system temporary directory if possible) + \param bForce if \e lpszPath is not \c NULL and this parameter set to \c true + the directory is created if it doesn't exists (if the given directory + does not exists , the temporary file will not be created) + \see AddNewFile + \see Smartness + \see GetTempPath + */ + void SetTempPath(LPCTSTR lpszPath = NULL, bool bForce = true); -// Function name : IsClosed -// Description : test if the archive or the current volume file is closed -// Return type : bool -// Argument : bool bArchive = true -// if true test for the whole archive, if false - for the volume file only - bool IsClosed(bool bArchive = true); + /** + enum values used in #PredictFileNameInZip + */ + enum Predict + { + + prDir, ///< if an argument is a directory, add a separator at the end + prFile, ///< treat the argument as a common file + prAuto ///< treat the argument as a directory only if it has a path separator at the end + + }; -// specify whether to control memory allocation and freeing by zlib library -// strongly suggested to set it to true (default) -// set it before opening a file (new or current) in the archive + /** + Given the file path in the form it would be passed to #AddNewFile + as \e lpszFilePath argument, the function returns the file name + as it would be stored in the archive.
+ The function takes into account the root path set with #SetRootPath. You can use this function + to eliminate duplicates before adding a list of files.
+ + \param lpszFilePath + the file path as it would be passed to #AddNewFile function + \param bFullPath + the same as \e bFullPath in #AddNewFile + \param iWhat + one of #Predict values to treat \e lpszFilePath correctly + bool bAnsiOEM + if \c true, ANSI->OEM conversion is made + + \return a modified file path + */ + CZipString PredictFileNameInZip(LPCTSTR lpszFilePath, bool bFullPath, int iWhat = prAuto, bool bAnsiOEM = false)const ; + + + /** + Predict the full filename with path after extraction. The parameters (except for the first) are in the form you'd pass + to the #ExtractFile(WORD , LPCTSTR , bool , LPCTSTR , DWORD ) function. The function takes into account the root path set with #SetRootPath. + \param lpszFileNameInZip + the filename of the file inside the archive (may be \c NULL if lpszNewName is not \c NULL) + \param lpszFilePath + \param bFullPath + \param lpszNewName + \return a predicted file path + */ + CZipString PredictExtractedFileName(LPCTSTR lpszFileNameInZip, LPCTSTR lpszPath, bool bFullPath, LPCTSTR lpszNewName = NULL)const ; + + /** + + Return the current value of #m_szTempPath + + \return CZipString + */ + CZipString GetTempPath()const + { + return m_szTempPath; + } + +/** + Function used in conjunction with #m_szRootPath to trim paths in #AddNewFile and #ExtractFile + \param zpc + \see SetRootPath + +*/ + CZipString TrimRootPath(CZipPathComponent& zpc)const ; + + /** + Remove \e lpszBeginning from the beginning of the \e szPath. Both argument are + considered to be paths so they matches up to the path separator. + + \param lpszBeginning + \param szPath + \param pCompareFunction (see: #m_pZipCompare) + + + \return \c true if the path beginning was removed + */ + static bool RemovePathBeginning(LPCTSTR lpszBeginning, CZipString& szPath, ZIPSTRINGCOMPARE pCompareFunction); + + /** + Set the default archive case-sensitivity. Affects the following functions: + - #FindFile + - #FindMatches + - #EnableFindFast + - #TrimRootPath + - #DeleteFiles + + \note set it before using one of the functions above or leave it as it is by default; + the default CZipArchive case-sensitivity depends on the system and is set + as follows: + - on Windows: \c false + - on Linux: \c true + + \param bCaseSensitive + */ + + void SetCaseSensitivity(bool bCaseSensitive) + { + m_bCaseSensitive = bCaseSensitive; + m_pZipCompare = GetCZipStrCompFunc(bCaseSensitive); + } + + /** + Return the central directory information. + \see GetCentralDirSize + */ + void GetCentralDirInfo(CZipCentralDir::Info& info)const; + + + /** + Get the central directory size. + \see CZipCentralDir::GetSize + \see GetCentralDirInfo + */ + DWORD GetCentralDirSize(bool bWhole = true) const + { + return m_centralDir.GetSize(bWhole); + } + + /** + return \c true if the archive cannot be modified, because it is an existing disk spanning archive + or it was opened with #zipOpenReadOnly + */ + bool IsReadOnly(){return m_storage.IsReadOnly();} + + + /** + + If you set \e bIgnore to \c true, CRC is not checked for the files being tested or extracted. + This method is useful when working with Java TM Archives (jar). + The CRC is checked by default. You can use this function on an opened or closed archive. + + */ + void SetIgnoreCRC(bool bIgnore = true){m_bIgnoreCRC = bIgnore;} + + /** + A class used in wildcard pattern matching. + This class is based on code by J. Kercheval, created 01/05/1991 + and available as a public domain at http://www.snippets.org. + */ + class CWildcard + { + public: + + + enum Match + { + matchNone, ///< for internal use + matchValid, ///< valid match + matchEnd, ///< premature end of pattern string + matchAbort, ///< premature end of text string + matchRange, ///< match failure on [..] construct + matchLiteral, ///< match failure on literal match + matchPattern ///< bad pattern + }; + + enum Pattern + { + patternEmpty = -4, ///< [..] construct is empty + patternClose, ///< no end bracket in [..] construct + patternRange, ///< malformed range in [..] construct + patternEsc, ///< literal escape at end of pattern + patternValid, ///< valid pattern + }; + + + /** + Match the pattern against the string \e lpszText + A match means the entire string \e lpszText is used up in matching. + + \param lpszText + the string to match against + \param iErrorType + if not \c NULL, set to one of #Match values indicating the return code + \return \c true if \e lpszText matches the pattern. + \see SetPattern + */ + bool IsMatch(LPCTSTR lpszText, int* iRetCode = NULL); + + /** + + \param lpszPattern + + \return \c true if \e lpszPattern has any special wildcard characters. + + */ + static bool IsPattern(LPCTSTR lpszPattern); + + /** + Test the pattern for validity. + + \param lpszPattern + the pattern to test + \param iErrorType + if not \c NULL, set to one of #Pattern values indicating the return code + \return \c true if \e lpszPattern is a well formed regular expression according + to the CWildcard class syntax (see #SetPattern) + */ + static bool IsPatternValid(LPCTSTR lpszPattern, int* iErrorType = NULL); + + /** + Match the pattern \e lpszPattern against the string \e lpszText + A match means the entire string \e lpszText is used up in matching. + + + \param lpszPattern + see #SetPattern + \param lpszText + the string to match against + \return + one of #Match values + */ + static int Match(LPCTSTR lpszPattern, LPCTSTR lpszText); + + CWildcard(){} + /** + Initialize the pattern. + \see SetPattern + */ + CWildcard(LPCTSTR lpszPattern, bool bCaseSensitive) + { + SetPattern(lpszPattern, bCaseSensitive); + } + virtual ~CWildcard(){} + + /** + Set the pattern to \e lpszPattern. + \param lpszPattern + + In the pattern string: + - * matches any sequence of characters(zero or more) + - ? matches any character + - [SET] matches any character in the specified set, + - [!SET] or[^SET] matches any character not in the specified set. + + A set is composed of characters or ranges; a range looks like + character hyphen character(as in 0 - 9 or A - Z).[0 - 9a - zA - Z_] is the + minimal set of characters allowed in the[..] pattern construct. + Other characters are allowed(ie. 8 bit characters) if your system + will support them. + + \note To suppress the special syntactic significance of any of []*?!^-\, + and match the character exactly, precede it with a \ + */ + void SetPattern(LPCTSTR lpszPattern, bool bCaseSensitive) + { + m_szPattern = lpszPattern; + m_bCaseSensitive=bCaseSensitive; + if (!bCaseSensitive) + m_szPattern.MakeLower(); + } + operator LPCTSTR() + { + return (LPCTSTR)m_szPattern; + } + protected: + bool m_bCaseSensitive; + static int MatchAfterStar(LPCTSTR p , LPCTSTR t); + CZipString m_szPattern; + }; + + + /** + This function finds the indexes of the files, which filenames match the specified pattern and stores + these indexes in the array. The indexes can be used then e.g. in deleting (CZipArchive::DeleteFiles) or + extracting files (CZipArchive::ExtractFile). + + \param lpszPattern + the pattern to match (see CWildcard::SetPattern on how to build the pattern). The case-sensitivity of the pattern + is set to the global archive case-sensitivity (set with #SetCaseSensitivity) + \param ar + the array which will contain the indexes of the files which filenames match the pattern; the contents of the array are NOT clearead, but the + indexes are appended to it + \param bFullPath
+ - if \c true, match the filename with path (if present) of the file (if the file is a directory, end it with the path separator or use a pattern that will recognize it) + - otherwise match only the name of the file (if the file is a directory, do not end it with the path separator) + + */ + void FindMatches(LPCTSTR lpszPattern, CZipWordArray& ar, bool bFullPath = true)const; +protected: + /** + A structure for the internal use only. Clears the password if necessary and + restores it later (also in case of an exception). + */ + struct CZipSmClrPass + { + void ClearPasswordSmartly(CZipArchive* pZip) + { + m_pZip = pZip; + m_szPass = pZip->GetPassword(); + if (!m_szPass.IsEmpty()) + pZip->SetPassword(); + } + ~CZipSmClrPass() + { + if (!m_szPass.IsEmpty()) + m_pZip->SetPassword(m_szPass); + } + CZipString m_szPass; + CZipArchive* m_pZip; + }; + + /** + Holds map of holes and areas to remain when deleting files from the archive. + A structure for the internal use only. + */ + struct CZipDeleteInfo + { + CZipDeleteInfo(){m_pHeader = NULL; m_bDelete = false;} + CZipDeleteInfo(CZipFileHeader* pHeader, bool bDelete) + :m_pHeader(pHeader), m_bDelete (bDelete){} + CZipFileHeader* m_pHeader; + bool m_bDelete; + }; + + + /** + Storage for callback functors. A structure for the internal use only. + \see SetCallback + */ + struct CZipClbckStrg : public CZipMap + { + void Set(CZipActionCallback* pCallback, CallbackType iType) + { + if (pCallback) + { + SetAt(iType, pCallback); + } + else + RemoveKey(iType); + } + CZipActionCallback* Get(CallbackType iType) + { + CZipActionCallback* pCallback = NULL; + if (Lookup(iType, pCallback)) + { + pCallback->m_iType = iType; + return pCallback; + } + else + return NULL; + } + }; + + + /** + \see CZipClbckStrg + */ + CZipClbckStrg m_callbacks; + + + /** + Write central directory calling a callback functor if available + */ + void WriteCentralDirectory(bool bFlush = true); + + /** + Default archive case-sensitivity + \see SetCaseSensitivity + */ + bool m_bCaseSensitive; + + /** + a pointer to the function in CZipString structure, + used to compare elements; can point to Compare, CompareNoCase, + Collate or CollateNoCase function address in CZipString structure ZIPSTRINGCOMPARE is defined as follows:
+ typedef int (CZipString::*ZIPSTRINGCOMPARE)( LPCTSTR ) const; + */ + ZIPSTRINGCOMPARE m_pZipCompare; + + /** + Internal data. + \see CZipInternalInfo + */ + CZipInternalInfo m_info; + + + /** + Physical layer of the archive. + \see CZipStorage + */ + CZipStorage m_storage; + + /** + A central directory object. + \see CZipCentralDir + */ + CZipCentralDir m_centralDir; + + /** + The open mode of the current file inside archive. + */ + enum OpenFileType + { + extract = -1, ///< current file opened for extraction + nothing, ///< no file inside archive opened + compress ///< a new file opened for compression + }; + + /** + Takes one of the #OpenFileType enum values. + */ + char m_iFileOpened; + + /** + The current AutoFlush value. + \see Flush + \see SetAutoFlush + \see GetAutoFlush + */ + bool m_bAutoFlush; + + /** + The value set with #SetIgnoreCRC + */ + bool m_bIgnoreCRC; + +/** + The root path to be omitted in #AddNewFile and #ExtractFile functions + from the beginning of the full file path. Set by #SetRootPath + \see TrimRootPath + \see SetRootPath +*/ + CZipString m_szRootPath; + + /** + A temporary path set with #SetTempPath function + \see SetTempPath + \see AddNewFile + \see Smartness + */ + CZipString m_szTempPath; + +/** + Open the archive in the given mode. + Called by #Open(LPCTSTR, int, int) and #Open(CZipMemFile&, int). + \param iMode + an opening mode + \note Throws exceptions. +*/ + void OpenInternal(int iMode); + + /** + The system code of the current archive. All new files in the archive + will be created regarding this value. Can be one of the enum values + defined in \link ZipCompatibility::ZipPlatforms ZipCompatibility.h + \endlink + + \see GetSystemCompatibility + */ + int m_iArchiveSystCompatib; + +/** + Free the memory allocated by the zlib library that hasn't been freed + due to an error in the zlib library (usually never happens). +*/ + void EmptyPtrList(); + + + +/** + Move the range of data in the archive specified by the \e uStartOffset + and \e uEndOffset by \e uToMove + \param uStartOffset + + \param uEndOffset + \param uMoveBy + + \return \c false if callback functor's operator () returned \c false + +*/ + bool MovePackedFiles(DWORD uStartOffset, DWORD uEndOffset, DWORD uMoveBy); + + /** + Remove recently added file (used by AddNewFile) if compressed is larger than uncompressed or if callback method return \c false. + \param bRemoveAnyway if \c true, do not check for the efficiency, but remove the file + + */ + bool RemoveLast(bool bRemoveAnyway = false); +/** + \return the currently opened for compression or decompression + file inside the archive NULL if there is no file opened +*/ + CZipFileHeader* CurrentFile(); + +/** + If the parameter \e iErr signalizes a zlib library error, throw CZipException + \param iErr + a zlib library error to check + \note Throws exceptions. +*/ + void CheckForError(int iErr); + + +/** + Throw a CZipException error. + \param err + the error code + \see CZipException::ZipErrors + \param bZlib + if \c true, treat \e err as a zlib error code and perform the conversion to the one of CZipException codes. + \see CZipException::Throw +*/ + void ThrowError(int err, bool bZlib = false); + + + typedef CZipPtrList::iterator CZipPtrListIter; + CZipPtrList m_list; ///< a list holding pointers to the memory areas allocated by the zlib library + + + static void* _zliballoc(void* opaque, UINT items, UINT size); ///< memory allocator called by the zlib library + static void _zlibfree(void* opaque, void* address); ///< memory deallocator called by the zlib library + + + /** + Specify whether to control memory allocation and freeing by the zlib library. + + \b Default: \c true + \note Set it before opening a file (new or existing) in the archive. + \see SetDetectZlibMemoryLeaks + + */ bool m_bDetectZlibMemoryLeaks; - CZipArchive(); - virtual ~CZipArchive(); - -//////////////////////////////////////////////////////////////////////// -////////////////////// static helper functions /////////////////////// -//////////////////////////////////////////////////////////////////////// - -// Function name : GetFileTitle -// Description : get the title of the file -// Return type : CString -// Argument : LPCTSTR lpszFilePath - static CString GetFileTitle(LPCTSTR lpszFilePath); - -// Function name : GetFileDirAndName -// Description : get the directory and the file name from the file path -// Return type : static CString -// Argument : LPCTSTR lpszFilePath - static CString GetFileDirAndName(LPCTSTR lpszFilePath); - -// Function name : GetDrive -// Description : return the (drive:) part from the path -// Return type : static CString -// Argument : LPCTSTR lpszFilePath - static CString GetDrive(LPCTSTR lpszFilePath); - -// Function name : IsDriveRemovable -// Description : return true if the file, path or (disk:) specified by the -// argument is (on) a removable drive -// Return type : static bool -// Argument : LPCTSTR lpszFilePath - static bool IsDriveRemovable(LPCTSTR lpszFilePath); - -// Function name : DirectoryExists -// Description : check if the given directory exists -// Return type : static bool -// Argument : LPCTSTR lpszDir - static bool DirectoryExists(LPCTSTR lpszDir); - - -// Function name : FileExists -// Description : check if the given file or directory exists -// Return type : static int -// return -1 if the given file is a directory, 1 if is a file -// or 0 if there is no such a file -// Argument : LPCTSTR lpszName - static int FileExists(LPCTSTR lpszName); - -// Function name : ForceDirectory -// Description : create nested directories with a single command -// Return type : static bool -// Argument : LPCTSTR lpDirectory - static bool ForceDirectory(LPCTSTR lpDirectory); - -// Function name : GetFilePath -// Description : get the path of the given file -// Return type : static CString -// Argument : LPCTSTR strFilePath - static CString GetFilePath(LPCTSTR lpszFilePath); - - -// Function name : GetFileExt -// Description : return the file extension -// Return type : static CString -// Argument : LPCTSTR lpszFilePath - static CString GetFileExt(LPCTSTR lpszFilePath); - - -// Function name : GetFileName -// Description : return the name of the file (title + extension) -// Return type : static CString -// Argument : LPCTSTR lpszFilePath - static CString GetFileName(LPCTSTR lpszFilePath); - - // just a helper for a various purposes - static const DWORD* GetCRCTable(); - // function for a VERY advanced use - you normally never need that - CZipStorage* GetStorage(){return &m_storage;} - -protected: - void EmptyPtrList(); + /** + Copyright string. + */ + static const TCHAR m_gszCopyright[]; + /** + \name Cryptography + Methods performing data encryption and decryption + and attributes used by them. + */ + //@{ +/** + Decode \e nCount bytes from the internal buffer. + \see m_info + \see CZipInternalInfo::m_pBuffer + \param uCount +*/ void CryptDecodeBuffer(DWORD uCount); +/** + Encode the internal buffer. + \see m_info + \see CZipInternalInfo::m_pBuffer +*/ void CryptEncodeBuffer(); + +/** + Encode the character \e c and update \link #m_keys encryption keys \endlink. + \param &c +*/ void CryptEncode(char &c); +/** + Create an encryption header for the new file in the archive. + \param iCrc + A control value. Use the two lower bytes of CZipFileHeader::m_uModTime. + This entails the need for a data description presence at the end of + the compressed data. We cannot use the real CRC now, because we don't know + it yet. + \param buf + a buffer to receive the header + \see CryptCheck +*/ void CryptCryptHeader(long iCrc, CZipAutoBuffer& buf); +/** + \internal + \param l + \param c + \return +*/ DWORD CryptCRC32(DWORD l, char c); +/** + Decode the character \e c and update \link #m_keys encryption keys \endlink. + \param &c +*/ void CryptDecode(char &c); + /** + \internal + */ char CryptDecryptByte(); + +/** + Decrypt the encryption header and check its control value. + The control value depends on the presence of the data descriptor. + \return \c true if the control value is correct + \see CryptCryptHeader +*/ bool CryptCheck(); +/** + Update \link #m_keys encryption keys \endlink with the given value. + \param c + +*/ void CryptUpdateKeys(char c); +/** + Initialize \link #m_keys encryption keys \endlink. +*/ void CryptInitKeys(); + /** + The archive password. If empty, the new file will not be encrypted. + */ CZipAutoBuffer m_pszPassword; + + /** + Encryption keys. + The key values are initialized using a supplied encryption password. + \see CryptInitKeys + */ DWORD m_keys[3]; - static int CompareWords(const void *pArg1, const void *pArg2); - bool IsDirectory(DWORD uAttr); - void DeleteInternal(WORD uIndex); - DWORD RemovePackedFile(DWORD uStartOffset, DWORD uEndOffset); - CZipFileHeader* CurrentFile(); - void CheckForError(int iErr); - CZipInternalInfo m_info; - CZipStorage m_storage; - CPtrList m_list; - static void* myalloc(void* opaque, UINT items, UINT size); - static void myfree(void* opaque, void* address); - enum {extract = -1, nothing, compress}; - // 0 - no file inside archive opened - // -1 - current opened for extract - // 1 - new opened for compression - char m_iFileOpened; - void ThrowError(int err); - CZipCentralDir m_centralDir; - static TCHAR m_gszCopyright[]; + //@} + + }; + + #endif // !defined(AFX_ZIPARCHIVE_H__A7F528A6_1872_4071_BE66_D56CC2DDE0E6__INCLUDED_) diff --git a/stepmania/src/smpackage/ZipArchive/ZipArchive_STL.dsp b/stepmania/src/smpackage/ZipArchive/ZipArchive_STL.dsp new file mode 100644 index 0000000000..2dd7c0dd93 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/ZipArchive_STL.dsp @@ -0,0 +1,421 @@ +# Microsoft Developer Studio Project File - Name="ZipArchive" - Package Owner=<4> +# Microsoft Developer Studio Generated Build File, Format Version 6.00 +# ** DO NOT EDIT ** + +# TARGTYPE "Win32 (x86) Static Library" 0x0104 + +CFG=ZipArchive - Win32 Unicode Debug +!MESSAGE This is not a valid makefile. To build this project using NMAKE, +!MESSAGE use the Export Makefile command and run +!MESSAGE +!MESSAGE NMAKE /f "ZipArchive_STL.mak". +!MESSAGE +!MESSAGE You can specify a configuration when running NMAKE +!MESSAGE by defining the macro CFG on the command line. For example: +!MESSAGE +!MESSAGE NMAKE /f "ZipArchive_STL.mak" CFG="ZipArchive - Win32 Unicode Debug" +!MESSAGE +!MESSAGE Possible choices for configuration are: +!MESSAGE +!MESSAGE "ZipArchive - Win32 Release" (based on "Win32 (x86) Static Library") +!MESSAGE "ZipArchive - Win32 Debug" (based on "Win32 (x86) Static Library") +!MESSAGE "ZipArchive - Win32 Unicode Debug" (based on "Win32 (x86) Static Library") +!MESSAGE "ZipArchive - Win32 Unicode Release" (based on "Win32 (x86) Static Library") +!MESSAGE + +# Begin Project +# PROP AllowPerConfigDependencies 0 +# PROP Scc_ProjName ""$/ZipArchive_STL", JHAAAAAA" +# PROP Scc_LocalPath "." +CPP=cl.exe +RSC=rc.exe + +!IF "$(CFG)" == "ZipArchive - Win32 Release" + +# PROP BASE Use_MFC 2 +# PROP BASE Use_Debug_Libraries 0 +# PROP BASE Output_Dir "Release" +# PROP BASE Intermediate_Dir "Release" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 0 +# PROP Output_Dir "Release" +# PROP Intermediate_Dir "Release" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /MD /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_AFXDLL" /Yu"stdafx.h" /FD /c +# ADD CPP /nologo /MD /W4 /GX /O2 /D "NDEBUG" /D "_MBCS" /D "WIN32" /D "_WINDOWS" /D "ZLIB_DLL" /D "ZIP_ARCHIVE_STL_PROJ" /YX"stdafx.h" /FD /c +# ADD BASE RSC /l 0x415 /d "NDEBUG" /d "_AFXDLL" +# ADD RSC /l 0x415 /d "NDEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LIB32=link.exe -lib +# ADD BASE LIB32 /nologo +# ADD LIB32 /nologo + +!ELSEIF "$(CFG)" == "ZipArchive - Win32 Debug" + +# PROP BASE Use_MFC 2 +# PROP BASE Use_Debug_Libraries 1 +# PROP BASE Output_Dir "Debug" +# PROP BASE Intermediate_Dir "Debug" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 1 +# PROP Output_Dir "Debug" +# PROP Intermediate_Dir "Debug" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_AFXDLL" /Yu"stdafx.h" /FD /GZ /c +# ADD CPP /nologo /MDd /W4 /Gm /GX /ZI /Od /D "_DEBUG" /D "_MBCS" /D "WIN32" /D "_WINDOWS" /D "ZLIB_DLL" /D "ZIP_ARCHIVE_STL_PROJ" /Fr /YX"stdafx.h" /FD /GZ /c +# ADD BASE RSC /l 0x415 /d "_DEBUG" /d "_AFXDLL" +# ADD RSC /l 0x415 /d "_DEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LIB32=link.exe -lib +# ADD BASE LIB32 /nologo +# ADD LIB32 /nologo + +!ELSEIF "$(CFG)" == "ZipArchive - Win32 Unicode Debug" + +# PROP BASE Use_MFC 2 +# PROP BASE Use_Debug_Libraries 1 +# PROP BASE Output_Dir "Zip___Win32_Unicode_Debug" +# PROP BASE Intermediate_Dir "Zip___Win32_Unicode_Debug" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 1 +# PROP Output_Dir "Unicode_Debug" +# PROP Intermediate_Dir "Unicode_Debug" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /MDd /W4 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_AFXDLL" /D "_MBCS" /D "ZLIB_DLL" /Fr /Yu"stdafx.h" /FD /GZ /c +# ADD CPP /nologo /MDd /W4 /Gm /GX /ZI /Od /D "_DEBUG" /D "_UNICODE" /D "WIN32" /D "_WINDOWS" /D "ZLIB_DLL" /D "ZIP_ARCHIVE_STL_PROJ" /Fr /YX"stdafx.h" /FD /GZ /c +# ADD BASE RSC /l 0x415 /d "_DEBUG" /d "_AFXDLL" +# ADD RSC /l 0x415 /d "_DEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LIB32=link.exe -lib +# ADD BASE LIB32 /nologo +# ADD LIB32 /nologo + +!ELSEIF "$(CFG)" == "ZipArchive - Win32 Unicode Release" + +# PROP BASE Use_MFC 2 +# PROP BASE Use_Debug_Libraries 0 +# PROP BASE Output_Dir "Zip___Win32_Unicode_Release" +# PROP BASE Intermediate_Dir "Zip___Win32_Unicode_Release" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 0 +# PROP Output_Dir "Unicode_Release" +# PROP Intermediate_Dir "Unicode_Release" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /MD /W4 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "ZLIB_DLL" /D "_AFXDLL" /Yu"stdafx.h" /FD /c +# ADD CPP /nologo /MD /W4 /GX /O2 /D "NDEBUG" /D "_UNICODE" /D "WIN32" /D "_WINDOWS" /D "ZLIB_DLL" /D "ZIP_ARCHIVE_STL_PROJ" /YX"stdafx.h" /FD /c +# ADD BASE RSC /l 0x415 /d "NDEBUG" /d "_AFXDLL" +# ADD RSC /l 0x415 /d "NDEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LIB32=link.exe -lib +# ADD BASE LIB32 /nologo +# ADD LIB32 /nologo + +!ENDIF + +# Begin Target + +# Name "ZipArchive - Win32 Release" +# Name "ZipArchive - Win32 Debug" +# Name "ZipArchive - Win32 Unicode Debug" +# Name "ZipArchive - Win32 Unicode Release" +# Begin Group "Source Files" + +# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" +# Begin Group "zlib_c" + +# PROP Default_Filter "" +# Begin Source File + +SOURCE=.\zlib\adler32.c +# End Source File +# Begin Source File + +SOURCE=.\zlib\compress.c +# End Source File +# Begin Source File + +SOURCE=.\zlib\crc32.c +# End Source File +# Begin Source File + +SOURCE=.\zlib\deflate.c +# End Source File +# Begin Source File + +SOURCE=.\zlib\gvmat32c.c +# End Source File +# Begin Source File + +SOURCE=.\zlib\infblock.c +# End Source File +# Begin Source File + +SOURCE=.\zlib\infcodes.c +# End Source File +# Begin Source File + +SOURCE=.\zlib\inffast.c +# End Source File +# Begin Source File + +SOURCE=.\zlib\inflate.c +# End Source File +# Begin Source File + +SOURCE=.\zlib\inftrees.c +# End Source File +# Begin Source File + +SOURCE=.\zlib\infutil.c +# End Source File +# Begin Source File + +SOURCE=.\zlib\maketree.c +# End Source File +# Begin Source File + +SOURCE=.\zlib\trees.c +# End Source File +# Begin Source File + +SOURCE=.\zlib\uncompr.c +# End Source File +# Begin Source File + +SOURCE=.\zlib\zutil.c +# End Source File +# End Group +# Begin Source File + +SOURCE=.\stdafx.cpp +# ADD CPP /Yc"stdafx.h" +# End Source File +# Begin Source File + +SOURCE=.\ZipArchive.cpp +# End Source File +# Begin Source File + +SOURCE=.\ZipAutoBuffer.cpp +# End Source File +# Begin Source File + +SOURCE=.\ZipCentralDir.cpp +# End Source File +# Begin Source File + +SOURCE=.\ZipCompatibility.cpp +# End Source File +# Begin Source File + +SOURCE=.\ZipException.cpp +# End Source File +# Begin Source File + +SOURCE=.\ZipFile.cpp +# End Source File +# Begin Source File + +SOURCE=.\ZipFileHeader.cpp +# End Source File +# Begin Source File + +SOURCE=.\ZipInternalInfo.cpp +# End Source File +# Begin Source File + +SOURCE=.\ZipMemFile.cpp +# End Source File +# Begin Source File + +SOURCE=.\ZipPathComponent.cpp +# End Source File +# Begin Source File + +SOURCE=.\ZipPlatform.cpp +# End Source File +# Begin Source File + +SOURCE=.\ZipPlatformComm.cpp +# End Source File +# Begin Source File + +SOURCE=.\ZipStorage.cpp +# End Source File +# Begin Source File + +SOURCE=.\ZipString.cpp +# End Source File +# End Group +# Begin Group "Header Files" + +# PROP Default_Filter "h;hpp;hxx;hm;inl" +# Begin Group "zlib_h" + +# PROP Default_Filter "" +# Begin Source File + +SOURCE=.\zlib\deflate.h +# End Source File +# Begin Source File + +SOURCE=.\zlib\infblock.h +# End Source File +# Begin Source File + +SOURCE=.\zlib\infcodes.h +# End Source File +# Begin Source File + +SOURCE=.\zlib\inffast.h +# End Source File +# Begin Source File + +SOURCE=.\zlib\inffixed.h +# End Source File +# Begin Source File + +SOURCE=.\zlib\inftrees.h +# End Source File +# Begin Source File + +SOURCE=.\zlib\infutil.h +# End Source File +# Begin Source File + +SOURCE=.\zlib\trees.h +# End Source File +# Begin Source File + +SOURCE=.\zlib\zconf.h +# End Source File +# Begin Source File + +SOURCE=.\zlib\zlib.h +# End Source File +# Begin Source File + +SOURCE=.\zlib\zutil.h +# End Source File +# End Group +# Begin Source File + +SOURCE=.\stdafx.h +# End Source File +# Begin Source File + +SOURCE=.\ZipAbstractFile.h +# End Source File +# Begin Source File + +SOURCE=.\ZipArchive.h +# End Source File +# Begin Source File + +SOURCE=.\ZipAutoBuffer.h +# End Source File +# Begin Source File + +SOURCE=.\ZipBaseException.h +# End Source File +# Begin Source File + +SOURCE=.\ZipCentralDir.h +# End Source File +# Begin Source File + +SOURCE=.\ZipCollections.h +# End Source File +# Begin Source File + +SOURCE=.\ZipCompatibility.h +# End Source File +# Begin Source File + +SOURCE=.\ZipException.h +# End Source File +# Begin Source File + +SOURCE=.\ZipFile.h +# End Source File +# Begin Source File + +SOURCE=.\ZipFileHeader.h +# End Source File +# Begin Source File + +SOURCE=.\ZipFileMapping.h +# End Source File +# Begin Source File + +SOURCE=.\ZipInternalInfo.h +# End Source File +# Begin Source File + +SOURCE=.\ZipMemFile.h +# End Source File +# Begin Source File + +SOURCE=.\ZipPathComponent.h +# End Source File +# Begin Source File + +SOURCE=.\ZipPlatform.h +# End Source File +# Begin Source File + +SOURCE=.\ZipStorage.h +# End Source File +# Begin Source File + +SOURCE=.\ZipString.h +# End Source File +# End Group +# Begin Group "Information" + +# PROP Default_Filter "txt" +# Begin Source File + +SOURCE=.\Appnote.txt +# End Source File +# Begin Source File + +SOURCE=.\ChangeLog.txt +# End Source File +# Begin Source File + +SOURCE=.\faq.txt +# End Source File +# Begin Source File + +SOURCE=.\gpl.txt +# End Source File +# Begin Source File + +SOURCE=.\License.txt +# End Source File +# Begin Source File + +SOURCE=.\Readme.txt +# End Source File +# End Group +# End Target +# End Project +# Section ZipArchive : {427B9281-D5E8-11D3-B7C7-E75054E13747} +# 2:12:AutoBuffer.h:AutoBuffer.h +# 2:18:CLASS: CAutoBuffer:CAutoBuffer +# 2:19:Application Include:ZipArchive.h +# 2:14:AutoBuffer.cpp:AutoBuffer.cpp +# End Section diff --git a/stepmania/src/smpackage/ZipArchive/ZipArchive_STL.dsw b/stepmania/src/smpackage/ZipArchive/ZipArchive_STL.dsw new file mode 100644 index 0000000000..dee3e16a75 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/ZipArchive_STL.dsw @@ -0,0 +1,29 @@ +Microsoft Developer Studio Workspace File, Format Version 6.00 +# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE! + +############################################################################### + +Project: "ZipArchive"=".\ZipArchive_STL.dsp" - Package Owner=<4> + +Package=<5> +{{{ +}}} + +Package=<4> +{{{ +}}} + +############################################################################### + +Global: + +Package=<5> +{{{ +}}} + +Package=<3> +{{{ +}}} + +############################################################################### + diff --git a/stepmania/src/smpackage/ZipArchive/ZipAutoBuffer.cpp b/stepmania/src/smpackage/ZipArchive/ZipAutoBuffer.cpp index 1197be39c1..08db1b5396 100644 --- a/stepmania/src/smpackage/ZipArchive/ZipAutoBuffer.cpp +++ b/stepmania/src/smpackage/ZipArchive/ZipAutoBuffer.cpp @@ -1,7 +1,11 @@ -// ZipAutoBuffer.cpp: implementation of the CZipAutoBuffer class. -// Part of the ZipArchive library -// -// Copyright (C) 2000 - 2001 Tadeusz Dracz. +/////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipAutoBuffer.cpp $ +// $Archive: /ZipArchive_STL/ZipAutoBuffer.cpp $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// // 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 @@ -101,4 +105,4 @@ CZipAutoBuffer& CZipAutoBuffer::operator=(const CZipAutoBuffer& buffer) memcpy(m_pBuffer, buffer.m_pBuffer, buffer.m_iSize); } return *this; -} \ No newline at end of file +} diff --git a/stepmania/src/smpackage/ZipArchive/ZipAutoBuffer.h b/stepmania/src/smpackage/ZipArchive/ZipAutoBuffer.h index 404e6fb765..ad8634c485 100644 --- a/stepmania/src/smpackage/ZipArchive/ZipAutoBuffer.h +++ b/stepmania/src/smpackage/ZipArchive/ZipAutoBuffer.h @@ -1,12 +1,11 @@ -/** -* \file ZipAutoBuffer.h -* Interface for the CZipAutoBuffer class. -* -* \author Tadeusz Dracz -*/ -// Part of the ZipArchive library -// -// Copyright (C) 2000 - 2001 Tadeusz Dracz. +/////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipAutoBuffer.h $ +// $Archive: /ZipArchive/ZipAutoBuffer.h $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// // 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 @@ -15,6 +14,11 @@ // For the licensing details see the file License.txt //////////////////////////////////////////////////////////////////////////////// +/** +* \file ZipAutoBuffer.h +* Interface for the CZipAutoBuffer class. +* +*/ #if !defined(AFX_ZIPAUTOBUFFER_H__DEC28C20_83FE_11D3_B7C3_EDEC47A8A86C__INCLUDED_) #define AFX_ZIPAUTOBUFFER_H__DEC28C20_83FE_11D3_B7C3_EDEC47A8A86C__INCLUDED_ @@ -26,13 +30,23 @@ /** A smart buffer freeing its contents on destruction. */ -class CZipAutoBuffer +class CZipAutoBuffer { public: operator char*() { return m_pBuffer; } +#ifndef __BORLANDC__ + operator const char*() const // Borland seems to have problems with this + { + return m_pBuffer; + } +#endif + + + + // may produce ambiguity on some compilers // operator const char*() const @@ -61,3 +75,4 @@ protected: }; #endif // !defined(AFX_ZIPAUTOBUFFER_H__DEC28C20_83FE_11D3_B7C3_EDEC47A8A86C__INCLUDED_) + diff --git a/stepmania/src/smpackage/ZipArchive/ZipBaseException.h b/stepmania/src/smpackage/ZipArchive/ZipBaseException.h new file mode 100644 index 0000000000..c68c5ca511 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/ZipBaseException.h @@ -0,0 +1,22 @@ +/////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipBaseException.h $ +// $Archive: /ZipArchive/ZipBaseException.h $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt +//////////////////////////////////////////////////////////////////////////////// + +#ifndef __ZIPBASEEXCEPTION_H__ +#define __ZIPBASEEXCEPTION_H__ + +typedef CException CZipBaseException; + +#endif //__ZIPBASEEXCEPTION_H__4 diff --git a/stepmania/src/smpackage/ZipArchive/ZipCentralDir.cpp b/stepmania/src/smpackage/ZipArchive/ZipCentralDir.cpp index 012c21ab79..77a4e62d12 100644 --- a/stepmania/src/smpackage/ZipArchive/ZipCentralDir.cpp +++ b/stepmania/src/smpackage/ZipArchive/ZipCentralDir.cpp @@ -1,55 +1,28 @@ -// ZipCentralDir.cpp: implementation of the CZipCentralDir class. -// +/////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipCentralDir.cpp $ +// $Archive: /ZipArchive/ZipCentralDir.cpp $ +// $Date$ $Author$ //////////////////////////////////////////////////////////////////////////////// -// Copyright (C) 2000 Tadeusz Dracz. -// For conditions of distribution and use, see copyright notice in ZipArchive.h +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt //////////////////////////////////////////////////////////////////////////////// #include "stdafx.h" #include "ZipCentralDir.h" #include "ZipArchive.h" +#include "ZipFileMapping.h" +#include "ZipPlatform.h" -struct CZipAutoHandle -{ - HANDLE m_hFileMap; - LPVOID m_pFileMap; - CZipAutoHandle() - { - m_hFileMap = NULL; - m_pFileMap = NULL; - } - bool CreateMapping(HANDLE hFile) - { - m_hFileMap = CreateFileMapping(hFile, NULL, PAGE_READWRITE, - 0, 0, _T("ZipArchive Mapping File")); - if (!m_hFileMap) - return false; - // Get pointer to memory representing file - m_pFileMap = MapViewOfFile(m_hFileMap, FILE_MAP_WRITE, 0, 0, 0); - return (m_pFileMap != NULL); - } - void RemoveMapping() - { - if (m_pFileMap) - { - UnmapViewOfFile(m_pFileMap); - m_pFileMap = NULL; - } - if (m_hFileMap) - { - CloseHandle(m_hFileMap); - m_hFileMap = NULL; - } - - } - ~CZipAutoHandle() - { - RemoveMapping(); - } -}; -#define ZIPCENTRALDIRSIZE 22 +#define CENTRALDIRSIZE 22 ////////////////////////////////////////////////////////////////////// // Construction/Destruction @@ -58,6 +31,8 @@ CZipCentralDir::CZipCentralDir() { m_bConvertAfterOpen = true; m_bFindFastEnabled = false; + m_bCaseSensitive = false; + m_pCompare = GetCZipStrCompFunc(ZipPlatform::GetSystemCaseSensitivity()); m_pStorage = NULL; m_pOpenedFile = NULL; m_iBufferSize = 32768; @@ -66,10 +41,11 @@ CZipCentralDir::CZipCentralDir() void CZipCentralDir::Init() { - m_bOnDisk = false; - m_uBytesBeforeZip = m_uCentrDirPos = 0; + m_info.m_bOnDisk = false; + m_info.m_uBytesBeforeZip = m_info.m_uCentrDirPos = 0; m_pOpenedFile = NULL; m_pszComment.Release(); + } CZipCentralDir::~CZipCentralDir() @@ -81,60 +57,60 @@ void CZipCentralDir::Read() { ASSERT(m_pStorage); WORD uCommentSize; - m_uCentrDirPos = Locate(); - m_pStorage->m_pFile->Seek(m_uCentrDirPos, CFile::begin); - CZipAutoBuffer buf(ZIPCENTRALDIRSIZE); - DWORD uRead = m_pStorage->m_pFile->Read(buf, ZIPCENTRALDIRSIZE ); - if (uRead != ZIPCENTRALDIRSIZE) - ThrowError(ZIP_BADZIPFILE); - memcpy(&m_szSignature, buf, 4); - memcpy(&m_uThisDisk, buf + 4, 2); - memcpy(&m_uDiskWithCD, buf + 6, 2); - memcpy(&m_uDiskEntriesNo, buf + 8, 2); - memcpy(&m_uEntriesNumber, buf + 10, 2); - memcpy(&m_uSize, buf + 12, 4); - memcpy(&m_uOffset, buf + 16, 4); - memcpy(&uCommentSize, buf + 20, 2); + m_info.m_uCentrDirPos = Locate(); + m_pStorage->m_pFile->Seek(m_info.m_uCentrDirPos, CZipAbstractFile::begin); + CZipAutoBuffer buf(CENTRALDIRSIZE); + + int uRead = m_pStorage->m_pFile->Read(buf, CENTRALDIRSIZE); + if (uRead != CENTRALDIRSIZE) + ThrowError(CZipException::badZipFile); + memcpy(&m_szSignature, buf, 4); + memcpy(&m_info.m_uThisDisk, buf + 4, 2); + memcpy(&m_info.m_uDiskWithCD, buf + 6, 2); + memcpy(&m_info.m_uDiskEntriesNo,buf + 8, 2); + memcpy(&m_info.m_uEntriesNumber,buf + 10, 2); + memcpy(&m_info.m_uSize, buf + 12, 4); + memcpy(&m_info.m_uOffset, buf + 16, 4); + memcpy(&uCommentSize, buf + 20, 2); buf.Release(); - m_pStorage->UpdateSpanMode(m_uThisDisk); - // if m_uThisDisk is not zero, it is enough to say that it is multi archive - ASSERT((!m_uThisDisk && (m_uEntriesNumber == m_uDiskEntriesNo) && !m_uDiskWithCD) || m_uThisDisk); + m_pStorage->UpdateSpanMode(m_info.m_uThisDisk); + // if m_uThisDisk is not zero, it is enough to say that it is a multi disk archive + ASSERT((!m_info.m_uThisDisk && (m_info.m_uEntriesNumber == m_info.m_uDiskEntriesNo) && !m_info.m_uDiskWithCD) || m_info.m_uThisDisk); - if (!m_pStorage->IsSpanMode() && ((DWORD)m_uCentrDirPos < m_uOffset + m_uSize)) - ThrowError(ZIP_BADZIPFILE); + if (!m_pStorage->IsSpanMode() && !m_info.CheckIfOK_1()) + ThrowError(CZipException::badZipFile); if (uCommentSize) { m_pszComment.Allocate(uCommentSize); uRead = m_pStorage->m_pFile->Read(m_pszComment, uCommentSize); if (uRead != uCommentSize) - ThrowError(ZIP_BADZIPFILE); + ThrowError(CZipException::badZipFile); } - m_uBytesBeforeZip = m_pStorage->IsSpanMode() ? 0 : m_uCentrDirPos - m_uSize - m_uOffset; + m_info.SetBytesBeforeZip(m_pStorage->IsSpanMode() != 0); - if ((!m_uSize && m_uEntriesNumber) || (!m_uEntriesNumber && m_uSize)) - ThrowError(ZIP_BADZIPFILE); + if (!m_info.CheckIfOK_2()) + ThrowError(CZipException::badZipFile); - m_bOnDisk = true; - m_pStorage->ChangeDisk(m_uDiskWithCD); + m_info.m_bOnDisk = true; + m_pStorage->ChangeDisk(m_info.m_uDiskWithCD); - if (!m_uSize) + if (!m_info.m_uSize) return; ReadHeaders(); } -// return the location of the beginning of the "end" record in the file DWORD CZipCentralDir::Locate() { // maximum size of end of central dir record - long uMaxRecordSize = 0xffff + ZIPCENTRALDIRSIZE; + long uMaxRecordSize = 0xffff + CENTRALDIRSIZE; DWORD uFileSize = m_pStorage->m_pFile->GetLength(); if ((DWORD)uMaxRecordSize > uFileSize) @@ -153,10 +129,10 @@ DWORD CZipCentralDir::Locate() int iToRead = uPosInFile - uRead; - m_pStorage->m_pFile->Seek(-uPosInFile, CFile::end); + m_pStorage->m_pFile->Seek(-uPosInFile, CZipAbstractFile::end); int iActuallyRead = m_pStorage->m_pFile->Read(buf, iToRead); if (iActuallyRead != iToRead) - ThrowError(ZIP_BADZIPFILE); + ThrowError(CZipException::badZipFile); // search from the very last bytes to prevent an error if inside archive // there are packed other arhives for (int i = iToRead - 4; i >=0 ; i--) @@ -167,35 +143,45 @@ DWORD CZipCentralDir::Locate() } - ThrowError(ZIP_CDIR_NOTFOUND); + ThrowError(CZipException::cdirNotFound); return 0; } -void CZipCentralDir::ThrowError(int err) +void CZipCentralDir::ThrowError(int err) const { - AfxThrowZipException(err, m_pStorage->m_pFile->GetFilePath()); + CZipException::Throw(err, m_pStorage->m_pFile->GetFilePath()); } void CZipCentralDir::ReadHeaders() { - m_pStorage->m_pFile->Seek(m_uOffset + m_uBytesBeforeZip, CFile::begin); - RemoveHeaders(); - for (int i = 0; i < m_uEntriesNumber; i++) + m_pStorage->m_pFile->Seek(m_info.m_uOffset + m_info.m_uBytesBeforeZip, CZipAbstractFile::begin); + RemoveHeaders(); //just in case + for (int i = 0; i < m_info.m_uEntriesNumber; i++) { CZipFileHeader* pHeader = new CZipFileHeader; - m_headers.Add(pHeader); // bezpoœrednio nastêpuje w razie wyj¹tku + m_headers.Add(pHeader); if (!pHeader->Read(m_pStorage)) - ThrowError(ZIP_BADZIPFILE); + ThrowError(CZipException::badZipFile); ConvertFileName(true, true, pHeader); } + SortHeaders(); // this is necessary when deleting files and removing data descriptors if (m_bFindFastEnabled) - BuildFindFastArray(); - + BuildFindFastArray(m_bCaseSensitive); +} + +void CZipCentralDir::SortHeaders() +{ + // we cannot use the Sort method of the CZipWordArray, + // because we store pointers (and we need to store pointers + // to make sure that the address of the CZipFileHeader structure + // remains the same while working with the library) + int iSize = m_headers.GetSize(); + if (iSize) + qsort((void*)&(m_headers[0]),iSize , sizeof(CZipFileHeader*), CompareHeaders); } -// remove all headers from the central dir void CZipCentralDir::Clear(bool bEverything) { m_pOpenedFile = NULL; @@ -211,26 +197,26 @@ void CZipCentralDir::Clear(bool bEverything) } -bool CZipCentralDir::IsValidIndex(WORD uIndex) +bool CZipCentralDir::IsValidIndex(int uIndex)const { - bool ret = uIndex < m_headers.GetSize(); + bool ret = uIndex < m_headers.GetSize() && uIndex >= 0; #ifdef _DEBUG if (!ret) - TRACE(_T("Not a valid index.\n")); + TRACE(_T("%s(%i) : Not a valid index.\n"),__FILE__,__LINE__); #endif return ret; } -// open the file for extracting + void CZipCentralDir::OpenFile(WORD uIndex) { WORD uLocalExtraFieldSize; - m_pOpenedFile = m_headers[uIndex]; + m_pOpenedFile = (*this)[uIndex]; m_pStorage->ChangeDisk(m_pOpenedFile->m_uDiskStart); - m_pStorage->m_pFile->Seek(m_pOpenedFile->m_uOffset + m_uBytesBeforeZip, CFile::begin); + m_pStorage->m_pFile->Seek(m_pOpenedFile->m_uOffset + m_info.m_uBytesBeforeZip, CZipAbstractFile::begin); if (!m_pOpenedFile->ReadLocal(m_pStorage, uLocalExtraFieldSize)) - ThrowError(ZIP_BADZIPFILE); + ThrowError(CZipException::badZipFile); m_pLocalExtraField.Release(); // just in case @@ -240,17 +226,17 @@ void CZipCentralDir::OpenFile(WORD uIndex) m_pLocalExtraField.Allocate(uLocalExtraFieldSize); m_pStorage->Read(m_pLocalExtraField, uLocalExtraFieldSize, true); if (m_pStorage->GetCurrentDisk() != iCurrDsk) - ThrowError(ZIP_BADZIPFILE); + ThrowError(CZipException::badZipFile); } } -void CZipCentralDir::CloseFile() +void CZipCentralDir::CloseFile(bool bAfterException) { if (!m_pOpenedFile) return; m_pLocalExtraField.Release(); - if (m_pOpenedFile->IsDataDescr()) + if (!bAfterException && m_pOpenedFile->IsDataDescr()) { CZipAutoBuffer buf(12); m_pStorage->Read(buf, 4, false); @@ -259,36 +245,37 @@ void CZipCentralDir::CloseFile() // This signature may be in the disk spanning archive that is one volume only // (it is detected as a non disk spanning archive) if (memcmp(buf, CZipStorage::m_gszExtHeaderSignat, 4) != 0) // there is no signature - m_pStorage->m_pFile->Seek(-4, CFile::current); + m_pStorage->m_pFile->Seek(-4, CZipAbstractFile::current); m_pStorage->Read(buf, 12, false); if (!m_pOpenedFile->CheckCrcAndSizes(buf)) - ThrowError(ZIP_BADZIPFILE); + ThrowError(CZipException::badZipFile); } m_pOpenedFile = NULL; } // add new header using the argument as a template -void CZipCentralDir::AddNewFile(CZipFileHeader & header) +CZipFileHeader* CZipCentralDir::AddNewFile(const CZipFileHeader & header) { CZipFileHeader* pHeader = new CZipFileHeader(header); m_pOpenedFile = pHeader; m_headers.Add(pHeader); if (m_bFindFastEnabled) - InsertFindFastElement(pHeader, WORD(m_headers.GetSize() - 1)); // GetSize IS > 0, 'cos we've just added a header + InsertFindFastElement(pHeader, WORD(m_headers.GetSize() - 1)); // GetCount > 0, 'cos we've just added a header RemoveFromDisk(); m_pStorage->m_pFile->SeekToEnd(); + return pHeader; } -// called during adding or deleting files; remove the central dir from the disk + void CZipCentralDir::RemoveFromDisk() { - if (m_bOnDisk) + if (m_info.m_bOnDisk) { ASSERT(!m_pStorage->IsSpanMode()); // you can't add files to the existing disk span archive or to delete them from it - m_pStorage->m_pFile->SetLength(m_uBytesBeforeZip + m_uOffset); - m_bOnDisk = false; + m_pStorage->m_pFile->SetLength(m_info.m_uBytesBeforeZip + m_info.m_uOffset); + m_info.m_bOnDisk = false; } } @@ -311,7 +298,7 @@ void CZipCentralDir::CloseNewFile() { ASSERT(!bIsSpan && !bEncrypted); m_pStorage->Flush(); - m_pStorage->m_pFile->Seek(m_pOpenedFile->m_uOffset + 14, CFile::begin); + m_pStorage->m_pFile->Seek(m_pOpenedFile->m_uOffset + 14, CZipAbstractFile::begin); // we don't have to restore the pointer, because before adding a new file, // the pointer is moved to the end } @@ -319,41 +306,46 @@ void CZipCentralDir::CloseNewFile() m_pOpenedFile->GetCrcAndSizes(buf + iToWrite); iToWrite += 12; - // offset set during writting the local header - m_pOpenedFile->m_uOffset -= m_uBytesBeforeZip; + // offset set during writing the local header + m_pOpenedFile->m_uOffset -= m_info.m_uBytesBeforeZip; // write the data descriptor and a disk spanning signature at once m_pStorage->Write(buf, iToWrite, true); - if (!bIsSpan && bEncrypted) - { - // write the information to the local header too - m_pStorage->Flush(); - m_pStorage->m_pFile->Seek(m_pOpenedFile->m_uOffset + 14, CFile::begin); - m_pStorage->Write(buf + 4, 12, true); - } - if (!bIsSpan) + { + if (bEncrypted) + { + // write the information to the local header too + m_pStorage->Flush(); + m_pStorage->m_pFile->Seek(m_pOpenedFile->m_uOffset + 14, CZipAbstractFile::begin); + m_pStorage->Write(buf + 4, 12, true); + } m_pStorage->Flush(); + } m_pOpenedFile = NULL; } -void CZipCentralDir::Write() +void CZipCentralDir::Write(CZipActionCallback* pCallback) { - if (m_bOnDisk) + if (m_info.m_bOnDisk) return; if (!m_pStorage->IsSpanMode()) { m_pStorage->Flush(); m_pStorage->m_pFile->SeekToEnd(); } - m_uEntriesNumber = (WORD)m_headers.GetSize(); - m_uSize = 0; + +// else +// // we are at the end already + + m_info.m_uEntriesNumber = (WORD)m_headers.GetSize(); + m_info.m_uSize = 0; bool bDontAllowDiskChange = false; // if there is a disk spanning archive in creation and it is only one-volume, // (current disk is 0 so far, no bytes has been written so we know they are - // all in the buffer) make sure that it will be after writting central dir + // all in the buffer) make sure that it will be after writing central dir // and make it a non disk spanning archive if (m_pStorage->IsSpanMode() && m_pStorage->GetCurrentDisk() == 0) { @@ -362,8 +354,8 @@ void CZipCentralDir::Write() // (they will be removed in the non disk spanning archive): // multi span signature at the beginnig (4 bytes) + the size of the data // descr. for each file (multi span signature + 12 bytes data) - // the count of bytes to add: central dir size - total to remove; - DWORD uToGrow = GetSize(true) - (4 + m_uEntriesNumber * (4 + 12)); + // the number of bytes to add: central dir size - total to remove; + DWORD uToGrow = GetSize(true) - (4 + m_info.m_uEntriesNumber * (4 + 12)); if (uVolumeFree >= uToGrow) // lets make sure it will be one-disk archive { @@ -377,77 +369,130 @@ void CZipCentralDir::Write() else { m_pStorage->Flush(); - m_pStorage->m_pFile->Flush(); if (RemoveDataDescr(false)) bDontAllowDiskChange = true; // if the disk change occurs somehow, we'll throw an error later } } } - WriteHeaders(); - m_uThisDisk = (WORD)m_pStorage->GetCurrentDisk(); - DWORD uSize = WriteCentralEnd(); - if (bDontAllowDiskChange && (m_pStorage->GetCurrentDisk() != 0)) - ThrowError(ZIP_BADZIPFILE); - // if after adding a central directory there is a disk change, - // update the information and write it again - if (m_uThisDisk != m_pStorage->GetCurrentDisk()) + try { - m_uThisDisk = (WORD)m_pStorage->GetCurrentDisk(); - if (m_uEntriesNumber) - { - m_uDiskEntriesNo = 0; - } - else - { - m_uDiskWithCD = m_uThisDisk; - m_uOffset = 0; - } + WriteHeaders(pCallback, bDontAllowDiskChange || !m_pStorage->IsSpanMode()); - if (m_pStorage->m_uBytesInWriteBuffer >= uSize) - // if the data is still in the buffer, simply remove it - m_pStorage->m_uBytesInWriteBuffer -= uSize; - else + m_info.m_uThisDisk = (WORD)m_pStorage->GetCurrentDisk(); + DWORD uSize = WriteCentralEnd(); + if (bDontAllowDiskChange) { - m_pStorage->Flush(); - m_pStorage->m_iBytesWritten -= uSize; - m_pStorage->m_pFile->SeekToBegin(); + if (m_pStorage->GetCurrentDisk() != 0) + ThrowError(CZipException::badZipFile); + } + // if after adding a central directory there is a disk change, + // update the information and write it again + if (m_info.m_uThisDisk != m_pStorage->GetCurrentDisk()) + { + m_info.DiskChange(m_pStorage->GetCurrentDisk()); + + if (m_pStorage->m_uBytesInWriteBuffer >= uSize) + // if the data is still in the buffer, simply remove it + m_pStorage->m_uBytesInWriteBuffer -= uSize; + else + { + m_pStorage->Flush(); + m_pStorage->m_iBytesWritten -= uSize; + m_pStorage->m_pFile->SeekToBegin(); + } + + WriteCentralEnd(); } - - WriteCentralEnd(); } - + catch (...) + { + if (bDontAllowDiskChange) + { + m_pStorage->FinalizeSpan(); + m_info.m_uThisDisk = 0; + } + throw; + } + m_info.m_bOnDisk = true; } -void CZipCentralDir::WriteHeaders() +void CZipCentralDir::WriteHeaders(CZipActionCallback* pCallback, bool bOneDisk) { - m_uDiskEntriesNo = 0; - m_uDiskWithCD = (WORD)m_pStorage->GetCurrentDisk(); - m_uOffset = m_pStorage->GetPosition() - m_uBytesBeforeZip; - if (!m_uEntriesNumber) + m_info.m_uDiskEntriesNo = 0; + m_info.m_uDiskWithCD = (WORD)m_pStorage->GetCurrentDisk(); + m_info.m_uOffset = m_pStorage->GetPosition() - m_info.m_uBytesBeforeZip; + if (!m_info.m_uEntriesNumber) return; - WORD iDisk = m_uDiskWithCD; - for (int i = 0; i < m_uEntriesNumber; i++) + WORD iDisk = m_info.m_uDiskWithCD; + int iStep = 0; // for the compiler + + if (pCallback) { - CZipFileHeader* pHeader = m_headers[i]; + pCallback->Init(); + pCallback->SetTotal(m_info.m_uEntriesNumber); + iStep = CZipActionCallback::m_iStep;// we don't want to wait forever + } + + int iAborted = 0; + for (int i = 0; i < m_info.m_uEntriesNumber; i++) + { + CZipFileHeader* pHeader = (*this)[i]; + + + CZipString szRemember; + if (m_bConvertAfterOpen) + // if CZipArchive::Flush is called we will be still using the archive, so restore changed name + szRemember = pHeader->GetFileName(); + ConvertFileName(false, true, pHeader); - m_uSize += pHeader->Write(m_pStorage); + m_info.m_uSize += pHeader->Write(m_pStorage); + + if (m_bConvertAfterOpen) + pHeader->SetFileName(szRemember); + if (m_pStorage->GetCurrentDisk() != iDisk) { - m_uDiskEntriesNo = 1; + m_info.m_uDiskEntriesNo = 1; iDisk = (WORD)m_pStorage->GetCurrentDisk(); // update the information about the offset and starting disk if the // first header was written on the new disk if (i == 0) { - m_uOffset = 0; - m_uDiskWithCD = iDisk; + m_info.m_uOffset = 0; + m_info.m_uDiskWithCD = iDisk; } } else - m_uDiskEntriesNo++; + m_info.m_uDiskEntriesNo++; + if (pCallback && !(i%iStep)) + if (!pCallback->Callback(iStep)) + { + + if (bOneDisk) + { + if (!m_pStorage->IsSpanMode()) + m_pStorage->EmptyWriteBuffer(); + else + m_pStorage->Flush(); // must be flush before - flush was not called in span mode + + // remove saved part from the disk + m_pStorage->m_pFile->SetLength(m_info.m_uBytesBeforeZip + m_info.m_uOffset); +// We can now abort safely + iAborted = CZipException::abortedSafely; + } + else + iAborted = CZipException::abortedAction; + break; + } } + + if (pCallback) + pCallback->CallbackEnd(); + + if (iAborted) + ThrowError(iAborted); } DWORD CZipCentralDir::WriteCentralEnd() @@ -456,57 +501,80 @@ DWORD CZipCentralDir::WriteCentralEnd() CZipAutoBuffer buf(uSize); WORD uCommentSize = (WORD)m_pszComment.GetSize(); memcpy(buf, m_gszSignature, 4); - memcpy(buf + 4, &m_uThisDisk, 2); - memcpy(buf + 6, &m_uDiskWithCD, 2); - memcpy(buf + 8, &m_uDiskEntriesNo, 2); - memcpy(buf + 10, &m_uEntriesNumber, 2); - memcpy(buf + 12, &m_uSize, 4); - memcpy(buf + 16, &m_uOffset, 4); + memcpy(buf + 4, &m_info.m_uThisDisk, 2); + memcpy(buf + 6, &m_info.m_uDiskWithCD, 2); + memcpy(buf + 8, &m_info.m_uDiskEntriesNo, 2); + memcpy(buf + 10, &m_info.m_uEntriesNumber, 2); + memcpy(buf + 12, &m_info.m_uSize, 4); + memcpy(buf + 16, &m_info.m_uOffset, 4); memcpy(buf + 20, &uCommentSize, 2); memcpy(buf + 22, m_pszComment, uCommentSize); m_pStorage->Write(buf, uSize, true); return uSize; } - -void CZipCentralDir::RemoveFile(WORD uIndex) +void CZipCentralDir::RemoveAll() +{ + m_findarray.RemoveAll(); + RemoveHeaders(); +} + +void CZipCentralDir::RemoveFile(CZipFileHeader* pHeader, int iIndex) { - CZipFileHeader* pHeader = m_headers[uIndex]; if (m_bFindFastEnabled) { - int i = FindFileNameIndex(pHeader->GetFileName(), true); + int i = FindFileNameIndex(pHeader->GetFileName()); ASSERT(i != -1); int uIndex = m_findarray[i].m_uIndex; m_findarray.RemoveAt(i); // shift down the indexes - for (int j = 0; j < m_findarray.GetSize(); j++) + int iSize = m_findarray.GetSize(); + for (int j = 0; j < iSize; j++) { if (m_findarray[j].m_uIndex > uIndex) m_findarray[j].m_uIndex--; } } - delete pHeader; - m_headers.RemoveAt(uIndex); + + if (iIndex == -1) + { + int iCount = m_headers.GetSize(); + for (int i = 0; i < iCount; i++) + if (pHeader == m_headers[i]) + { + iIndex = i; + break; + } + } + + if (iIndex != -1) + { + delete pHeader; + m_headers.RemoveAt(iIndex); + } + } -DWORD CZipCentralDir::GetSize(bool bWhole) +DWORD CZipCentralDir::GetSize(bool bWhole) const { DWORD uHeaders = 0; + int iCount = m_headers.GetSize(); if (bWhole) { - for (int i = 0; i < m_headers.GetSize(); i++) - uHeaders += m_headers[i]->GetSize(); + for (int i = 0; i < iCount; i++) + { + const CZipFileHeader* pHeader = m_headers[i]; + uHeaders += pHeader->GetSize(); + } } - return ZIPCENTRALDIRSIZE + m_pszComment.GetSize() + uHeaders; + return CENTRALDIRSIZE + m_pszComment.GetSize() + uHeaders; } -// remove data descriptors from the write buffer in the disk spanning volume -// that is one-disk only (do not remove from password encrypted files) bool CZipCentralDir::RemoveDataDescr(bool bFromBuffer) { - CZipAutoHandle ah; - char* pFile = NULL; + ziparchv::CZipFileMapping fm; + char* pFile; DWORD uSize; if (bFromBuffer) { @@ -516,18 +584,18 @@ bool CZipCentralDir::RemoveDataDescr(bool bFromBuffer) else { uSize = m_pStorage->m_pFile->GetLength(); - if (!ah.CreateMapping((HANDLE)m_pStorage->m_pFile->m_hFile)) + // we cannot use CZipMemFile in multidisk archive + // so it MUST be CZipFile + if (!fm.CreateMapping(static_cast(m_pStorage->m_pFile))) return false; - pFile = (char*)ah.m_pFileMap; + pFile = fm.GetMappedMemory(); } DWORD uOffsetToChange = 4; - DWORD uToCopy = 0; DWORD uPosInBuffer = 0; DWORD uExtraHeaderLen; - // this will work providing the order in the m_headers is the same as - // in the archive - for (int i = 0; i < m_headers.GetSize(); i++) + int iCount = m_headers.GetSize(); + for (int i = 0; i < iCount; i++) { // update the flag value in the local and central header // int uDataDescr = (m_headers[i]->m_uFlag & 8) ? (4 + 12) : 0; @@ -553,7 +621,7 @@ bool CZipCentralDir::RemoveDataDescr(bool bFromBuffer) // update crc32 and sizes' values pHeader->GetCrcAndSizes(pSour+ 14); - uToCopy = (i == (m_headers.GetSize() - 1) ? uSize : m_headers[i + 1]->m_uOffset) + DWORD uToCopy = (i == (iCount - 1) ? uSize : m_headers[i + 1]->m_uOffset) - pHeader->m_uOffset - uExtraHeaderLen; memmove(pFile + uPosInBuffer, pSour, uToCopy); @@ -568,7 +636,7 @@ bool CZipCentralDir::RemoveDataDescr(bool bFromBuffer) else { m_pStorage->m_iBytesWritten = uPosInBuffer; - ah.RemoveMapping(); + fm.RemoveMapping(); m_pStorage->m_pFile->SetLength(uPosInBuffer); } return true; @@ -576,32 +644,109 @@ bool CZipCentralDir::RemoveDataDescr(bool bFromBuffer) void CZipCentralDir::RemoveHeaders() { - for (int i = 0; i < m_headers.GetSize(); i++) - delete m_headers[i]; - m_headers.RemoveAll(); + int iCount = m_headers.GetSize(); + for (int i = 0; i < iCount; i++) + delete m_headers[i]; + m_headers.RemoveAll(); } + + void CZipCentralDir::ConvertAll() { ASSERT(!m_bConvertAfterOpen); - for (int i = 0; i < m_headers.GetSize(); i++) + int iCount = m_headers.GetSize(); + for (int i = 0; i < iCount; i++) ConvertFileName(true, false, m_headers[i]); m_bConvertAfterOpen = true; } - -void CZipCentralDir::BuildFindFastArray() +void CZipCentralDir::BuildFindFastArray( bool bCaseSensitive ) { - m_findarray.RemoveAll();// just in case - for (int i = 0; i < m_headers.GetSize(); i++) - InsertFindFastElement(m_headers[i], (WORD)i); + m_findarray.RemoveAll(); + m_bCaseSensitive = bCaseSensitive; + m_pCompare = GetCZipStrCompFunc(bCaseSensitive); + int iCount = m_headers.GetSize(); + if (!m_bConvertAfterOpen) + { + for (int i = 0; i < iCount; i++) + { + CZipFileHeader fh = *m_headers[i]; + ConvertFileName(true, false, &fh); + InsertFindFastElement(&fh, i); // this method requires the name to be already converted + } + } + else + for (int i = 0; i < iCount; i++) + InsertFindFastElement(m_headers[i], i); +} + +void CZipCentralDir::EnableFindFast(bool bEnable, bool bCaseSensitive) +{ + if (m_bFindFastEnabled == bEnable) + return; + m_bFindFastEnabled = bEnable; + if (bEnable) + BuildFindFastArray(bCaseSensitive); + else + m_findarray.RemoveAll(); +} + +int CZipCentralDir::FindFile(LPCTSTR lpszFileName, bool bCaseSensitive, bool bSporadically, bool bFileNameOnly) +{ + // this is required for fast finding and is done only once + if (!m_bConvertAfterOpen) + { + TRACE(_T("%s(%i) : Converting all the filenames.\n"),__FILE__,__LINE__); + ConvertAll(); + } + if (!m_bFindFastEnabled) + EnableFindFast(true, bSporadically ? !bCaseSensitive : bCaseSensitive); + int iResult = -1; + if (bFileNameOnly) + { + // a non-effective search (treat an array as unsorted) + int iSize = m_findarray.GetSize(); + for (int i = 0; i < iSize; i++) + { + CZipString sz = GetProperHeaderFileName(m_findarray[i].m_pHeader); + CZipPathComponent::RemoveSeparators(sz); // to find a dir + CZipPathComponent zpc(sz); + sz = zpc.GetFileName(); + if ((sz.*m_pCompare)(lpszFileName) == 0) + { + iResult = i; + break; + } + } + } + else if (bCaseSensitive == m_bCaseSensitive) + iResult = FindFileNameIndex(lpszFileName); + else + { + if (bSporadically) + { + // a non-effective search (treat an array as unsorted) + int iSize = m_findarray.GetSize(); + for (int i = 0; i < iSize; i++) + if (CompareElement(lpszFileName, (WORD)i) == 0) + { + iResult = i; + break; + } + } + else + { + BuildFindFastArray(bCaseSensitive); + iResult = FindFileNameIndex(lpszFileName); + } + } + return iResult == -1 ? -1 : m_findarray[iResult].m_uIndex; } void CZipCentralDir::InsertFindFastElement(CZipFileHeader* pHeader, WORD uIndex) { - CString fileName = pHeader->GetFileName(); - - + CZipString fileName = pHeader->GetFileName(); int iSize = m_findarray.GetSize(); // Our initial binary search range encompasses the entire array of filenames: @@ -616,7 +761,7 @@ void CZipCentralDir::InsertFindFastElement(CZipFileHeader* pHeader, WORD uIndex) int midpoint = ( start + end ) / 2; // Compare the filename with the filename at the midpoint of the current search range: - int result = CompareElement(fileName, (WORD)midpoint, true); + int result = CompareElement(fileName, (WORD)midpoint); // If our filename is larger, it must fall in the first half of the search range: if ( result > 0 ) @@ -636,10 +781,10 @@ void CZipCentralDir::InsertFindFastElement(CZipFileHeader* pHeader, WORD uIndex) start = midpoint; break; } } - m_findarray.InsertAt(start, CZipFindFast(pHeader, WORD(uIndex == -1 ? iSize : uIndex /* just in case */))); + m_findarray.InsertAt(start, CZipFindFast(pHeader, WORD(uIndex == WORD(-1) ? iSize : uIndex /* just in case */))); } -int CZipCentralDir::FindFileNameIndex(LPCTSTR lpszFileName, bool bCaseSensitive) +int CZipCentralDir::FindFileNameIndex(LPCTSTR lpszFileName) const { int start = 0; int end = m_findarray.GetUpperBound(); @@ -651,7 +796,7 @@ int CZipCentralDir::FindFileNameIndex(LPCTSTR lpszFileName, bool bCaseSensitive) int midpoint = ( start + end ) / 2; // Compare the given filename with the filename at the midpoint of the search range: - int result = CompareElement(lpszFileName, (WORD)midpoint, bCaseSensitive); + int result = CompareElement(lpszFileName, (WORD)midpoint); // If our filename is smaller, it must fall in the first half of the search range: if ( result > 0 ) @@ -675,3 +820,5 @@ int CZipCentralDir::FindFileNameIndex(LPCTSTR lpszFileName, bool bCaseSensitive) // Signal failure: return -1; } + + diff --git a/stepmania/src/smpackage/ZipArchive/ZipCentralDir.h b/stepmania/src/smpackage/ZipArchive/ZipCentralDir.h index 25170ee5d0..3a41496880 100644 --- a/stepmania/src/smpackage/ZipArchive/ZipCentralDir.h +++ b/stepmania/src/smpackage/ZipArchive/ZipCentralDir.h @@ -1,101 +1,317 @@ -// ZipCentralDir.h: interface for the CZipCentralDir class. -// //////////////////////////////////////////////////////////////////////////////// -// Copyright (C) 2000 Tadeusz Dracz. -// For conditions of distribution and use, see copyright notice in ZipArchive.h +// $Workfile: ZipCentralDir.h $ +// $Archive: /ZipArchive/ZipCentralDir.h $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt //////////////////////////////////////////////////////////////////////////////// -#if !defined(AFX_ZipCentralDir_H__859029E8_8927_4717_9D4B_E26E5DA12BAE__INCLUDED_) -#define AFX_ZipCentralDir_H__859029E8_8927_4717_9D4B_E26E5DA12BAE__INCLUDED_ +/** +* \file ZipCentralDir.h +* Interface for the CZipCentralDir class. +* +*/ + +#if !defined(AFX_CENTRALDIR_H__859029E8_8927_4717_9D4B_E26E5DA12BAE__INCLUDED_) +#define AFX_CENTRALDIR_H__859029E8_8927_4717_9D4B_E26E5DA12BAE__INCLUDED_ #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER > 1000 #include "ZipException.h" -#include #include "ZipFileHeader.h" #include "ZipAutoBuffer.h" +#include "ZipCollections.h" +#include "ZipCompatibility.h" /** - Used in fast finding files by the filename. - \see CZipCentralDir::m_findarray - \see CZipArchive::FindFile + A class representing the central directory record in the archive. */ -struct CZipFindFast -{ - CZipFindFast() - { - m_uIndex = 0; - m_pHeader= NULL; - } - CZipFindFast(CZipFileHeader* pHeader, WORD uIndex):m_pHeader(pHeader), m_uIndex(uIndex){} - /** - We extract a name from it. - */ - CZipFileHeader* m_pHeader; - - /** - The index in the central directory of the \e m_pHeader. - */ - WORD m_uIndex; -}; - - class CZipCentralDir { + /** + Used in fast finding files by the filename. + A structure for the internal use only. + \see CZipCentralDir::m_findarray + \see CZipArchive::GetFindFastElement + \see CZipArchive::FindFile + \see CZipArchive::EnableFindFast + */ + struct CZipFindFast + { + CZipFindFast() + { + m_uIndex = 0; + m_pHeader= NULL; + } + CZipFindFast(CZipFileHeader* pHeader, WORD uIndex):m_pHeader(pHeader), m_uIndex(uIndex){} + /** + A pointer to the structure in CZipCentralDir. We extract a name from it. + */ + CZipFileHeader* m_pHeader; -public: + /** + The index in the central directory of the \e m_pHeader. + */ + WORD m_uIndex; + }; -// end of central dir signature 4 bytes (0x06054b50) - char m_szSignature[4]; -// number of this disk 2 bytes - WORD m_uThisDisk; -// number of the disk with the -// start of the central directory 2 bytes - WORD m_uDiskWithCD; -// total number of entries in -// the central dir on this disk 2 bytes - WORD m_uDiskEntriesNo; -// total number of entries in -// the central dir 2 bytes - WORD m_uEntriesNumber; -// size of the central directory 4 bytes - DWORD m_uSize; -// offset of start of central -// directory with respect to -// the starting disk number 4 bytes - DWORD m_uOffset; -// zipfile comment length 2 bytes -// WORD m_uCommentSize; -// zipfile comment (variable size) - CZipAutoBuffer m_pszComment; - bool m_bFindFastEnabled; - CZipFileHeader* m_pOpenedFile; - void RemoveFile(WORD uIndex); - void Clear(bool bEverything = true); - CZipStorage* m_pStorage; - DWORD m_uCentrDirPos; - DWORD m_uBytesBeforeZip; +public: + /** + Stores general information about the central directory record. + */ + struct Info + { + DWORD m_uCentrDirPos; ///< the position of the beginning of the central directory + DWORD m_uBytesBeforeZip; ///< The number of bytes before the actual zip archive in a file. It is non-zero for self-extracting archives. + WORD m_uThisDisk; ///< number of the disk with the central directory end record (the number of disks in the disk-spanning archive) + WORD m_uDiskWithCD; ///< number of the disk with the start of the central directory + WORD m_uDiskEntriesNo; ///< total number of entries in the central dir on this disk + WORD m_uEntriesNumber; ///< total number of entries in the central dir + DWORD m_uSize; ///< size of the central directory (valid only if #m_bOnDisk is \c true; use #GetSize instead) + DWORD m_uOffset; ///< offset of start of central directory with respect to the starting disk number + bool m_bOnDisk; ///< \c true if the central directory is physically present in the archive + + protected: + friend CZipCentralDir; + bool CheckIfOK_1() + { + return ((DWORD)m_uCentrDirPos >= m_uOffset + m_uSize); + } + void SetBytesBeforeZip(bool bIsSpan) + { + m_uBytesBeforeZip = bIsSpan ? 0 : m_uCentrDirPos - m_uSize - m_uOffset; + } + bool CheckIfOK_2() + { + return (m_uSize || !m_uEntriesNumber) && (m_uEntriesNumber || !m_uSize); + } + void DiskChange(int iCurrentDisk) + { + m_uThisDisk = (WORD)iCurrentDisk; + if (m_uEntriesNumber) + { + m_uDiskEntriesNo = 0; + } + else + { + m_uDiskWithCD = m_uThisDisk; + m_uOffset = 0; + } + } + }; + CZipCentralDir(); virtual ~CZipCentralDir(); - void CloseFile(); - void OpenFile(WORD uIndex); - bool IsValidIndex(WORD uIndex); - void Read(); + + static char m_gszSignature[]; ///< central dir signature + + char m_szSignature[4]; ///< end of central dir signature (must be 0x06054b50) + + CZipAutoBuffer m_pszComment; ///< the archive comment + CZipAutoBuffer m_pLocalExtraField; ///< a local extra field + CZipFileHeader* m_pOpenedFile; ///< points to a currently opened file or NULL if no file is opened + + /** + Called by CZipArchive::OpenInternal. + */ void Init(); - void CloseNewFile(); - void Write(); - int m_iBufferSize; - bool m_bOnDisk; - static char m_gszSignature[]; - CTypedPtrArray m_headers; - CZipAutoBuffer m_pLocalExtraField; - void AddNewFile(CZipFileHeader & header); + + /** + Read the central directory from the archive. + \note Throws exceptions. + */ + void Read(); + + /** + Open the file. + \param uIndex + zero-based index of the file to open + \note Throws exceptions. + */ + void OpenFile(WORD uIndex); + +/** + Test if the given file header index is valid. + \param uIndex + a zero-based index + \return \c true if the file with the given index exists inside the archive; otherwise \c false; +*/ + bool IsValidIndex(int uIndex)const; + +/** + Remove the file header from the central directory. + \param pHeader + the header to remove + \param iIndex if index is not known set it to -1 + \note Throws exceptions. +*/ + void RemoveFile(CZipFileHeader* pHeader, int iIndex = -1); + + + /** + Remove last file from the central directory after the compression of the + file has proven to be non-effective (according to smartness level set) + + \param pHeader + \param iIndex + + */ + void RemoveLastFile(CZipFileHeader* pHeader, int iIndex) + { + DWORD uNewSize = pHeader->m_uOffset + GetBytesBefore(); + // then remove + RemoveFile(pHeader, iIndex); + + m_pStorage->Flush(); + m_pStorage->m_pFile->SetLength(uNewSize); + m_info.m_bOnDisk = false; // it is true when AutoFlush is set to true + } + + + /** + Remove all files + \note Throws exceptions. + */ + void RemoveAll(); +/** + Cleanup the structure. + \param bEverything + - \c true - clear some attributes and remove all the file headers from memory + - \c false - do not remove the file headers. It is called in that manner + from CZipArchive::CloseFileAfterTestFailed so that the + next file can be tested for the integrity + \see CZipArchive::CloseFileAfterTestFailed +*/ + void Clear(bool bEverything = true); + +/** + Add a new file to the central directory. + \param header + copy data from it to the new file header + \return the pointer to the new header + \note Throws exceptions. +*/ + CZipFileHeader* AddNewFile(const CZipFileHeader & header); + + /** + return the header filename, converted if needed + */ + CZipString GetProperHeaderFileName(const CZipFileHeader* pHeader) const + { + if (!m_bConvertAfterOpen) + { + CZipFileHeader fh = *pHeader; + ConvertFileName(true, false, &fh); + return fh.GetFileName(); + } + else + return pHeader->GetFileName(); + } + +/** + Remove physically the central directory from the archive. + Called during adding or deleting files. + \note Throws exceptions. +*/ void RemoveFromDisk(); - DWORD GetSize(bool bWhole = false); - CArray m_findarray; - int FindFileNameIndex(LPCTSTR lpszFileName, bool bCaseSensitive); - void BuildFindFastArray(); + +/** + Get the central directory size. + \param bWhole + if \c true, include the size of the file headers + \return the size of the central directory + \see CZipArchive::GetCentralDirSize +*/ + DWORD GetSize(bool bWhole = false) const; + + /** + Close a file inside archive opened for reading. + \param bAfterException \c true if closing after exception + \note Throws exceptions. + */ + void CloseFile(bool bAfterException = false); + + /** + Close a file inside archive opened for reading. + \note Throws exceptions. + */ + void CloseNewFile(); + + /** + Write the central directory to the archive. + \note Throws exceptions. + */ + void Write(CZipActionCallback* pCallback); + + /** + \see CZipArchive::EnableFindFast + */ + void EnableFindFast(bool bEnable, bool bCaseSensitive); + + /** + \see CZipArchive::FindFile + \note \e bSporadically set to \c false rebuilds #m_findarray if necessary + */ + int FindFile(LPCTSTR lpszFileName, bool bCaseSensitive, bool bSporadically, bool bFileNameOnly); + + + /** + \see CZipArchive::GetFindFastIndex + */ + int GetFindFastIndex(int iFindFastIndex)const + { + if (!IsValidIndex(iFindFastIndex) || !m_bFindFastEnabled) + { + // ASSERT(FALSE); // + return -1; + } + + return m_findarray[iFindFastIndex].m_uIndex; + } + + /** + Points to CZipArchive::m_storage. + */ + CZipStorage* m_pStorage; + + + /** + The size of the buffer used in searching for the central dir. + Set before opening the archive. + It is usually set with CZipArchive::SetAdvanced + (specify this value as the third argument). + \see CZipArchive::SetAdvanced + */ + int m_iBufferSize; + + + + + /** + Holds all the files inside archive info. + \see CZipFileHeader + */ + CZipArray m_headers; + + CZipFileHeader* operator[](int iIndex) + { + return m_headers[iIndex]; + } + const CZipFileHeader* operator[](int iIndex) const + { + return m_headers[iIndex]; + } + + /** - If \c true, the conversion of the filenames takes place after opening the archive (after reading the central directory @@ -104,16 +320,19 @@ public: - If \c false, the conversion takes place on each call to CZipArchive::GetFileInfo Set it to \c true when you plan to use CZipArchive::FindFile or get the stored files information.
- Set it to \c false when you plan mostly to only modify the archive. + Set it to \c false when you plan mostly to modify the archive. \b Default: \c true \note Set it before opening the archive. \see ConvertFileName */ bool m_bConvertAfterOpen; + /** - Convert the filename of the CZipFileHeader. + Convert the filename of the CZipFileHeader depending on the current system + and the system the zip file was created on (change slash to backslash or + vice versa, perform ANSI-OEM conversion if necessary). \param bFromZip if \c true, convert from archive format \param bAfterOpen @@ -121,9 +340,10 @@ public: \param pHeader the header to have filename converted; if \c NULL convert the currently opened file + \see ZipCompatibility::FileNameUpdate \see m_bConvertAfterOpen */ - void ConvertFileName(bool bFromZip, bool bAfterOpen, CZipFileHeader* pHeader = NULL) + void ConvertFileName(bool bFromZip, bool bAfterOpen, CZipFileHeader* pHeader = NULL) const { if (bAfterOpen != m_bConvertAfterOpen) return; @@ -132,25 +352,172 @@ public: pHeader = m_pOpenedFile; ASSERT(pHeader); } - pHeader->AnsiOem(!bFromZip); - pHeader->SlashChange(bFromZip); - } - void ConvertAll(); -protected: - void InsertFindFastElement(CZipFileHeader* pHeader, WORD uIndex); - void RemoveHeaders(); - bool RemoveDataDescr(bool bFromBuffer); - DWORD WriteCentralEnd(); - void WriteHeaders(); - void ReadHeaders(); - void ThrowError(int err); - DWORD Locate(); - int CompareElement(LPCTSTR lpszFileName, WORD uIndex, bool bCaseSensitive) - { - return bCaseSensitive ? m_findarray[uIndex].m_pHeader->GetFileName().Collate(lpszFileName) - : m_findarray[uIndex].m_pHeader->GetFileName().CollateNoCase(lpszFileName); + ZipCompatibility::FileNameUpdate(*pHeader, bFromZip); } +/** + Convert all the filenames to the system form. + Called by CZipArchive::FindFile + \see CZipArchive::FindFile +*/ + void ConvertAll(); + +/** + \param lpszFileName + the name of the file to find, must be exactly the same (apart from case) + as it appears in the archive + \return the index in #m_findarray with the appropriate CZipFindFast structure + or \c -1 if there is no file with the given name + \see CZipArchive::FindFile +*/ + int FindFileNameIndex(LPCTSTR lpszFileName) const; + + DWORD GetBytesBefore() const {return m_info.m_uBytesBeforeZip;} + void GetInfo(Info& info) const {info = m_info;} +protected: + /** + Sort the files inside the archive headers by the order in the archive. + */ + void SortHeaders(); + static int CompareHeaders(const void *pArg1, const void *pArg2) + { + CZipFileHeader* pw1 = *(CZipFileHeader**)pArg1; + CZipFileHeader* pw2 = *(CZipFileHeader**)pArg2; + if ((pw1->m_uOffset < pw2->m_uOffset && pw1->m_uDiskStart == pw2->m_uDiskStart) + || (pw1->m_uDiskStart < pw2->m_uDiskStart)) + return -1; + else if ((pw1->m_uOffset > pw2->m_uOffset && pw1->m_uDiskStart == pw2->m_uDiskStart) + || (pw1->m_uDiskStart > pw2->m_uDiskStart)) + return 1; + else + { + ASSERT(FALSE); + // two files with the same offsets on the same disk??? + CZipException::Throw(CZipException::badZipFile); + return 0; // just for the compiler comfort + } + } + + +/** + Build #m_findarray. +*/ + void BuildFindFastArray( bool bCaseSensitive ); + + /** + Used in fast finding files by the filename. + \see CZipFindFast + \see m_bFindFastEnabled + \see CZipArchive::FindFile + */ + CZipArray m_findarray; + + /** + If \c true, the there is an additional array build, to speed up the + finding process + CZipArchive::FindFile uses this array to perform a + binary search. + \b Default: \c false + \see CZipArchive::EnableFindFast + \see CZipArchive::FindFile + \see CZipCentralDir::m_findarray + */ + bool m_bFindFastEnabled; + + +/** + The \e lpszFileName and \e bCaseSensitive arguments + are the same as in the #FindFileNameIndex. The function get CZipFindFast + structure pointed by \e uIndex and compares the filename of CZipFileHeader + class stored in this structure with \e lpszFileName. + \param lpszFileName + \param uIndex + the index from #m_findarray + \return + - 0 if the filenames are the same + - < 0 if the filename stored in the array is less than \e lpszFileName + - > 0 if the filename stored in the array is greater than \e lpszFileName +*/ + int CompareElement(LPCTSTR lpszFileName, WORD uIndex) const + { + return (m_findarray[uIndex].m_pHeader->GetFileName().*m_pCompare)(lpszFileName); + } +/** + Insert a new CZipFindFast element to the #m_findarray. + Initialize CZipFindFast object with \e pHeader and \e uIndex values. + \param pHeader + \param uIndex +*/ + void InsertFindFastElement(CZipFileHeader* pHeader, WORD uIndex); + + + + /** + A compare function (Collate or CollateNoCase) set once so as not + to check every time which one to use
+ ZIPSTRINGCOMPARE is defined in CZipString.h as:
+ typedef int (CZipString::*ZIPSTRINGCOMPARE)( LPCTSTR ) const; + */ + ZIPSTRINGCOMPARE m_pCompare; + + /** + The way the m_findarray is sorted + */ + bool m_bCaseSensitive; + + /** + \see Info + */ + Info m_info; + + /** + \return the location of the beginning of the central dir end record in the archive + \note Throws exceptions. + */ + DWORD Locate(); + /** + Read the file headers from the file. + \note Throws exceptions. + */ + void ReadHeaders(); + + /** + Free the memory allocated for the CZipFileHeader structures. + */ + void RemoveHeaders(); +/** + Remove data descriptors from the write buffer in the disk spanning volume + that turned out to be one-disk only. + We do not remove them from password encrypted files. + + \param bFromBuffer + if \c true, remove from the buffer in memory otherwise from the file on a disk + \return \c false if the file mapping to memory was not successful + Can happen only when \e bFormBuffer is \c false. + \note Throws exceptions. +*/ + bool RemoveDataDescr(bool bFromBuffer); +/** + Write the file headers to the archive. + \note Throws exceptions. +*/ + void WriteHeaders(CZipActionCallback* pCallback, bool bOneDisk); +/** + Write the central directory end record. + \return the size of the record + \note Throws exceptions. +*/ + DWORD WriteCentralEnd(); + +/** + Throw an exception with the given code. + \param err + \see CZipException::Throw +*/ + void ThrowError(int err) const; + + }; -#endif // !defined(AFX_ZipCentralDir_H__859029E8_8927_4717_9D4B_E26E5DA12BAE__INCLUDED_) + +#endif // !defined(AFX_CENTRALDIR_H__859029E8_8927_4717_9D4B_E26E5DA12BAE__INCLUDED_) diff --git a/stepmania/src/smpackage/ZipArchive/ZipCollections.h b/stepmania/src/smpackage/ZipArchive/ZipCollections.h new file mode 100644 index 0000000000..0bcdfe063e --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/ZipCollections.h @@ -0,0 +1,83 @@ +//////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipCollections.h $ +// $Archive: /ZipArchive/ZipCollections.h $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt +//////////////////////////////////////////////////////////////////////////////// + +#ifndef ZIPCOLLECTIONS_DOT_H +#define ZIPCOLLECTIONS_DOT_H + +#if _MSC_VER > 1000 +#pragma once +#pragma warning( push ) +#pragma warning (disable:4786) // 'identifier' : identifier was truncated to 'number' characters in the debug information +#endif // _MSC_VER > 1000 + +#include +typedef CStringArray CZipStringArray; + +template +class CZipArray : public CArray +{ + + static int CompareAsc(const void *pArg1, const void *pArg2) + { + TYPE w1 = *(TYPE*)pArg1; + TYPE w2 = *(TYPE*)pArg2; + return w1 == w2 ? 0 :(w2 > w1 ? - 1 : 1); + } + static int CompareDesc(const void *pArg1, const void *pArg2) + { + TYPE w1 = *(TYPE*)pArg1; + TYPE w2 = *(TYPE*)pArg2; + return w1 == w2 ? 0 :(w1 > w2 ? - 1 : 1); + } +public: + void Sort(bool bAscending) + { + int iSize = GetSize(); + if (!iSize) // if ommitted operator [] will fail if empty + return; + qsort((void*)&((*this)[0]),iSize , sizeof(TYPE), bAscending ? CompareAsc : CompareDesc); + } +}; + +typedef CZipArray CZipWordArray; + +template +class CZipPtrList : public CTypedPtrList +{ +public: + typedef POSITION iterator; + typedef POSITION const_iterator; + + bool IteratorValid(const iterator &iter) const + { + return iter != NULL; + } + +}; + +template +class CZipMap : public CMap +{ + +}; + +#ifdef _MFC_VER + #pragma warning( pop ) +#endif + + +#endif /* ZIPCOLLECTIONS_DOT_H */ + diff --git a/stepmania/src/smpackage/ZipArchive/ZipCompatibility.cpp b/stepmania/src/smpackage/ZipArchive/ZipCompatibility.cpp new file mode 100644 index 0000000000..37cc8bbbad --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/ZipCompatibility.cpp @@ -0,0 +1,214 @@ +//////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipCompatibility.cpp $ +// $Archive: /ZipArchive/ZipCompatibility.cpp $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt +//////////////////////////////////////////////////////////////////////////////// + +#include "stdafx.h" +#include "ZipCompatibility.h" +#include "ZipPlatform.h" +#include "ZipException.h" +#include "ZipAutoBuffer.h" +#include "ZipFileHeader.h" +enum iInternalAttr +{ + attROnly = 0x01, + attHidd = 0x02, + attSys = 0x04, + attDir = 0x10, + attArch = 0x20 +}; +// *********************** WINDOWS ************************** +#ifndef _WIN32 + #define FILE_ATTRIBUTE_READONLY 0x00000001 + #define FILE_ATTRIBUTE_HIDDEN 0x00000002 + #define FILE_ATTRIBUTE_SYSTEM 0x00000004 + #define FILE_ATTRIBUTE_DIRECTORY 0x00000010 + #define FILE_ATTRIBUTE_ARCHIVE 0x00000020 +#endif +// *********************** UINX ************************** +#define USER_PERMISSIONS_MASK 0x01C00000 +#define EXTRACT_USER_PERMISSIONS(x) ((x & USER_PERMISSIONS_MASK) >> 22) +#define CREATE_USER_PERMISSIONS(x) ((x & 0x0007) << 22) + +#define GROUP_PERMISSIONS_MASK 0x00380000 +#define EXTRACT_GROUP_PERMISSIONS ((x & GROUP_PERMISSIONS_MASK) >> 19) +#define CREATE_GROUP_PERMISSIONS(x) ((x & 0x0007) << 19) + +#define OTHER_PERMISSIONS_MASK 0x00070000 +#define EXTRACT_OTHER_PERMISSIONS ((x & OTHER_PERMISSIONS_MASK) >> 16) +#define CREATE_OTHER_PERMISSIONS(x) ((x & 0x0007) << 16) + +#define UNIX_DIRECTORY_ATTRIBUTE 0x40000000 +#define UNIX_FILE_ATTRIBUTE 0x80000000 + +////////////////////////////////////////////////////////////////////// +// Construction/Destruction +////////////////////////////////////////////////////////////////////// +using namespace ZipCompatibility; + +typedef DWORD(*conv_func)(DWORD , bool ); + +DWORD AttrDos(DWORD , bool ); +DWORD AttrUnix(DWORD, bool); +DWORD AttrMac(DWORD , bool ); + +// more to come... +conv_func conv_funcs[11] = {AttrDos, + NULL, + NULL, + AttrUnix, + NULL, + NULL, + AttrDos, + AttrMac, + NULL, + NULL, + AttrDos +}; + + + +DWORD ZipCompatibility::ConvertToSystem(DWORD uAttr, int iFromSystem, int iToSystem) +{ + + if (iToSystem != iFromSystem && iFromSystem < 11 && iToSystem < 11) + { + conv_func p = conv_funcs[iFromSystem], q = conv_funcs[iToSystem]; + if (p && q) + uAttr = q( p(uAttr, true), false); + else + CZipException::Throw(CZipException::platfNotSupp); + } + return uAttr; +} + + +DWORD AttrDos(DWORD uAttr, bool ) +{ + return uAttr; +} + + + +DWORD AttrUnix(DWORD uAttr, bool bFrom) +{ + DWORD uNewAttr = 0; + if (bFrom) + { + if (uAttr & UNIX_DIRECTORY_ATTRIBUTE) + uNewAttr = attDir; + + uAttr = EXTRACT_USER_PERMISSIONS (uAttr); + + // we may set archive attribute if the file hasn't the execute permissions + // + if (!(uAttr & 1)) + uNewAttr |= attArch ; + + if (!(uAttr & 2)) + uNewAttr |= attROnly; + + if (!(uAttr & 4)) + uNewAttr |= attHidd; + } + else + { + + uNewAttr = 0; // we cannot assume that if the file hasn't the archive attribute set + + //then it is executable and set execute permissions + + if (!(uAttr & attHidd)) + uNewAttr |= (CREATE_OTHER_PERMISSIONS (4) | + CREATE_GROUP_PERMISSIONS (4)) + | CREATE_USER_PERMISSIONS (4); + + if (!(uAttr & attROnly)) + uNewAttr |= (CREATE_GROUP_PERMISSIONS (2) | + CREATE_USER_PERMISSIONS (2)); + if (uAttr & attDir) + uNewAttr |= UNIX_DIRECTORY_ATTRIBUTE | attDir; + else + uNewAttr |= UNIX_FILE_ATTRIBUTE; + + } + + return uNewAttr; +} + +DWORD AttrMac(DWORD uAttr, bool ) +{ + DWORD uNewAttr = uAttr & (attDir | attROnly); +// if (bFrom) +// { +// +// } +// else +// { +// +// } + return uNewAttr; +} + +// ************************************************************************ +ZIPINLINE bool ZipCompatibility::IsPlatformSupported(int iCode) +{ + return iCode == zcDosFat || iCode == zcUnix || iCode == zcMacintosh + || iCode == zcNtfs || iCode == zcOs2Hpfs; +} + + +void ZipCompatibility::FileNameUpdate(CZipFileHeader& header, bool bFromZip) +{ + int iSysHeader = header.GetSystemCompatibility(); + int iCurSystem = ZipPlatform::GetSystemID(); + if (bFromZip) + { + if (iCurSystem == zcDosFat) + SlashBackslashChg(header.m_pszFileName, true); + if (iSysHeader == zcDosFat) + ZipPlatform::AnsiOem(header.m_pszFileName, false); + } + else + { + if (iSysHeader == zcDosFat) + { + ZipPlatform::AnsiOem(header.m_pszFileName, true); + + + } + SlashBackslashChg(header.m_pszFileName, false); + } +} + +void ZipCompatibility::SlashBackslashChg(CZipAutoBuffer& buffer, bool bReplaceSlash) +{ + char t1 = '\\' /*backslash*/, t2 = '/', c1, c2; + if (bReplaceSlash) + { + c1 = t1; + c2 = t2; + } + else + { + c1 = t2; + c2 = t1; + } + for (DWORD i = 0; i < buffer.GetSize(); i++) + { + if (buffer[i] == c2) + buffer[i] = c1; + } + +} diff --git a/stepmania/src/smpackage/ZipArchive/ZipCompatibility.h b/stepmania/src/smpackage/ZipArchive/ZipCompatibility.h new file mode 100644 index 0000000000..e2d29fe6b8 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/ZipCompatibility.h @@ -0,0 +1,107 @@ +//////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipCompatibility.h $ +// $Archive: /ZipArchive/ZipCompatibility.h $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt +//////////////////////////////////////////////////////////////////////////////// + + +/** +* \file ZipCompatibility.h +* ZipCompatibility namespace declaration. +* +*/ + +#if !defined(AFX_ZIPCOMPATIBILITY_H__8E8B9904_84C7_4B22_B364_A10ED0E7DAD6__INCLUDED_) +#define AFX_ZIPCOMPATIBILITY_H__8E8B9904_84C7_4B22_B364_A10ED0E7DAD6__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +class CZipAutoBuffer; +class CZipFileHeader; + +/** + Functions that provides the proper conversion of attributes + and filename strings between different system platforms. +*/ +namespace ZipCompatibility +{ + /** + The codes of the compatibility of the file attribute information. + \see CZipArchive::GetSystemCompatibility + \see CZipFileHeader::GetSystemCompatibility + \see ZipPlatform::GetSystemID + */ + enum ZipPlatforms + { + zcDosFat, ///< MS-DOS and OS/2 (FAT / VFAT / FAT32 file systems) + zcAmiga, ///< Amiga + zcVaxVms, ///< VAX/VMS + zcUnix, ///< Unix / Linux + zcVmCms, ///< VM/CMS + zcAtari, ///< Atari ST + zcOs2Hpfs, ///< OS/2 H.P.F.S. + zcMacintosh, ///< Macintosh + zcZsystem, ///< Z-System + zcCpm, ///< CP/M + zcNtfs ///< Windows NTFS + }; + +/** + Check whether the system with the given code is supported by the ZipArchive library. + \param iCode + \link #ZipPlatforms the system code \endlink + \return \c true if supported +*/ + bool IsPlatformSupported(int iCode); + + +/** + Convert the system attributes between different system platforms. + It calls one of the converting functions. + \param uAttr + attributes to convert + \param iFromSystem + system code to convert from + \param iToSystem + system code to convert to + \return the converted attributes + \note Throws exceptions. + \see ZipPlatforms +*/ + DWORD ConvertToSystem(DWORD uAttr, int iFromSystem, int iToSystem); + +/** + Convert the filename of the file inside archive. + This conversion may not change the size of the filename, otherwise an + error may occur in #ReadLocal while comparing the filename sizes. + \param header + the file header to have the filename converted + \param bFromZip + if \c true convert the path from the from it is stored in the archive + to the current system compatible form; otherwise vice-versa. + \see CZipCentralDir::ConvertFileName +*/ void FileNameUpdate(CZipFileHeader& header, bool bFromZip); + +/** + Change the slash to backslash or vice-versa in \e buffer. + \param buffer + \param bReplaceSlash + if \c true, change slash to backslash +*/ + void SlashBackslashChg(CZipAutoBuffer& buffer, bool bReplaceSlash); + +}; + +#endif // !defined(AFX_ZIPCOMPATIBILITY_H__8E8B9904_84C7_4B22_B364_A10ED0E7DAD6__INCLUDED_) diff --git a/stepmania/src/smpackage/ZipArchive/ZipException.cpp b/stepmania/src/smpackage/ZipArchive/ZipException.cpp index e9e43fe6a6..ab73213e99 100644 --- a/stepmania/src/smpackage/ZipArchive/ZipException.cpp +++ b/stepmania/src/smpackage/ZipArchive/ZipException.cpp @@ -1,19 +1,34 @@ -// ZipException.cpp: implementation of the CZipException class. -// //////////////////////////////////////////////////////////////////////////////// -// Copyright (C) 2000 Tadeusz Dracz. -// For conditions of distribution and use, see copyright notice in ZipArchive.h +// $Workfile: ZipException.cpp $ +// $Archive: /ZipArchive/ZipException.cpp $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt //////////////////////////////////////////////////////////////////////////////// #include "stdafx.h" #include "ZipException.h" +#include ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// -IMPLEMENT_DYNAMIC( CZipException, CException) +#ifdef _MFC_VER + IMPLEMENT_DYNAMIC( CZipException, CException) +#endif -CZipException::CZipException(int iCause, LPCTSTR lpszZipName):CException(TRUE) +CZipException::CZipException(int iCause, LPCTSTR lpszZipName) +#ifdef _MFC_VER + :CException(TRUE) +#endif { m_iCause = iCause; @@ -26,14 +41,21 @@ CZipException::~CZipException() } -void AfxThrowZipException(int iZipError, LPCTSTR lpszZipName) -{ - throw new CZipException(CZipException::ZipErrToCause(iZipError), lpszZipName); -} +// inline void CZipException::Throw(int iZipError, LPCTSTR lpszZipName) +// { +// #ifdef _MFC_VER +// throw new CZipException(iZipError, lpszZipName); +// #else +// CZipException e(iZipError, lpszZipName); +// throw e; +// #endif +// MSVC++: ignore "Unreachable code" warning here, it's due to +// optimizations +// } -int CZipException::ZipErrToCause(int iZipError) +int CZipException::ZlibErrToZip(int iZlibError) { - switch (iZipError) + switch (iZlibError) { case 2://Z_NEED_DICT: return CZipException::needDict; @@ -51,28 +73,202 @@ int CZipException::ZipErrToCause(int iZipError) return CZipException::bufError; case -6://Z_VERSION_ERROR: return CZipException::versionError; - case ZIP_BADZIPFILE: - return CZipException::badZipFile; - case ZIP_BADCRC: - return CZipException::badCrc; - case ZIP_ABORTED: - return CZipException::aborted; - case ZIP_NOCALLBACK: - return CZipException::noCallback; - case ZIP_NONREMOVABLE: - return CZipException::nonRemovable; - case ZIP_TOOMANYVOLUMES: - return CZipException::tooManyVolumes; - case ZIP_TOOLONGFILENAME: - return CZipException::tooLongFileName; - case ZIP_BADPASSWORD: - return CZipException::badPassword; - case ZIP_CDIR_NOTFOUND: - return CZipException::cdirNotFound; - - default: return CZipException::generic; } } + +#ifdef ZIP_ENABLE_ERROR_DESCRIPTION + +BOOL CZipException::GetErrorMessage(LPTSTR lpszError, UINT nMaxError, + UINT* ) + +{ + if (!lpszError || !nMaxError) + return FALSE; + CZipString sz = GetErrorDescription(); + if (sz.IsEmpty()) + return FALSE; + UINT iLen = sz.GetLength(); + if (nMaxError - 1 < iLen) + iLen = nMaxError - 1; + LPTSTR lpsz = sz.GetBuffer(iLen); +#ifdef _UNICODE + wcsncpy(lpszError, lpsz, iLen); +#else + strncpy(lpszError, lpsz, iLen); +#endif + lpszError[iLen] = _T('\0'); + return TRUE; +} + + +CZipString CZipException::GetErrorDescription() +{ + return GetInternalErrorDescription(m_iCause); +} + + +CZipString CZipException::GetSystemErrorDescription() +{ +#ifdef WIN32 + DWORD x = GetLastError(); + if (x) + { + LPVOID lpMsgBuf; + FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, x, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), + (LPTSTR) &lpMsgBuf, 0, NULL); + CZipString sz = (LPCTSTR)lpMsgBuf; + LocalFree(lpMsgBuf); + return sz; + } +#endif + return GetInternalErrorDescription(errno == 0 ? generic : errno, true); +} + +CZipString CZipException::GetInternalErrorDescription(int iCause, bool bNoLoop) +{ + CZipString sz; + switch (iCause) + { + case EROFS: + sz = _T("Read-only file system"); + break; + case ESPIPE: + sz = _T("Illegal seek"); + break; + case ENOSPC: + sz = _T("No space left on device"); + break; + case EFBIG: + sz = _T("File too large"); + break; + case EMFILE: + sz = _T("Too many open files"); + break; + case ENFILE: + sz = _T("File table overflow"); + break; + case EINVAL: + sz = _T("Invalid argument"); + break; + case EISDIR: + sz = _T("Is a directory"); + break; + case ENOTDIR: + sz = _T("Not a directory"); + break; + case ENODEV: + sz = _T("No such device"); + break; + case EXDEV: + sz = _T("Cross-device link"); + break; + case EEXIST: + sz = _T("File exists"); + break; + case EFAULT: + sz = _T("Bad address"); + break; + case EACCES: + sz = _T("Permission denied"); + break; + case ENOMEM: + sz = _T("Not enough space"); + break; + case EBADF: + sz = _T("Bad file number"); + break; + case ENXIO: + sz = _T("No such device or address"); + break; + case EIO: + sz = _T("I/O error"); + break; + case EINTR: + sz = _T("Interrupted system call"); + break; + case ENOENT: + sz = _T("No such file or directory"); + break; + case EPERM: + sz = _T("Not super-user"); + break; + case badZipFile: + sz = _T("Damaged or not a zip file"); + break; + case badCrc: + sz = _T("Crc mismatched"); + break; + case noCallback: + sz = _T("No disk-spanning callback functor set"); + break; + case aborted: + sz = _T("Disk change aborted"); + break; + case abortedAction: + sz = _T("Action aborted"); + break; + case abortedSafely: + sz = _T("Action aborted safely"); + break; + case nonRemovable: + sz = _T("The device selected for the disk spanning archive is non removable"); + break; + case tooManyVolumes: + sz = _T("Limit of the maximum volumes reached (999)"); + break; + case tooLongFileName: + sz = _T("The filename of the file being added to the archive is too long"); + break; + case badPassword: + sz = _T("Incorrect password set for the file being decrypted"); + break; + case dirWithSize: + sz = _T("During testing found the directory with the size greater than 0"); + break; + case internal: + sz = _T("Internal error"); + break; + case notRemoved: + sz.Format(_T("%s (%s)"), _T("Error while removing a file"), (LPCTSTR)GetSystemErrorDescription()); + break; + case notRenamed: + sz.Format(_T("%s (%s)"), _T("Error while renaming a file"), (LPCTSTR)GetSystemErrorDescription()); + break; + case platfNotSupp: + sz = _T("Cannot create the file for the specified platform"); + break; + case cdirNotFound: + sz = _T("The central directory was not found in the archive (or you were trying to open not the last disk of a multi-disk archive)"); + break; + case streamEnd: + sz = _T("Zlib Library error (end of stream)"); + break; + case errNo: + sz = GetInternalErrorDescription(errno != errNo ? errno : generic); + break; + case streamError: + sz = _T("Zlib library error (stream error)"); + break; + case dataError: + sz = _T("Zlib library error (data error)"); + break; + case memError: + sz = _T("Not enough memory"); + break; + case bufError: + sz = _T("Zlib library error (buffer error)"); + break; + case versionError: + sz = _T("Zlib library error (version error)"); + break; + default: + sz = bNoLoop ? _T("Unknown error") :(LPCTSTR) GetSystemErrorDescription(); + } + return sz; +} + +#endif //ZIP_ENABLE_ERROR_DESCRIPTION diff --git a/stepmania/src/smpackage/ZipArchive/ZipException.h b/stepmania/src/smpackage/ZipArchive/ZipException.h index 93640ca030..68219a9f7a 100644 --- a/stepmania/src/smpackage/ZipArchive/ZipException.h +++ b/stepmania/src/smpackage/ZipArchive/ZipException.h @@ -1,71 +1,224 @@ -// ZipException.h: interface for the CZipException class. +//////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipException.h $ +// $Archive: /ZipArchive/ZipException.h $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) // +// 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. +// +// For the licensing details see the file License.txt //////////////////////////////////////////////////////////////////////////////// -// Copyright (C) 2000 Tadeusz Dracz. -// For conditions of distribution and use, see copyright notice in ZipArchive.h -//////////////////////////////////////////////////////////////////////////////// + +/** +* \file ZipException.h +* Interface for the CZipException class. +* +*/ + #if !defined(AFX_ZIPEXCEPTION_H__E3546921_D728_11D3_B7C7_E77339672847__INCLUDED_) #define AFX_ZIPEXCEPTION_H__E3546921_D728_11D3_B7C7_E77339672847__INCLUDED_ #if _MSC_VER > 1000 #pragma once +#pragma warning( push ) +#pragma warning (disable:4702) // disable "Unreachable code" warning in Throw function in the Release mode #endif // _MSC_VER > 1000 -typedef unsigned short uShort; -// errors number definitions -#define ZIP_BADZIPFILE (-101) -#define ZIP_BADCRC (-102) -#define ZIP_NOCALLBACK (-103) -#define ZIP_ABORTED (-104) -#define ZIP_NONREMOVABLE (-105) -#define ZIP_TOOMANYVOLUMES (-106) -#define ZIP_TOOLONGFILENAME (-107) -#define ZIP_BADPASSWORD (-108) -#define ZIP_CDIR_NOTFOUND (-109) -class CZipException : public CException + +#include "ZipString.h" +#include "ZipBaseException.h" + + +#define ZIP_ENABLE_ERROR_DESCRIPTION + +/** + A class representing exceptions specific to the ZipArchive library. + Library exception class derived in the MFC version from \c CException + and in non-MFC version from \c std::exception. +*/ +class CZipException : public CZipBaseException { public: - DECLARE_DYNAMIC(CZipException) - // convert zlib library and internal error code to a ZipException code - static int ZipErrToCause(int iZipError); - // name of the zip file where the error occured - CString m_szFileName; - enum +/** + \param iCause + error cause (takes one of the #ZipErrors enumeration codes) + \param lpszZipName + the name of the file where the error occurred (if applicable) +*/ + CZipException(int iCause = generic, LPCTSTR lpszZipName = NULL); + + CZipException::CZipException(CZipException& e) + { + m_szFileName = e.m_szFileName; + m_iCause = e.m_iCause; + } + +/** + Throw an exception. + Throw CZipException* in the MFC version of the library + (the object must be deleted with Delete() method) + and CZipException in other versions. + + The arguments are the same as in CZipException(). + + \param iZipError + \param lpszZipName + + \see CZipException() + +*/ + + static void Throw(int iZipError = CZipException::generic, LPCTSTR lpszZipName = NULL) { - noError, // no error - generic, // unknown error - streamEnd, // zlib library errors - needDict, // - errNo, // - streamError, // - dataError, // - memError, // - bufError, // - versionError, // - badZipFile, // damaged or not a zip file - badCrc, // crc mismatched - noCallback, // no callback function set - aborted, // disk change callback function returned false - nonRemovable, // the disk selected for pkSpan archive is non removable - tooManyVolumes, // limit of the maximum volumes reached (999) - tooLongFileName, // the file name of the file added to the archive is too long - badPassword, // incorrect password set for the file being decrypted - cdirNotFound, ///< the central directory was not found in the archive - dirWithSize // during testing: found the directory with the size greater than 0 - }; - // cause - takes one of the codes above - int m_iCause; - CZipException(int iCause = generic, LPCTSTR lpszZipName = NULL); - virtual ~CZipException(); + #ifdef _MFC_VER + throw new CZipException(iZipError, lpszZipName); + #else + CZipException e(iZipError, lpszZipName); + throw e; + #endif + } + +/** + Convert a zlib library error code to a \link #ZipErrors CZipException error code \endlink + \param iZlibError + zlib library error code + \return \link #ZipErrors CZipException error code \endlink +*/ + + static int ZlibErrToZip(int iZlibError); + + +#ifdef ZIP_ENABLE_ERROR_DESCRIPTION + + /** + Return the error description (you need to have defined ZIP_ENABLE_ERROR_DESCRIPTION + in file ZipException.h); undefine this value if you don't want to + store the messages in the library. + + + \return + */ + CZipString GetErrorDescription(); + + + /** + Return the description of the error based on system variables + (this function is provided only for compatibility with MFC \c CException::GetErrorMessage) + + \param lpszError + a pointer to a buffer that will receive the error message + if \c NULL + + \param nMaxError + the maximum number of characters the buffer can hold, including the NULL terminator + + \param UINT* + not used + + \return + \c TRUE if the error string is not empty + \note + the function will not copy more than \c nMaxError – 1 characters + to the buffer, and it always adds a trailing null to end the string; + if the buffer is too small, the error message will be truncated; + + */ + BOOL GetErrorMessage(LPTSTR lpszError, UINT nMaxError, UINT* = NULL); + +#endif //ZIP_ENABLE_ERROR_DESCRIPTION + + /** + The name of the zip file where the error occurred. + */ + CZipString m_szFileName; + + /** + The codes of errors thrown by the ZipArchive library + */ + enum ZipErrors + { + noError, ///< no error +// 1 - 42 reserved for errno (from STL) values - used only in non-MFC versions +// 43 - 99 reserved + generic = 100, ///< unknown error + badZipFile, ///< damaged or not a zip file + badCrc, ///< crc mismatched + noCallback, ///< no disk-spanning callback functor set + aborted, ///< callback functor's method Callback returned \c false while disk change in the disk-spanning archive + abortedAction, ///< callback functor's method Callback returned \c false in CZipArchive class members: AddNewFile, ExtractFile, TestFile, DeleteFile or DeleteFiles + abortedSafely, ///< the same as above, you may be sure that the operation was successfully completed before or it didn't cause any damage in the archive (break when counting before deleting files; see CZipArchive::cbDeleteCnt) + nonRemovable, ///< the disk selected for pkzipSpan archive is non removable + tooManyVolumes, ///< limit of the maximum volumes reached (999) + tooLongFileName, ///< the filename of the file added to the archive is too long + badPassword, ///< incorrect password set for the file being decrypted + dirWithSize, ///< during testing: found the directory with the size greater than 0 + internal, ///< internal error + notRemoved, ///< error while removing a file (under Windows call GetLastError() to find out more) + notRenamed, ///< error while renaming a file (under Windows call GetLastError() to find out more) + platfNotSupp, ///< the platform that the zip file is being created for is not supported + cdirNotFound, ///< the central directory was not found in the archive (it is thrown also when the last disk of multi-disk archive is not in the drive when opening the archive) + streamEnd = 500, ///< zlib library error + needDict, ///< zlib library error + errNo, ///< zlib library error + streamError, ///< zlib library error + dataError, ///< zlib library error + memError, ///< zlib library error thrown by CZipMemFile as well + bufError, ///< zlib library error + versionError, ///< zlib library error + }; + + + + /** + A cause of the error - takes one of the #ZipErrors enumeration codes. + */ + int m_iCause; + + + virtual ~CZipException(); +protected: + +#ifdef ZIP_ENABLE_ERROR_DESCRIPTION + + + /** + Return the error description + + \param iCause : error number + \param bNoLoop: if \c true tells not to search for en error description, + it the error is generic + + \return + */ + CZipString GetInternalErrorDescription(int iCause, bool bNoLoop = false); + + + /** + Return the description of the error based on system variables + + + \return + */ + CZipString GetSystemErrorDescription(); + + +#endif //ZIP_ENABLE_ERROR_DESCRIPTION + +#ifdef _MFC_VER + DECLARE_DYNAMIC(CZipException) + #pragma warning( pop ) +#endif }; -// throw zip exception -// Parameters: -// iZipError - zlib or internal error code -// lpszZipName - name of the file where the error occured -void AfxThrowZipException(int iZipError = 1000, LPCTSTR lpszZipName = NULL); #endif // !defined(AFX_ZIPEXCEPTION_H__E3546921_D728_11D3_B7C7_E77339672847__INCLUDED_) + + diff --git a/stepmania/src/smpackage/ZipArchive/ZipFile.cpp b/stepmania/src/smpackage/ZipArchive/ZipFile.cpp new file mode 100644 index 0000000000..9cabf1251c --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/ZipFile.cpp @@ -0,0 +1,54 @@ +//////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipFile.cpp $ +// $Archive: /ZipArchive/ZipFile.cpp $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt +//////////////////////////////////////////////////////////////////////////////// + +#include "stdafx.h" +#include "ZipFile.h" + +////////////////////////////////////////////////////////////////////// +// Construction/Destruction +////////////////////////////////////////////////////////////////////// + +// IMPLEMENT_DYNAMIC(CZipAbstractFile, CFile) +IMPLEMENT_DYNAMIC(CZipFile, CFile) + +CZipFile::CZipFile() +{ +} + +CZipFile::~CZipFile() +{ + +} + + +// __int64 CZipFile::Seek(__int64 dOff, UINT nFrom) +// { +// ASSERT_VALID(this); +// ASSERT(m_hFile != (UINT)hFileNull); +// ASSERT(nFrom == begin || nFrom == end || nFrom == current); +// ASSERT(begin == FILE_BEGIN && end == FILE_END && current == FILE_CURRENT); +// LARGE_INTEGER li; +// li.QuadPart = dOff; +// +// li.LowPart = ::SetFilePointer((HANDLE)m_hFile, li.LowPart, &li.HighPart, (DWORD)nFrom); +// DWORD dw = GetLastError(); +// if ((li.LowPart == (DWORD)-1) && (dw != NO_ERROR)) +// { +// CFileException::ThrowOsError((LONG)dw); +// } +// +// return li.QuadPart; +// } diff --git a/stepmania/src/smpackage/ZipArchive/ZipFile.h b/stepmania/src/smpackage/ZipArchive/ZipFile.h new file mode 100644 index 0000000000..af5b103704 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/ZipFile.h @@ -0,0 +1,67 @@ +//////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipFile.h $ +// $Archive: /ZipArchive/ZipFile.h $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt +//////////////////////////////////////////////////////////////////////////////// + +#if !defined(AFX_ZIPFILE_H__80609DE0_2C6D_4C94_A90C_0BE34A50C769__INCLUDED_) +#define AFX_ZIPFILE_H__80609DE0_2C6D_4C94_A90C_0BE34A50C769__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 +#include "ZipAbstractFile.h" + +class CZipFile :public CZipAbstractFile, public CFile +{ +public: + DECLARE_DYNAMIC(CZipFile) +// __int64 Seek(__int64 dOff, UINT nFrom); + void Flush(){CFile::Flush();} + DWORD GetPosition() const {return CFile::GetPosition() ;} + CZipString GetFilePath() const {return CFile::GetFilePath();} + void SetLength(long nNewLen) {CFile::SetLength(nNewLen);} + UINT Read(void *lpBuf, UINT nCount){return CFile::Read(lpBuf, nCount);} + void Write(const void* lpBuf, UINT nCount){CFile::Write(lpBuf, nCount);} + long Seek(long lOff, int nFrom){return CFile::Seek(lOff, nFrom);} + DWORD GetLength() const {return CFile::GetLength();} + bool Open( LPCTSTR lpszFileName, UINT nOpenFlags, bool bThrowExc) + { + CFileException* e = new CFileException; + bool bRet = CFile::Open(lpszFileName, nOpenFlags, e) != 0; + if (!bRet && bThrowExc) + throw e; + e->Delete(); + return bRet; + + } + CZipFile(); + bool IsClosed() const + { + return m_hFile == (UINT)CFile::hFileNull; + } + + + CZipFile( LPCTSTR lpszFileName, UINT nOpenFlags ):CFile(lpszFileName, nOpenFlags) + { + } + void Close( ) + { + if (!IsClosed()) + CFile::Close(); + } + virtual ~CZipFile(); + +}; + +#endif // !defined(AFX_ZIPFILE_H__80609DE0_2C6D_4C94_A90C_0BE34A50C769__INCLUDED_) diff --git a/stepmania/src/smpackage/ZipArchive/ZipFileHeader.cpp b/stepmania/src/smpackage/ZipArchive/ZipFileHeader.cpp index 5487e02d44..bf74e89e1c 100644 --- a/stepmania/src/smpackage/ZipArchive/ZipFileHeader.cpp +++ b/stepmania/src/smpackage/ZipArchive/ZipFileHeader.cpp @@ -1,20 +1,32 @@ -// ZipFileHeader.cpp: implementation of the CZipFileHeader class. +//////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipFileHeader.cpp $ +// $Archive: /ZipArchive/ZipFileHeader.cpp $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) // +// 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. +// +// For the licensing details see the file License.txt //////////////////////////////////////////////////////////////////////////////// -// Copyright (C) 2000 Tadeusz Dracz. -// For conditions of distribution and use, see copyright notice in ZipArchive.h -//////////////////////////////////////////////////////////////////////////////// + #include "stdafx.h" +#include "zlib/zlib.h" #include "ZipFileHeader.h" -#include "zlib.h" #include "ZipAutoBuffer.h" #include "ZipArchive.h" +#include "ZipPlatform.h" +#include "ZipCompatibility.h" +#include + +#define FILEHEADERSIZE 46 +#define LOCALFILEHEADERSIZE 30 -#define ZipFileHeaderSIZE 46 -#define LOCALZipFileHeaderSIZE 30 -#define VERSIONMADEBY 20 -#define ENCR_HEADER_LEN 12 ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// @@ -22,9 +34,10 @@ char CZipFileHeader::m_gszSignature[] = {0x50, 0x4b, 0x01, 0x02}; char CZipFileHeader::m_gszLocalSignature[] = {0x50, 0x4b, 0x03, 0x04}; CZipFileHeader::CZipFileHeader() { - m_uExternalAttr = FILE_ATTRIBUTE_ARCHIVE; - m_uModDate = m_uModTime = m_uInternalAttr = 0; + m_uExternalAttr = 0;//ZipPlatform::GetDefaultAttributes(); + m_uModDate = m_uModTime = 0; m_uMethod = Z_DEFLATED; +// SetSystemCompatibility(ZipPlatform::m_sSystemID); } CZipFileHeader::~CZipFileHeader() @@ -39,8 +52,8 @@ bool CZipFileHeader::Read(CZipStorage *pStorage) // m_pszComment.Release(); // m_pszFileName.Release(); WORD uFileNameSize, uCommentSize, uExtraFieldSize; - CZipAutoBuffer buf(ZipFileHeaderSIZE); - pStorage->Read(buf, ZipFileHeaderSIZE, true); + CZipAutoBuffer buf(FILEHEADERSIZE); + pStorage->Read(buf, FILEHEADERSIZE, true); memcpy(&m_szSignature, buf, 4); memcpy(&m_uVersionMadeBy, buf + 4, 2); memcpy(&m_uVersionNeeded, buf + 6, 2); @@ -65,26 +78,34 @@ bool CZipFileHeader::Read(CZipStorage *pStorage) int iCurDsk = pStorage->GetCurrentDisk(); m_pszFileName.Allocate(uFileNameSize); // don't add NULL at the end - pStorage->m_pFile->Read(m_pszFileName, uFileNameSize); + pStorage->Read(m_pszFileName, uFileNameSize, true); if (uExtraFieldSize) { ASSERT(!m_pExtraField.IsAllocated()); m_pExtraField.Allocate(uExtraFieldSize); - pStorage->m_pFile->Read(m_pExtraField, uExtraFieldSize); + pStorage->Read(m_pExtraField, uExtraFieldSize, true); } if (uCommentSize) { m_pszComment.Allocate(uCommentSize); - pStorage->m_pFile->Read(m_pszComment, uCommentSize); + pStorage->Read(m_pszComment, uCommentSize, true); } - - return pStorage->GetCurrentDisk() == iCurDsk; // check that the while header is on the one disk + + return pStorage->GetCurrentDisk() == iCurDsk; // check that the whole header is on the one disk } -// return CTime representation of m_uModDate, m_uModTime -CTime CZipFileHeader::GetTime() +time_t CZipFileHeader::GetTime()const { - return CTime(m_uModDate, m_uModTime); + struct tm atm; + atm.tm_sec = (m_uModTime & ~0xFFE0) << 1; + atm.tm_min = (m_uModTime & ~0xF800) >> 5; + atm.tm_hour = m_uModTime >> 11; + + atm.tm_mday = m_uModDate & ~0xFFE0; + atm.tm_mon = ((m_uModDate & ~0xFE00) >> 5) - 1; + atm.tm_year = (m_uModDate >> 9) + 80; + atm.tm_isdst = -1; + return mktime(&atm); } // write the header to the central dir @@ -92,7 +113,7 @@ DWORD CZipFileHeader::Write(CZipStorage *pStorage) { WORD uFileNameSize = GetFileNameSize(), uCommentSize = GetCommentSize(), uExtraFieldSize = GetExtraFieldSize(); - DWORD iSize = GetSize(); + DWORD iSize = FILEHEADERSIZE + uFileNameSize + uCommentSize + uExtraFieldSize; CZipAutoBuffer buf(iSize); memcpy(buf, &m_szSignature, 4); memcpy(buf + 4, &m_uVersionMadeBy, 2); @@ -124,11 +145,10 @@ DWORD CZipFileHeader::Write(CZipStorage *pStorage) return iSize; } -// read local header bool CZipFileHeader::ReadLocal(CZipStorage *pStorage, WORD& iLocExtrFieldSize) { - char buf[LOCALZipFileHeaderSIZE]; - pStorage->Read(buf, LOCALZipFileHeaderSIZE, true); + char buf[LOCALFILEHEADERSIZE]; + pStorage->Read(buf, LOCALFILEHEADERSIZE, true); if (memcmp(buf, m_gszLocalSignature, 4) != 0) return false; @@ -148,26 +168,26 @@ bool CZipFileHeader::ReadLocal(CZipStorage *pStorage, WORD& iLocExtrFieldSize) return false; memcpy(&iLocExtrFieldSize, buf + 28, 2); - pStorage->m_pFile->Seek(uFileNameSize, CFile::current); + pStorage->m_pFile->Seek(uFileNameSize, CZipAbstractFile::current); return true; } -// set the m_uModDate, m_uModTime values using CTime object -void CZipFileHeader::SetTime(const CTime &time) +void CZipFileHeader::SetTime(const time_t & ttime) { - WORD year = (WORD)time.GetYear(); + tm* gt = localtime(&ttime); + WORD year = (WORD)(gt->tm_year + 1900); if (year <= 1980) year = 0; else year -= 1980; - m_uModDate = (WORD) (time.GetDay() + (time.GetMonth() << 5) + (year << 9)); - m_uModTime = (WORD) ((time.GetSecond() >> 1) + (time.GetMinute() << 5) + - (time.GetHour() << 11)); + m_uModDate = (WORD) (gt->tm_mday + ((gt->tm_mon + 1)<< 5) + (year << 9)); + m_uModTime = (WORD) ((gt->tm_sec >> 1) + (gt->tm_min << 5) + + (gt->tm_hour << 11)); } // the buffer contains crc32, compressed and uncompressed sizes to be compared // with the actual values -bool CZipFileHeader::CheckCrcAndSizes(char *pBuf) +bool CZipFileHeader::CheckCrcAndSizes(char *pBuf) const { return (memcmp(pBuf, &m_uCrc32, 4) == 0) && (memcmp(pBuf + 4, &m_uComprSize, 4) == 0) && (memcmp(pBuf + 8, &m_uUncomprSize, 4) == 0); @@ -178,7 +198,7 @@ void CZipFileHeader::WriteLocal(CZipStorage& storage) { // extra field is local by now WORD uFileNameSize = GetFileNameSize(), uExtraFieldSize = GetExtraFieldSize(); - DWORD iLocalSize = LOCALZipFileHeaderSIZE + uExtraFieldSize + uFileNameSize; + DWORD iLocalSize = LOCALFILEHEADERSIZE + uExtraFieldSize + uFileNameSize; CZipAutoBuffer buf(iLocalSize); memcpy(buf, m_gszLocalSignature, 4); memcpy(buf + 4, &m_uVersionNeeded, 2); @@ -194,7 +214,7 @@ void CZipFileHeader::WriteLocal(CZipStorage& storage) memcpy(buf + 30, m_pszFileName, uFileNameSize); memcpy(buf + 30 + uFileNameSize, m_pExtraField, uExtraFieldSize); - // possible disk change before writting to the file in the disk spanning mode + // possible disk change before writing to the file in the disk spanning mode // so write the local header first storage.Write(buf, iLocalSize, true); // it was only local information, use CZipArchive::SetExtraField to set the file extra field in the central directory @@ -209,8 +229,8 @@ bool CZipFileHeader::PrepareData(int iLevel, bool bExtraHeader, bool bEncrypted) { memcpy(m_szSignature, m_gszSignature, 4); m_uInternalAttr = 0; - m_uVersionMadeBy = VERSIONMADEBY; - m_uVersionNeeded = 20; + m_uVersionNeeded = IsDirectory() ? 0xa : 0x14; // 1.0 or 2.0 + SetVersion((WORD)(0x14)); m_uCrc32 = 0; m_uComprSize = 0; @@ -242,7 +262,7 @@ bool CZipFileHeader::PrepareData(int iLevel, bool bExtraHeader, bool bEncrypted) if (bEncrypted) { - m_uComprSize = ENCR_HEADER_LEN; // encrypted header + m_uComprSize = ZIPARCHIVE_ENCR_HEADER_LEN; // encrypted header m_uFlag |= 9; // encrypted file } @@ -250,38 +270,30 @@ bool CZipFileHeader::PrepareData(int iLevel, bool bExtraHeader, bool bEncrypted) || m_pExtraField.GetSize() > USHRT_MAX); } -// fill the buffer with the current values -void CZipFileHeader::GetCrcAndSizes(char * pBuffer) +void CZipFileHeader::GetCrcAndSizes(char * pBuffer)const { memcpy(pBuffer, &m_uCrc32, 4); memcpy(pBuffer + 4, &m_uComprSize, 4); memcpy(pBuffer + 8, &m_uUncomprSize, 4); } -DWORD CZipFileHeader::GetSize() +DWORD CZipFileHeader::GetSize(bool bLocal)const { - return ZipFileHeaderSIZE + GetExtraFieldSize() + GetFileNameSize() + GetCommentSize(); + if (bLocal) + return LOCALFILEHEADERSIZE + GetExtraFieldSize() + GetFileNameSize(); + else + return FILEHEADERSIZE + GetExtraFieldSize() + GetFileNameSize() + GetCommentSize(); } -bool CZipFileHeader::IsEncrypted() -{ - return (m_uFlag & (WORD) 1) != 0; -} - -bool CZipFileHeader::IsDataDescr() -{ - return (m_uFlag & (WORD) 8) != 0; -} - bool CZipFileHeader::SetComment(LPCTSTR lpszComment) { return CZipArchive::WideToSingle(lpszComment, m_pszComment) != -1; } -CString CZipFileHeader::GetComment() +CZipString CZipFileHeader::GetComment() const { - CString temp; + CZipString temp; CZipArchive::SingleToWide(m_pszComment, temp); return temp; @@ -289,41 +301,38 @@ CString CZipFileHeader::GetComment() bool CZipFileHeader::SetFileName(LPCTSTR lpszFileName) { + return CZipArchive::WideToSingle(lpszFileName, m_pszFileName) != -1; } -CString CZipFileHeader::GetFileName() +CZipString CZipFileHeader::GetFileName()const { - CString temp; + CZipString temp; CZipArchive::SingleToWide(m_pszFileName, temp); return temp; } - -void CZipFileHeader::SlashChange(bool bWindowsStyle) +bool CZipFileHeader::IsDirectory()const { - char t1 = '\\', t2 = '/', c1, c2; - if (bWindowsStyle) - { - c1 = t1; - c2 = t2; - } - else - { - c1 = t2; - c2 = t1; - } - for (DWORD i = 0; i < m_pszFileName.GetSize(); i++) - { - if (m_pszFileName[i] == c2) - m_pszFileName[i] = c1; - } + return ZipPlatform::IsDirectory(GetSystemAttr()); } -void CZipFileHeader::AnsiOem(bool bAnsiToOem) +DWORD CZipFileHeader::GetSystemAttr()const { - if (bAnsiToOem) - CharToOemBuffA(m_pszFileName, m_pszFileName, m_pszFileName.GetSize()); + int iSystemComp = GetSystemCompatibility(); + if (ZipCompatibility::IsPlatformSupported(iSystemComp)) + { + if (!m_uExternalAttr && CZipPathComponent::HasEndingSeparator(GetFileName())) + return ZipPlatform::GetDefaultDirAttributes(); // can happen + else + return ZipCompatibility::ConvertToSystem(m_uExternalAttr, iSystemComp, ZipPlatform::GetSystemID()); + } else - OemToCharBuffA(m_pszFileName, m_pszFileName, m_pszFileName.GetSize()); + return CZipPathComponent::HasEndingSeparator(GetFileName()) ? ZipPlatform::GetDefaultDirAttributes() : ZipPlatform::GetDefaultAttributes(); +} + + +void CZipFileHeader::SetSystemAttr(DWORD uAttr) +{ + m_uExternalAttr = ZipCompatibility::ConvertToSystem(uAttr, ZipPlatform::GetSystemID(), GetSystemCompatibility()); } diff --git a/stepmania/src/smpackage/ZipArchive/ZipFileHeader.h b/stepmania/src/smpackage/ZipArchive/ZipFileHeader.h index b582345c38..c969bfa084 100644 --- a/stepmania/src/smpackage/ZipArchive/ZipFileHeader.h +++ b/stepmania/src/smpackage/ZipArchive/ZipFileHeader.h @@ -1,106 +1,351 @@ -// ZipFileHeader.h: interface for the CZipFileHeader class. -// //////////////////////////////////////////////////////////////////////////////// -// Copyright (C) 2000 Tadeusz Dracz. -// For conditions of distribution and use, see copyright notice in ZipArchive.h +// $Workfile: ZipFileHeader.h $ +// $Archive: /ZipArchive/ZipFileHeader.h $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt //////////////////////////////////////////////////////////////////////////////// -#if !defined(AFX_ZipFileHeader_H__0081FC65_C9C9_4D48_AF72_DBF37DF5E0CF__INCLUDED_) -#define AFX_ZipFileHeader_H__0081FC65_C9C9_4D48_AF72_DBF37DF5E0CF__INCLUDED_ +/** +* \file ZipFileHeader.h +* Interface for the CZipFileHeader class. +* +*/ + +#if !defined(AFX_FILEHEADER_H__0081FC65_C9C9_4D48_AF72_DBF37DF5E0CF__INCLUDED_) +#define AFX_FILEHEADER_H__0081FC65_C9C9_4D48_AF72_DBF37DF5E0CF__INCLUDED_ #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER > 1000 -#include "ZipException.h" #include "ZipStorage.h" #include "ZipAutoBuffer.h" +#include "sys/types.h" +#include "ZipCompatibility.h" +#define ZIPARCHIVE_ENCR_HEADER_LEN 12 +/** + Representation of a single file stored in the zip archive. + Modify all the class attributes BEFORE adding a file to and archive + ( using CZipArchive::OpenNewFile ). + It is not possible to modify the data of the existing files in the archive + (it would mean updating all the information in the local headers + and the offsets would be changed as well when the filename would changed its size) +*/ class CZipFileHeader { + friend class CZipCentralDir; + friend class CZipArchive; + friend void ZipCompatibility::FileNameUpdate(CZipFileHeader&, bool); public: -// convert characters in the filename from oem to ansi or vice-versa - void AnsiOem(bool bAnsiToOem); -// change slash to backslash or vice-versa - void SlashChange(bool bWindowsStyle); -// return the filename size in characters (without NULL); - WORD GetFileNameSize(){return (WORD)m_pszFileName.GetSize();} -// return the comment size in characters (without NULL); - WORD GetCommentSize(){return (WORD)m_pszComment.GetSize();} -// return the extra field size in characters (without NULL); - WORD GetExtraFieldSize(){return (WORD)m_pExtraField.GetSize();} + CZipFileHeader(); + virtual ~CZipFileHeader(); - CString GetFileName(); -// return true if confersion from unicode to single byte was successful + +// +/** + Change slash to backslash or vice-versa in #m_pszFileName. + \param bWindowsStyle + if \c true, change slash to backslash; otherwise vice versa; +*/ + +/** + \return the filename size in characters (without NULL) +*/ + WORD GetFileNameSize()const {return (WORD)m_pszFileName.GetSize();} + +/** + \return the comment size in characters (without NULL) +*/ + WORD GetCommentSize() const {return (WORD)m_pszComment.GetSize();} + +/** + \return the extra field size in characters +*/ + WORD GetExtraFieldSize()const{return (WORD)m_pExtraField.GetSize();} + +/** + \return the filename +*/ + CZipString GetFileName()const; + +/** + Set the filename + \param lpszFileName + + \return + \c true, if conversion from UNICODE to single byte was successful + (or if there was no conversion needed or possible); otherwise \c false; +*/ bool SetFileName(LPCTSTR lpszFileName); - CString GetComment(); -// return true if confersion from unicode to single byte was successful + +/** + \return the file comment +*/ + CZipString GetComment() const; + +/** + Set the file comment. + \param lpszComment + + \return + \c true, if conversion from UNICODE to single byte was successful + (or if there was no conversion needed or possible); otherwise \c false; + +*/ bool SetComment(LPCTSTR lpszComment); -// return true if the data descriptor is present - bool IsDataDescr(); -// return true if the file is encrypted - bool IsEncrypted(); -// central file header signature 4 bytes (0x02014b50) - char m_szSignature[4]; -// version made by 2 bytes - WORD m_uVersionMadeBy; -// version needed to extract 2 bytes - WORD m_uVersionNeeded; -// general purpose bit flag 2 bytes - WORD m_uFlag; -// compression method 2 bytes - WORD m_uMethod; -// last mod file time 2 bytes - WORD m_uModTime; -// last mod file date 2 bytes - WORD m_uModDate; -// crc-32 4 bytes - DWORD m_uCrc32; -// compressed size 4 bytes - DWORD m_uComprSize; -// uncompressed size 4 bytes - DWORD m_uUncomprSize; + +/** + \return \c true if the data descriptor is present +*/ + bool IsDataDescr()const { return (m_uFlag & (WORD) 8) != 0;} + + + /** + \return + get the effective compressed size: if the file is encrypted, return less by the size of the encryption header + */ + DWORD GetEffComprSize() + { + return m_uComprSize - (IsEncrypted() ? ZIPARCHIVE_ENCR_HEADER_LEN : 0); + } + /** + \return + \c false if the file should be stored instead of being compressed + */ + bool CompressionEfficient() + { + DWORD uBefore = m_uUncomprSize; + // ignore the length of encryption header + DWORD uAfter = GetEffComprSize(); + return uAfter <= uBefore; + } + + /** + \return the compression ratio of the file + */ + float GetCompressionRatio() + { + return m_uUncomprSize ? ((float)m_uComprSize) * 100 / m_uUncomprSize : 0; + } + +/** + \return \c if the file is encrypted ( a password is needed to extract this file) + \see CZipArchive::SetPassword +*/ + bool IsEncrypted()const { return (m_uFlag & (WORD) 1) != 0;} + + char m_szSignature[4]; ///< central file header signature + WORD m_uVersionMadeBy; ///< version made by and system compatibility + WORD m_uVersionNeeded; ///< version needed to extract + WORD m_uFlag; ///< general purpose bit flag + WORD m_uMethod; ///< compression method + WORD m_uModTime; ///< last mod file time + WORD m_uModDate; ///< last mod file date + DWORD m_uCrc32; ///< crc-32 + DWORD m_uComprSize; ///< compressed size + DWORD m_uUncomprSize; ///< uncompressed size // filename length 2 bytes // WORD m_uFileNameSize; // extra field length 2 bytes // WORD m_uExtraFieldSize; // file comment length 2 bytes // WORD m_uCommentSize; -// disk number start 2 bytes - WORD m_uDiskStart; -// internal file attributes 2 bytes - WORD m_uInternalAttr; -// external file attributes 4 bytes - DWORD m_uExternalAttr; -// relative offset of local header 4 bytes - DWORD m_uOffset; -// extra field (variable size) - CZipAutoBuffer m_pExtraField; - - CZipFileHeader(); - virtual ~CZipFileHeader(); - CTime GetTime(); - void SetTime(const CTime& time); - static char m_gszSignature[]; - static char m_gszLocalSignature[]; -// return the total size of the structure as stored in the central directory - DWORD GetSize(); + WORD m_uDiskStart; ///< disk number start + WORD m_uInternalAttr; ///< internal file attributes protected: -// filename (variable size) + DWORD m_uExternalAttr; ///< external file attributes +public: + DWORD m_uOffset; ///< relative offset of local header + CZipAutoBuffer m_pExtraField; ///< extra field (variable size) + static char m_gszSignature[]; ///< central file header signature + static char m_gszLocalSignature[]; ///< local file header signature + + +/** + Set #m_uModDate, #m_uModTime + (file modification time) + \param const time_t& ttime + \see GetTime +*/ + void SetTime(const time_t& ttime); + +/** + \return the modification time + \see SetTime +*/ + time_t GetTime()const; + +/** + \param bLocal + if \c true return the local file header size or in the central directory otherwise + \return the total size of the structure depending on the \e bLocal parameter +*/ + DWORD GetSize(bool bLocal = false)const; + +/** + \return the system compatibility of the current file as + the one of ZipCompatibility::ZipPlatforms values; + usually the same as CZipArchive::GetSystemComatibility. + Software can use this information e.g. to determine the line + record format for text files etc. + ZipArchive library uses it to perform a proper attributes conversion. + + \see CZipArchive::GetSystemComatibility + \see ZipPlatform::GetSystemID +*/ + int GetSystemCompatibility()const + { + return (m_uVersionMadeBy & 0xFF00) >> 8; + } + +/** + \return the attributes of the file converted to the current system compatible value + \note + - Throws exception if the archive system or the current system + is not supported by the ZipArchive library. + - (only Linux version): After obtaining the attributes, you need to shift them right by 16 +*/ + + DWORD GetSystemAttr()const; + + /** + \return + the original attributes as stored in the archive (without performing any conversion) + */ + DWORD GetOriginalAttributes() const {return m_uExternalAttr;} + +/** + \return \c true, if this object represents a directory; otherwise \c false; + If #m_uExternalAttr value is zero, the function check for a presence of a path + separator at the end of the file name. If it is present, it is assumed to be a directory. +*/ + bool IsDirectory()const; + + +protected: + +/** + Set the system compatibility of the file. + \param iSystemID + one of ZipCompatibility::ZipPlatforms values + \see CZipArchive::GetSystemCompatibility +*/ + void SetSystemCompatibility(int iSystemID) + { + m_uVersionMadeBy &= 0x00FF; + m_uVersionMadeBy |= (WORD)(iSystemID << 8); + } + +/** + Set the system attributes + if you wish to set the attributes of this structure use CZipArchive::SetFileHeaderAttr() + \param uAttr + attributes to set + \note Throws exceptions if the archive system or the current system + is not supported by the ZipArchive library. + \see CZipArchive::SetFileHeaderAttr + \see GetSystemAttr + \see SetSystemCompatibility +*/ + void SetSystemAttr(DWORD uAttr); + +/** + Set the version made by number. + \param uVersion +*/ + void SetVersion(WORD uVersion) + { + if ((m_uVersionMadeBy & 0x00FF) != (uVersion & 0x00FF)) + { + m_uVersionMadeBy &= 0xFF00; + m_uVersionMadeBy |= (WORD)(uVersion & 0x00FF); + } + } + + /** + a filename + */ CZipAutoBuffer m_pszFileName; -// file comment (variable size) + + /** + a file comment + */ CZipAutoBuffer m_pszComment; - void GetCrcAndSizes(char * pBuffer); +/** + Fill the buffer with the current values of crc and compressed and + uncompressed sizes of the file. + \param pBuffer + +*/ + void GetCrcAndSizes(char* pBuffer)const; + +/** + Check whether the actual values of crc and compressed and + uncompressed sizes of the file are the same as defined in + the file header. + \param pBuf + buffer with the mentioned data + \return \c true if they are the same; otherwise \c false; +*/ + bool CheckCrcAndSizes(char* pBuf) const; + + +/** + Prepare the data for the class while adding a new file. + Called by CZipArchive::OpenNewFile + \param iLevel + a compression level + \param bExtraHeader + \c true, if the data descriptor will be present + \param bEncrypted + \c true, if the file will be encrypted + \return \c true if the sizes of the filename, extra field and comments + does not exceed \c unsigned \c short maximum value; otherwise \c false; +*/ bool PrepareData(int iLevel, bool bExtraHeader, bool bEncrypted); +/** + Write the local file header to the \e storage + \param storage + \note Throws exceptions. +*/ void WriteLocal(CZipStorage& storage); - bool CheckCrcAndSizes(char* pBuf); - friend class CZipCentralDir; - friend class CZipArchive; + +/** + Read the file header from the central directory record from \e pStorage. + \param *pStorage + \return \c true if the whole file header is on one disk in + a multi-disk archive; otherwise \c false; + \note Throws exceptions. +*/ bool Read(CZipStorage *pStorage); +/** + Read the local file header from \e pStorage and check for consistency. + \param *pStorage + \param iLocExtrFieldSize + receives local extra field size + \return \c false, if something goes wrong; otherwise \c true; + \note Throws exceptions. +*/ bool ReadLocal(CZipStorage *pStorage, WORD& iLocExtrFieldSize); +/** + Write the file header to \e pStorage. + \param *pStorage + \return the size of the file header + \note Throws exceptions. +*/ DWORD Write(CZipStorage *pStorage); }; -#endif // !defined(AFX_ZipFileHeader_H__0081FC65_C9C9_4D48_AF72_DBF37DF5E0CF__INCLUDED_) +#endif // !defined(AFX_FILEHEADER_H__0081FC65_C9C9_4D48_AF72_DBF37DF5E0CF__INCLUDED_) diff --git a/stepmania/src/smpackage/ZipArchive/ZipFileMapping.h b/stepmania/src/smpackage/ZipArchive/ZipFileMapping.h new file mode 100644 index 0000000000..6d1dd50e2c --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/ZipFileMapping.h @@ -0,0 +1,80 @@ +//////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipFileMapping.h $ +// $Archive: /ZipArchive/ZipFileMapping.h $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt +// +// Check the site http://www.artpol-software.com for the updated version of the library. +//////////////////////////////////////////////////////////////////////////////// + + +#if !defined(AFX_AUTOHANDLE_H__D68326EA_D7FA_4792_AB1F_68D09533E399__INCLUDED_) +#define AFX_AUTOHANDLE_H__D68326EA_D7FA_4792_AB1F_68D09533E399__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#include "ZipFile.h" +namespace ziparchv +{ + + + struct CZipFileMapping + { + CZipFileMapping() + { + m_hFileMap = NULL; + m_pFileMap = NULL; + } + bool CreateMapping(CZipFile* pFile) + { + if (!pFile) + return false; + m_hFileMap = CreateFileMapping((HANDLE)pFile->operator HFILE(), NULL, PAGE_READWRITE, + 0, 0, _T("ZipArchive Mapping File")); + if (!m_hFileMap) + return false; + // Get pointer to memory representing file + m_pFileMap = MapViewOfFile(m_hFileMap, FILE_MAP_WRITE, 0, 0, 0); + return (m_pFileMap != NULL); + } + void RemoveMapping() + { + if (m_pFileMap) + { + UnmapViewOfFile(m_pFileMap); + m_pFileMap = NULL; + } + if (m_hFileMap) + { + CloseHandle(m_hFileMap); + m_hFileMap = NULL; + } + + } + ~CZipFileMapping() + { + RemoveMapping(); + } + char* GetMappedMemory() + { + return reinterpret_cast (m_pFileMap); + } + protected: + HANDLE m_hFileMap; + LPVOID m_pFileMap; + + }; +} + +#endif // !defined(AFX_AUTOHANDLE_H__D68326EA_D7FA_4792_AB1F_68D09533E399__INCLUDED_) diff --git a/stepmania/src/smpackage/ZipArchive/ZipInternalInfo.cpp b/stepmania/src/smpackage/ZipArchive/ZipInternalInfo.cpp index 653310dce0..91aecf03de 100644 --- a/stepmania/src/smpackage/ZipArchive/ZipInternalInfo.cpp +++ b/stepmania/src/smpackage/ZipArchive/ZipInternalInfo.cpp @@ -1,8 +1,17 @@ -// ZipInternalInfo.cpp: implementation of the CZipInternalInfo class. -// //////////////////////////////////////////////////////////////////////////////// -// Copyright (C) 2000 Tadeusz Dracz. -// For conditions of distribution and use, see copyright notice in ZipArchive.h +// $Workfile: ZipInternalInfo.cpp $ +// $Archive: /ZipArchive/ZipInternalInfo.cpp $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt //////////////////////////////////////////////////////////////////////////////// #include "stdafx.h" diff --git a/stepmania/src/smpackage/ZipArchive/ZipInternalInfo.h b/stepmania/src/smpackage/ZipArchive/ZipInternalInfo.h index 86792fc989..61e567f652 100644 --- a/stepmania/src/smpackage/ZipArchive/ZipInternalInfo.h +++ b/stepmania/src/smpackage/ZipArchive/ZipInternalInfo.h @@ -1,10 +1,24 @@ -// ZipInternalInfo.h: interface for the CZipInternalInfo class. -// //////////////////////////////////////////////////////////////////////////////// -// Copyright (C) 2000 Tadeusz Dracz. -// For conditions of distribution and use, see copyright notice in ZipArchive.h +// $Workfile: ZipInternalInfo.h $ +// $Archive: /ZipArchive/ZipInternalInfo.h $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt //////////////////////////////////////////////////////////////////////////////// +/** +* \file ZipInternalInfo.h +* Interface for the CZipInternalInfo structure. +* +*/ #if !defined(AFX_ZIPINTERNALINFO_H__C6749101_590C_4F74_8121_B82E3BE9FA44__INCLUDED_) #define AFX_ZIPINTERNALINFO_H__C6749101_590C_4F74_8121_B82E3BE9FA44__INCLUDED_ @@ -12,21 +26,39 @@ #pragma once #endif // _MSC_VER > 1000 #include "ZipAutoBuffer.h" -#include "zlib.h" +#include "zlib/zlib.h" -class CZipInternalInfo +/** + The purpose of this structure is to hold the data that allow communication + with the zlib library +*/ +struct CZipInternalInfo { -public: - DWORD m_iBufferSize; - z_stream m_stream; - DWORD m_uUncomprLeft; - DWORD m_uComprLeft; - DWORD m_uCrc32; - void Init(); - CZipAutoBuffer m_pBuffer; CZipInternalInfo(); virtual ~CZipInternalInfo(); +/** + Allocate internal buffer of m_iBufferSize size +*/ + void Init(); + z_stream m_stream; ///< zlib library data stream + DWORD m_uUncomprLeft; ///< bytes left to uncompress + DWORD m_uComprLeft; ///< bytes left to decompress + DWORD m_uCrc32; ///< crc32 file control value + + /** + The size of the buffer used in decompressing data. + Set before opening the archive. + It is usually set with CZipArchive::SetAdvanced + (specify this value as the second argument). + \see CZipArchive::SetAdvanced + */ + DWORD m_iBufferSize; + + /** + This buffer caches data during compression and decompression. + */ + CZipAutoBuffer m_pBuffer; }; #endif // !defined(AFX_ZIPINTERNALINFO_H__C6749101_590C_4F74_8121_B82E3BE9FA44__INCLUDED_) diff --git a/stepmania/src/smpackage/ZipArchive/ZipMemFile.cpp b/stepmania/src/smpackage/ZipArchive/ZipMemFile.cpp new file mode 100644 index 0000000000..639ef6f1fc --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/ZipMemFile.cpp @@ -0,0 +1,98 @@ +//////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipMemFile.cpp $ +// $Archive: /ZipArchive/ZipMemFile.cpp $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt +//////////////////////////////////////////////////////////////////////////////// + +#include "stdafx.h" +#include "ZipMemFile.h" +#include "ZipException.h" + +////////////////////////////////////////////////////////////////////// +// Construction/Destruction +////////////////////////////////////////////////////////////////////// + +void CZipMemFile::Grow(long nGrowTo) +{ + if (m_nBufSize < (UINT)nGrowTo) + { + if (m_nGrowBy == 0) + CZipException::Throw(CZipException::memError); + long nNewSize = m_nBufSize; + while (nNewSize < nGrowTo) + nNewSize += m_nGrowBy; + BYTE* lpNew; + if (m_lpBuf) + lpNew = (BYTE*)realloc((void*) m_lpBuf, nNewSize); + else + lpNew = (BYTE*)malloc(nNewSize); + + if (!lpNew) + CZipException::Throw(CZipException::memError); + m_nBufSize = nNewSize; + m_lpBuf = lpNew; + } +} + +void CZipMemFile::SetLength(long nNewLen) +{ + if (m_nBufSize < (UINT)nNewLen) + Grow(nNewLen); + else + m_nPos = nNewLen; + m_nDataSize = nNewLen; +} + +UINT CZipMemFile::Read(void *lpBuf, UINT nCount) +{ + if (m_nPos > m_nDataSize) + return 0; + UINT nToRead = (m_nPos + nCount > m_nDataSize) ? m_nDataSize - m_nPos : nCount; + memcpy(lpBuf, m_lpBuf + m_nPos, nToRead); + m_nPos += nToRead; + return nToRead; + +} + +void CZipMemFile::Write(const void *lpBuf, UINT nCount) +{ + if (!nCount) + return; + + if (m_nPos + nCount > m_nBufSize) + Grow(m_nPos + nCount); + memcpy(m_lpBuf + m_nPos, lpBuf, nCount); + m_nPos += nCount; + if (m_nPos > m_nDataSize) + m_nDataSize = m_nPos; +} + +long CZipMemFile::Seek(long lOff, int nFrom) +{ + long lNew = m_nPos; + + if (nFrom == CZipAbstractFile::begin) + lNew = lOff; + else if (nFrom == CZipAbstractFile::current) + lNew += lOff; + else if (nFrom == CZipAbstractFile::end) + lNew = m_nDataSize + lOff; + else + return lNew; + + if (lNew< 0) + CZipException::Throw(CZipException::memError); + + m_nPos = lNew; + return lNew; +} diff --git a/stepmania/src/smpackage/ZipArchive/ZipMemFile.h b/stepmania/src/smpackage/ZipArchive/ZipMemFile.h new file mode 100644 index 0000000000..605c603903 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/ZipMemFile.h @@ -0,0 +1,105 @@ +//////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipMemFile.h $ +// $Archive: /ZipArchive/ZipMemFile.h $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt +//////////////////////////////////////////////////////////////////////////////// + +/** +* \file ZipMemFile.h +* Interface for the CZipMemFile class. +* +*/ +#if !defined(AFX_ZIPMEMFILE_H__EA73AB25_6B51_4C5E_8D78_BAC95812598F__INCLUDED_) +#define AFX_ZIPMEMFILE_H__EA73AB25_6B51_4C5E_8D78_BAC95812598F__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 +#include "ZipAbstractFile.h" +#include "ZipString.h" + +/** + A memory buffer which behaves like a physical file. + Automatically grows when necessary +*/ +class CZipMemFile : public CZipAbstractFile +{ +protected: + UINT m_nGrowBy, m_nPos; + UINT m_nBufSize, m_nDataSize; + BYTE* m_lpBuf; + bool m_bAutoDelete; + void Free() + { + if (m_lpBuf) + { + free(m_lpBuf); + m_lpBuf = NULL; + } + } + void Init() + { + m_nGrowBy = m_nPos = 0; + m_nBufSize = m_nDataSize = 0; + m_lpBuf = NULL; + + } + void Grow(long nBytes); +public: + bool IsClosed() const { return m_lpBuf == NULL;} + void Flush(){} + + long Seek(long lOff, int nFrom); + DWORD GetLength() const {return m_nDataSize;} + void Write(const void* lpBuf, UINT nCount); + UINT Read(void* lpBuf, UINT nCount); + void SetLength(long nNewLen); + CZipString GetFilePath() const {return _T("");} + CZipMemFile(long nGrowBy = 1024) + { + Init(); + m_nGrowBy = nGrowBy; + m_bAutoDelete = true; + } + + CZipMemFile(BYTE* lpBuf, UINT nBufSize, long nGrowBy = 0) + { + Attach(lpBuf, nBufSize, nGrowBy); + } + DWORD GetPosition() const { return m_nPos;} + void Attach(BYTE* lpBuf, UINT nBufSize, long nGrowBy = 0) + { + Close(); + m_lpBuf = lpBuf; + m_nGrowBy = nGrowBy; + m_nBufSize = nBufSize; + m_nDataSize = nGrowBy == 0 ? nBufSize : 0; + m_bAutoDelete = false; + } + BYTE* Detach() + { + BYTE* b = m_lpBuf; + Init(); + return b; + } + void Close() + { + if (m_bAutoDelete) + Free(); + Init(); + } + virtual ~CZipMemFile(){Close();} + +}; + +#endif // !defined(AFX_ZIPMEMFILE_H__EA73AB25_6B51_4C5E_8D78_BAC95812598F__INCLUDED_) diff --git a/stepmania/src/smpackage/ZipArchive/ZipPathComponent.cpp b/stepmania/src/smpackage/ZipArchive/ZipPathComponent.cpp new file mode 100644 index 0000000000..1976e23d1b --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/ZipPathComponent.cpp @@ -0,0 +1,76 @@ +//////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipPathComponent.cpp $ +// $Archive: /ZipArchive/ZipPathComponent.cpp $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt +//////////////////////////////////////////////////////////////////////////////// + +#include "stdafx.h" +#include "ZipPathComponent.h" + +////////////////////////////////////////////////////////////////////// +// Construction/Destruction +////////////////////////////////////////////////////////////////////// + + +CZipPathComponent::~CZipPathComponent() +{ + +} + +void CZipPathComponent::SetFullPath(LPCTSTR lpszFullPath) +{ + + TCHAR szDrive[_MAX_DRIVE]; + TCHAR szDir[_MAX_DIR]; + TCHAR szFname[_MAX_FNAME]; + TCHAR szExt[_MAX_EXT]; + + + CZipString szTempPath(lpszFullPath); + const CZipString szPrefix = _T("\\\\?\\unc\\"); + int i = -1, iLen = szPrefix.GetLength(); + if (iLen > szTempPath.GetLength()) + iLen = szTempPath.GetLength(); + CZipString szPossiblePrefix = szTempPath.Left(iLen); + szPossiblePrefix.MakeLower(); // must perform case insensitive comparison + while (++i < iLen && szPossiblePrefix[i] == szPrefix[i]); + if (i == 2 || i == 4 || i == 8) // unc path, unicode path or unc path meeting windows file name conventions + { + m_szPrefix = szTempPath.Left(i); + szTempPath = szTempPath.Mid(i); + } + else + m_szPrefix.Empty(); + + _tsplitpath(szTempPath, szDrive , szDir, szFname, szExt); + m_szDrive = szDrive; + m_szDirectory = szDir; + + m_szDirectory.TrimLeft(m_cSeparator); + m_szDirectory.TrimRight(m_cSeparator); + SetExtension(szExt); + m_szFileTitle = szFname; +} + + +CZipString CZipPathComponent::GetNoDrive() const +{ + CZipString szPath = m_szDirectory; + CZipString szFileName = GetFileName(); + if (!szFileName.IsEmpty() && !szPath.IsEmpty()) + szPath += m_cSeparator; + + szPath += szFileName; + return szPath; +} + diff --git a/stepmania/src/smpackage/ZipArchive/ZipPathComponent.h b/stepmania/src/smpackage/ZipArchive/ZipPathComponent.h new file mode 100644 index 0000000000..77c11112c3 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/ZipPathComponent.h @@ -0,0 +1,208 @@ +//////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipPathComponent.h $ +// $Archive: /ZipArchive/ZipPathComponent.h $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt +//////////////////////////////////////////////////////////////////////////////// + +/** +* \file ZipPathComponent.h +* Interface for the CZipPathComponent class. +* +*/ +#if !defined(AFX_ZIPPATHCOMPONENT_H__9B222C08_AD11_4138_96CC_1237511E3E37__INCLUDED_) +#define AFX_ZIPPATHCOMPONENT_H__9B222C08_AD11_4138_96CC_1237511E3E37__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 +#include "ZipString.h" + +/** + A class splitting a file path into components. +*/ +class CZipPathComponent +{ +public: + CZipPathComponent(){} + virtual ~CZipPathComponent(); + + static const TCHAR m_cSeparator; ///< A system - specific default path separator. Defined in ZipPlatform.cpp. +/** + Append a path separator to \e szPath if it is not already there. + \param szPath +*/ + static void AppendSeparator(CZipString& szPath) + { + RemoveSeparators(szPath); + szPath += m_cSeparator; + } + + /** + Remove separators from the end of \e szPath + \param szPath + */ + static void RemoveSeparators(CZipString& szPath) + { +// szPath.TrimRight(m_cSeparator); + szPath.TrimRight(_T("\\/")); + } + + /** + Remove separators from the beginning of \e szPath + \param szPath + */ + + static void RemoveSeparatorsLeft(CZipString& szPath) + { + szPath.TrimLeft(_T("\\/")); + } + + + /** + + \return \c true if \e c is a slash or a backslash + + \param c + + */ + static bool IsSeparator(TCHAR c) + { + return c == _T('\\') || c == _T('/'); + } + + /** + \return \c true if the path has a path separator at the and + */ + static bool HasEndingSeparator(const CZipString& szPath) + { + int iLen = szPath.GetLength(); + if (iLen) + return IsSeparator(szPath[iLen - 1]); + else + return false; + } + +/** + Construct the object and set a path. + \param lpszFullPath + the full path of the file + \see SetFullPath +*/ + CZipPathComponent(LPCTSTR lpszFullPath) + { + SetFullPath(lpszFullPath); + } + + // full path of the file (not a directory alone) +/** + Set the path. + \param lpszFullPath + a full path to the file (including a filename - the last element in the + path is assumed to be a filename) +*/ + void SetFullPath(LPCTSTR lpszFullPath); + +/** + \return the filename (without an extension) +*/ + CZipString GetFileTitle() const { return m_szFileTitle;} + +/** + Set the file title (without an extension). + \param lpszFileTitle + + \return +*/ + void SetFileTitle(LPCTSTR lpszFileTitle) { m_szFileTitle = lpszFileTitle;} + + +/** + Set the extension alone. + \param lpszExt + may but not have to contain a dot at the beginning +*/ + void SetExtension(LPCTSTR lpszExt) + { + m_szFileExt = lpszExt; + m_szFileExt.TrimLeft(_T('.')); + } + +/** + \return the file extension without a dot +*/ + CZipString GetFileExt() const { return m_szFileExt;} +/** + \return the drive (no path separator at the end) +*/ + CZipString GetFileDrive() const { return m_szDrive;} +/** + \return the full path without the drive (no separator at the beginning) +*/ + CZipString GetNoDrive() const ; + +/** + \return the filename including an extension +*/ + CZipString GetFileName() const + { + CZipString szFullFileName = m_szFileTitle; + if (!m_szFileExt.IsEmpty()) + { + szFullFileName += _T("."); + szFullFileName += m_szFileExt; + } + return szFullFileName; + } +/** + \return the full path of the file (including the filename) +*/ + CZipString GetFullPath() const + { + CZipString szFullPath = GetFilePath(); + CZipString szFileName = GetFileName(); + if (!szFileName.IsEmpty()) + { + szFullPath += m_cSeparator; + szFullPath += szFileName; + } + return szFullPath; + + } +/** + \return the path of the file (without the separator at the end) +*/ + CZipString GetFilePath() const + { + CZipString szDrive = m_szDrive; + CZipString szDir = m_szDirectory; + if (!szDrive.IsEmpty() && !szDir.IsEmpty()) + szDrive += m_cSeparator; + + return m_szPrefix + szDrive + szDir; + + } +protected: + /** + \name Path components + */ + //@{ + CZipString m_szDirectory, ///< a directory(ies) (one or more) without the path separators at the end and the beginning + m_szFileTitle, ///< a filename without an extension + m_szFileExt, ///< a file extension without a dot + m_szDrive, ///< a drive (if the system path standard uses it) without a path separator at the end + m_szPrefix; ///< a prefix (e.g. for the UNC path or Unicode path under Windows) + //@} + +}; + +#endif // !defined(AFX_ZIPPATHCOMPONENT_H__9B222C08_AD11_4138_96CC_1237511E3E37__INCLUDED_) diff --git a/stepmania/src/smpackage/ZipArchive/ZipPlatform.cpp b/stepmania/src/smpackage/ZipArchive/ZipPlatform.cpp new file mode 100644 index 0000000000..0affb9e3a1 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/ZipPlatform.cpp @@ -0,0 +1,351 @@ +//////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipPlatform.cpp $ +// $Archive: /ZipArchive/ZipPlatform.cpp $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt +//////////////////////////////////////////////////////////////////////////////// + + +#include "stdafx.h" +#include "ZipPlatform.h" +#include "ZipFileHeader.h" +#include "ZipException.h" +#include "ZipAutoBuffer.h" +#include + +#if defined _MSC_VER && !defined __BORLANDC__ /*_MSC_VER may be defined in Borland after converting the VC project */ + #include +#else + #include +#endif + +#include +#include +#include +#include "ZipPathComponent.h" +#include "ZipCompatibility.h" + +const TCHAR CZipPathComponent::m_cSeparator = _T('\\'); + + +#ifndef _UTIMBUF_DEFINED +#define _utimbuf utimbuf +#endif + +DWORD ZipPlatform::GetDeviceFreeSpace(LPCTSTR lpszPath) +{ + DWORD SectorsPerCluster, BytesPerSector, NumberOfFreeClusters, TotalNumberOfClusters; + CZipPathComponent zpc (lpszPath); + CZipString szDrive = zpc.GetFileDrive(); + if (!GetDiskFreeSpace( + szDrive, + &SectorsPerCluster, + &BytesPerSector, + &NumberOfFreeClusters, + &TotalNumberOfClusters)) + { + CZipPathComponent::AppendSeparator(szDrive); // in spite of what is written in MSDN it is sometimes needed (on fixed disks) + if (!GetDiskFreeSpace( + szDrive, + &SectorsPerCluster, + &BytesPerSector, + &NumberOfFreeClusters, + &TotalNumberOfClusters)) + + return 0; + } + __int64 total = SectorsPerCluster * BytesPerSector * NumberOfFreeClusters; + return (DWORD)total; +} + +bool ZipPlatform::GetFileSize(LPCTSTR lpszFileName, DWORD& dSize) +{ + HANDLE f = CreateFile(lpszFileName, GENERIC_READ, FILE_SHARE_READ, + NULL, OPEN_EXISTING, 0, NULL); + if (!f) + return false; + DWORD dwSize; + dwSize = ::GetFileSize(f, NULL); + CloseHandle(f); + if (dwSize == 0xFFFFFFFF) + return false; + dSize = dwSize; + return true; +} + +CZipString ZipPlatform::GetTmpFileName(LPCTSTR lpszPath, DWORD iSizeNeeded) +{ + TCHAR empty[] = _T(""); + CZipString tempPath; + bool bCheckTemp = true; + if (lpszPath) + { + tempPath = lpszPath; + bCheckTemp = GetDeviceFreeSpace(tempPath) < iSizeNeeded; + + } + if (bCheckTemp) + { + DWORD size = GetTempPath(0, NULL); + if (size == 0) + return empty; + + GetTempPath(size, tempPath.GetBuffer(size)); + tempPath.ReleaseBuffer(); + if (GetDeviceFreeSpace(tempPath) < iSizeNeeded) + { + if (!GetCurrentDirectory(tempPath) || GetDeviceFreeSpace(tempPath) < iSizeNeeded) + return empty; + } + } + CZipString tempName; + if (!GetTempFileName(tempPath, _T("ZAR"), 0, tempName.GetBuffer(_MAX_PATH))) + return empty; + tempName.ReleaseBuffer(); + return tempName; +} + + +bool ZipPlatform::GetCurrentDirectory(CZipString& sz) +{ + DWORD i = ::GetCurrentDirectory(0, NULL); + if (!i) + return false; + TCHAR* pBuf = new TCHAR[i]; + bool b = true; + if (!::GetCurrentDirectory(i, pBuf)) + b = false; + else + sz = pBuf; + delete[] pBuf; + return b; +} + +bool ZipPlatform::SetFileAttr(LPCTSTR lpFileName, DWORD uAttr) +{ + return ::SetFileAttributes(lpFileName, uAttr) != 0; +} + +bool ZipPlatform::GetFileAttr(LPCTSTR lpFileName, DWORD& uAttr) +{ + // not using MFC due to MFC bug (attr is one byte there) + DWORD temp = ::GetFileAttributes(lpFileName); + if (temp == -1) + return false; + uAttr = temp; + return true; + +} + +bool ZipPlatform::GetFileModTime(LPCTSTR lpFileName, time_t & ttime) +{ +#if defined _MSC_VER && !defined __BORLANDC__ /*_MSC_VER may be defined in Borland after converting the VC project */ + struct _stat st; + if (_tstat(lpFileName, &st) != 0) +#else + struct stat st; + if (stat(lpFileName, &st) != 0) +#endif + return false; + + ttime = st.st_mtime; + return ttime != -1; +} + +bool ZipPlatform::SetFileModTime(LPCTSTR lpFileName, time_t ttime) +{ + struct _utimbuf ub; + ub.actime = time(NULL); + ub.modtime = ttime; + return _tutime(lpFileName, &ub) == 0; +} + + +bool ZipPlatform::ChangeDirectory(LPCTSTR lpDirectory) +{ + return _tchdir(lpDirectory) == 0; // returns 0 if ok +} +int ZipPlatform::FileExists(LPCTSTR lpszName) +{ + if (_taccess(lpszName, 0) == 0) + { + if (DirectoryExists(lpszName)) + return -1; + return 1; + } + else + return 0; + +} + +ZIPINLINE bool ZipPlatform::IsDriveRemovable(LPCTSTR lpszFilePath) +{ + CZipPathComponent zpc(lpszFilePath); + return ::GetDriveType(zpc.GetFileDrive()) == DRIVE_REMOVABLE; +} + +ZIPINLINE bool ZipPlatform::SetVolLabel(LPCTSTR lpszPath, LPCTSTR lpszLabel) +{ + CZipPathComponent zpc(lpszPath); + CZipString szDrive = zpc.GetFileDrive(); + CZipPathComponent::AppendSeparator(szDrive); + return ::SetVolumeLabel(szDrive, lpszLabel) != 0; +} + +ZIPINLINE void ZipPlatform::AnsiOem(CZipAutoBuffer& buffer, bool bAnsiToOem) +{ + if (bAnsiToOem) + CharToOemBuffA(buffer, buffer, buffer.GetSize()); + else + OemToCharBuffA(buffer, buffer, buffer.GetSize()); +} + +ZIPINLINE bool ZipPlatform::RemoveFile(LPCTSTR lpszFileName, bool bThrow) +{ + if (!::DeleteFile((LPTSTR)lpszFileName)) + if (bThrow) + CZipException::Throw(CZipException::notRemoved, lpszFileName); + else + return false; + return true; + +} +ZIPINLINE bool ZipPlatform::RenameFile( LPCTSTR lpszOldName, LPCTSTR lpszNewName, bool bThrow) +{ + if (!::MoveFile((LPTSTR)lpszOldName, (LPTSTR)lpszNewName)) + if (bThrow) + CZipException::Throw(CZipException::notRenamed, lpszOldName); + else + return false; + return true; + +} +ZIPINLINE bool ZipPlatform::IsDirectory(DWORD uAttr) +{ + return (uAttr & FILE_ATTRIBUTE_DIRECTORY) != 0; +} +ZIPINLINE bool ZipPlatform::CreateDirectory(LPCTSTR lpDirectory) +{ + return ::CreateDirectory(lpDirectory, NULL) != 0; +} + +ZIPINLINE DWORD ZipPlatform::GetDefaultAttributes() +{ + return 0x81a40020; // make it readable under Unix +} + +ZIPINLINE DWORD ZipPlatform::GetDefaultDirAttributes() +{ + return 0x41ff0010; // make it readable under Unix +} + +ZIPINLINE int ZipPlatform::GetSystemID() +{ + return ZipCompatibility::zcDosFat; +} + +ZIPINLINE bool ZipPlatform::GetSystemCaseSensitivity() +{ + return false; +} + +#ifdef _UNICODE +int ZipPlatform::WideToSingle(LPCTSTR lpWide, CZipAutoBuffer &szSingle) +{ + size_t wideLen = wcslen(lpWide); + if (wideLen == 0) + { + szSingle.Release(); + return 0; + } + + // iLen does not include terminating character + int iLen = WideCharToMultiByte(CP_ACP,0, lpWide, wideLen, szSingle, + 0, NULL, NULL); + if (iLen > 0) + { + szSingle.Allocate(iLen, true); + iLen = WideCharToMultiByte(CP_ACP,0, lpWide , wideLen, szSingle, + iLen, NULL, NULL); + ASSERT(iLen != 0); + } + else // here it means error + { + szSingle.Release(); + iLen --; + } + return iLen; + +} +int ZipPlatform::SingleToWide(const CZipAutoBuffer &szSingle, CZipString& szWide) +{ + int singleLen = szSingle.GetSize(); + // iLen doesn't include terminating character + int iLen = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, szSingle.GetBuffer(), singleLen, NULL, 0); + if (iLen > 0) + { + iLen = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, szSingle.GetBuffer(), singleLen, + szWide.GetBuffer(iLen) , iLen); + szWide.ReleaseBuffer(iLen); + ASSERT(iLen != 0); + } + else + { + szWide.Empty(); + iLen --; // return -1 + } + return iLen; + +} +#endif + +#ifndef _MFC_VER +#include +#include +bool ZipPlatform::TruncateFile(int iDes, DWORD iSize) +{ + int ret = chsize(iDes, iSize); + return ret != -1; + +} + +int ZipPlatform::OpenFile(LPCTSTR lpszFileName, UINT iMode, int iShareMode) +{ + switch (iShareMode) + { + case (CZipFile::shareDenyWrite & CZipFile::shareDenyRead): + iShareMode = SH_DENYRW; + break; + case (CZipFile::shareDenyRead): + iShareMode = SH_DENYRD; + break; + case (CZipFile::shareDenyWrite): + iShareMode = SH_DENYWR; + break; + default: + iShareMode = SH_DENYNO; + } + return _tsopen(lpszFileName, iMode, iShareMode, S_IREAD | S_IWRITE /*required only when O_CREAT mode*/); +} + +bool ZipPlatform::FlushFile(int iDes) +{ + return _commit(iDes) == 0; +} + +int ZipPlatform::GetFileSystemHandle(int iDes) +{ + return _get_osfhandle(iDes); +} + + +#endif //_MFC_VER diff --git a/stepmania/src/smpackage/ZipArchive/ZipPlatform.h b/stepmania/src/smpackage/ZipArchive/ZipPlatform.h new file mode 100644 index 0000000000..7425f54483 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/ZipPlatform.h @@ -0,0 +1,174 @@ +//////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipPlatform.h $ +// $Archive: /ZipArchive/ZipPlatform.h $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt +//////////////////////////////////////////////////////////////////////////////// + +/** +* \file ZipPlatform.h +* ZipPlatform namespace declaration. +* +*/ +#if !defined(AFX_ZipPlatform_H__E2FE6343_9D03_4F3C_A1F7_706C9F0ED978__INCLUDED_) +#define AFX_ZipPlatform_H__E2FE6343_9D03_4F3C_A1F7_706C9F0ED978__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 +class CZipFileHeader; +class CZipAutoBuffer; +#include "ZipString.h" +#include "ZipPathComponent.h" +#include + +/** + Interface to the system API. + All functions have a system - specific implementation . +*/ +namespace ZipPlatform +{ + + /** + return the default system case-sensitivity + */ + bool GetSystemCaseSensitivity(); + + /** + \return A current system name tag. + May be one of ZipCompatibility::ZipPlatforms values. + \see CZipArchive::GetSystemCompatibility + */ + int GetSystemID(); + +/** + \return the default file attributes for the current system +*/ + DWORD GetDefaultAttributes(); + +/** + \return the default directory attributes for the current system +*/ + DWORD GetDefaultDirAttributes(); + +/** + Get the free space on the device pointed by \e lpszPath +*/ + DWORD GetDeviceFreeSpace(LPCTSTR lpszPath); + +/** + Return the temporary file name ensuring there is enough size in the destination directory,. + Checking for the size is disabled by default. +*/ + CZipString GetTmpFileName(LPCTSTR lpszPath = NULL, DWORD iSizeNeeded = DWORD(-1)); +/** + \name Various operations on files and directories. + All the functions which are returning a \c bool value, + return \c true when the operation was successful. +*/ + //@{ + bool GetCurrentDirectory(CZipString& sz); ///< Get the current directory and store it in \e sz + bool ChangeDirectory(LPCTSTR lpDirectory); + bool SetFileAttr(LPCTSTR lpFileName, DWORD uAttr); + bool GetFileAttr(LPCTSTR lpFileName, DWORD& uAttr); + bool GetFileModTime(LPCTSTR lpFileName, time_t & ttime); ///< get the file modification time + bool GetFileSize(LPCTSTR lpszFileName, DWORD& dSize); + bool SetFileModTime(LPCTSTR lpFileName, time_t ttime); ///< set the file modification time + bool CreateDirectory(LPCTSTR lpDirectory); + bool SetVolLabel(LPCTSTR lpszPath, LPCTSTR lpszLabel); ///< \c lpszPath may point to a file on the device + bool ForceDirectory(LPCTSTR lpDirectory); ///< create nested directories at once + bool RemoveFile(LPCTSTR lpszFileName, bool bThrow = true); + bool RenameFile( LPCTSTR lpszOldName, LPCTSTR lpszNewName, bool bThrow = true); + +#ifndef _MFC_VER + bool TruncateFile(int iDes, DWORD iSize); + int OpenFile(LPCTSTR lpszFileName, UINT iMode, int iShareMode); + bool FlushFile(int iDes); ///< flush the file to the disk. + int GetFileSystemHandle(int iDes); ///< return the underlying system handle +#endif + //@} + +/** + \param lpszDir + + \return \c true, if \e lpszDir directory exists; otherwise \c false; +*/ + bool DirectoryExists(LPCTSTR lpszDir); +/** + \param lpszFilePath + may point to a file path or a directory on the device + \return \c true if the drive is removable. + Implemented only on Windows system, in all others always returns \c true. +*/ + bool IsDriveRemovable(LPCTSTR lpszFilePath); +/** + \param uAttr + attributes value to test + \return \c true if the attributes are the directory attributes +*/ + bool IsDirectory(DWORD uAttr); + +/** + Perform the translation between ANSI and OEM character sets. + \remark + - The conversion is performed only for the zip archives created under Windows platform. + - Windows archiving programs convert a filename to OEM before adding it to the archive. + - OEM conversion only influences the ANSI values above 126, so it + affects only strings containing international characters. + + \param buffer + buffer to be translated + \param bAnsiToOem + if \c true, convert ANSI to OEM + if \c false, OEM to ANSI +*/ + void AnsiOem(CZipAutoBuffer& buffer, bool bAnsiToOem); +/** + Check if the given file or directory exists. + \param lpszName + + \return + - -1 if the given file is a directory + - 1 a file + - 0 if there is no such a file +*/ + int FileExists(LPCTSTR lpszName); + + +#ifdef _UNICODE +/** + Convert wide character string to single character string. + \param lpWide + Wide string to convert + \param szSingle + buffer to receive converted string (without the terminating NULL character) + \return + the \e szSingle buffer length, or \c -1 when not succeeded + \note Only in UNICODE version. +*/ + int WideToSingle(LPCTSTR lpWide, CZipAutoBuffer &szSingle); +/** + Convert single character string to wide character string. + \param szSingle + single string to convert (no terminating NULL character at the end) + \param szWide + receives the wide string after the conversion + \return \e the length of the string after the conversion (without the NULL character), + or \c -1 when not succeeded + \note Only in UNICODE version. +*/ + int SingleToWide(const CZipAutoBuffer &szSingle, CZipString& szWide); +#endif +}; + + +#endif // !defined(AFX_ZipPlatform_H__E2FE6343_9D03_4F3C_A1F7_706C9F0ED978__INCLUDED_) diff --git a/stepmania/src/smpackage/ZipArchive/ZipPlatformComm.cpp b/stepmania/src/smpackage/ZipArchive/ZipPlatformComm.cpp new file mode 100644 index 0000000000..1bb6e4cb40 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/ZipPlatformComm.cpp @@ -0,0 +1,48 @@ +//////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipPlatformComm.cpp $ +// $Archive: /ZipArchive/ZipPlatformComm.cpp $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt +//////////////////////////////////////////////////////////////////////////////// + + +#include "stdafx.h" +#include "ZipPlatform.h" + +using namespace ZipPlatform; + +bool ZipPlatform::DirectoryExists(LPCTSTR lpszDir) +{ + CZipString sz; + if (!GetCurrentDirectory(sz)) + return false; + if (!ChangeDirectory(lpszDir)) + return false; + ChangeDirectory(sz); + return true; +} + +bool ZipPlatform::ForceDirectory(LPCTSTR lpDirectory) +{ + ASSERT(lpDirectory); + CZipString szDirectory = lpDirectory; + szDirectory.TrimRight(CZipPathComponent::m_cSeparator); + CZipPathComponent zpc(szDirectory); + if ((zpc.GetFilePath() == szDirectory) || + (FileExists(szDirectory) == -1)) + return true; + if (!ForceDirectory(zpc.GetFilePath())) + return false; + if (!CreateDirectory(szDirectory)) + return false; + return true; +} diff --git a/stepmania/src/smpackage/ZipArchive/ZipStorage.cpp b/stepmania/src/smpackage/ZipArchive/ZipStorage.cpp index 0a295d8612..bc4057084f 100644 --- a/stepmania/src/smpackage/ZipArchive/ZipStorage.cpp +++ b/stepmania/src/smpackage/ZipArchive/ZipStorage.cpp @@ -1,13 +1,24 @@ -// ZipStorage.cpp: implementation of the CZipStorage class. -// //////////////////////////////////////////////////////////////////////////////// -// Copyright (C) 2000 Tadeusz Dracz. -// For conditions of distribution and use, see copyright notice in ZipArchive.h +// $Workfile: ZipStorage.cpp $ +// $Archive: /ZipArchive/ZipStorage.cpp $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt //////////////////////////////////////////////////////////////////////////////// #include "stdafx.h" #include "ZipStorage.h" #include "ZipArchive.h" +// #include "ZipPathComponent.h" +#include "ZipPlatform.h" ////////////////////////////////////////////////////////////////////// // disk spanning objectives: @@ -16,11 +27,12 @@ // - each file has a data descriptor preceded by the signature // (bit 3 set in flag); +int CZipActionCallback::m_iStep = 256; char CZipStorage::m_gszExtHeaderSignat[] = {0x50, 0x4b, 0x07, 0x08}; CZipStorage::CZipStorage() { - m_pCallbackData = m_pZIPCALLBACKFUN = NULL; + m_pChangeDiskFunc = NULL; m_iWriteBufferSize = 65535; m_iCurrentDisk = -1; m_pFile = NULL; @@ -43,20 +55,20 @@ DWORD CZipStorage::Read(void *pBuf, DWORD iSize, bool bAtOnce) if (IsSpanMode()) ChangeDisk(m_iCurrentDisk + 1); else - ThrowError(ZIP_BADZIPFILE); + ThrowError(CZipException::badZipFile); } if (iRead == iSize) return iRead; else if (bAtOnce || !IsSpanMode()) - ThrowError(ZIP_BADZIPFILE); + ThrowError(CZipException::badZipFile); while (iRead < iSize) { ChangeDisk(m_iCurrentDisk + 1); UINT iNewRead = m_pFile->Read((char*)pBuf + iRead, iSize - iRead); if (!iNewRead && iRead < iSize) - ThrowError(ZIP_BADZIPFILE); + ThrowError(CZipException::badZipFile); iRead += iNewRead; } @@ -69,14 +81,16 @@ void CZipStorage::Open(LPCTSTR szPathName, int iMode, int iVolumeSize) m_uBytesInWriteBuffer = 0; m_bNewSpan = false; m_pFile = &m_internalfile; + m_bInMemory = false; - if ((iMode == CZipArchive::create) ||(iMode == CZipArchive::createSpan)) // create new archive + if ((iMode == CZipArchive::zipCreate) ||(iMode == CZipArchive::zipCreateSpan)) // create new archive { + m_bReadOnly = false; m_iCurrentDisk = 0; - if (iMode == CZipArchive::create) + if (iMode == CZipArchive::zipCreate) { m_iSpanMode = noSpan; - OpenFile(szPathName, CFile::modeCreate | CFile::modeReadWrite); + OpenFile(szPathName, CZipFile::modeCreate | CZipFile::modeReadWrite); } else // create disk spanning archive { @@ -84,10 +98,10 @@ void CZipStorage::Open(LPCTSTR szPathName, int iMode, int iVolumeSize) m_iBytesWritten = 0; if (iVolumeSize <= 0) // pkzip span { - if (!m_pZIPCALLBACKFUN) - ThrowError(ZIP_NOCALLBACK); - if (!CZipArchive::IsDriveRemovable(szPathName)) - ThrowError(ZIP_NONREMOVABLE); + if (!m_pChangeDiskFunc) + ThrowError(CZipException::noCallback); + if (!ZipPlatform::IsDriveRemovable(szPathName)) + ThrowError(CZipException::nonRemovable); m_iSpanMode = pkzipSpan; } else @@ -102,22 +116,25 @@ void CZipStorage::Open(LPCTSTR szPathName, int iMode, int iVolumeSize) } else // open existing { - OpenFile(szPathName, CFile::modeNoTruncate | ((iMode == CZipArchive::openReadOnly) ? CFile::modeRead : CFile::modeReadWrite)); - // m_uData, m_bAllowModif i m_iSpanMode ustalane automatycznie podczas odczytu central dir + m_bReadOnly = iMode == CZipArchive::zipOpenReadOnly; + OpenFile(szPathName, CZipFile::modeNoTruncate | + (m_bReadOnly ? CZipFile::modeRead : CZipFile::modeReadWrite)); + // m_uData, i m_iSpanMode are automatically set during reading the central dir m_iSpanMode = iVolumeSize == 0 ? suggestedAuto : suggestedTd; } } -void CZipStorage::Open(CMemFile& mf, int iMode) +void CZipStorage::Open(CZipMemFile& mf, int iMode) { m_pWriteBuffer.Allocate(m_iWriteBufferSize); m_uBytesInWriteBuffer = 0; m_bNewSpan = false; m_pFile = &mf; + m_bInMemory = true; - if (iMode == CZipArchive::create) + if (iMode == CZipArchive::zipCreate) { m_iCurrentDisk = 0; m_iSpanMode = noSpan; @@ -131,11 +148,6 @@ void CZipStorage::Open(CMemFile& mf, int iMode) } -int CZipStorage::IsSpanMode() -{ - return m_iSpanMode == noSpan ? 0 : (m_bNewSpan ? 1 : -1); -} - void CZipStorage::ChangeDisk(int iNumber) { if (iNumber == m_iCurrentDisk) @@ -144,76 +156,71 @@ void CZipStorage::ChangeDisk(int iNumber) ASSERT(m_iSpanMode != noSpan); m_iCurrentDisk = iNumber; OpenFile(m_iSpanMode == pkzipSpan ? ChangePkzipRead() : ChangeTdRead(), - CFile::modeNoTruncate | CFile::modeRead); + CZipFile::modeNoTruncate | CZipFile::modeRead); } void CZipStorage::ThrowError(int err) { - AfxThrowZipException(err, m_pFile->GetFilePath()); + CZipException::Throw(err, m_pFile->GetFilePath()); } bool CZipStorage::OpenFile(LPCTSTR lpszName, UINT uFlags, bool bThrow) { - CFileException* e = new CFileException; - BOOL bRet = m_pFile->Open(lpszName, uFlags | CFile::shareDenyWrite, e); - if (!bRet && bThrow) - throw e; - e->Delete(); - return bRet != 0; + return m_pFile->Open(lpszName, uFlags | CZipFile::shareDenyWrite, bThrow); } -// zapobiega konstrukcji ChangeDisk(++m_iCurrentDisk) -void CZipStorage::SetCurrentDisk(int iNumber) -{ - m_iCurrentDisk = iNumber; -} -int CZipStorage::GetCurrentDisk() +CZipString CZipStorage::ChangePkzipRead() { - return m_iCurrentDisk; -} - -CString CZipStorage::ChangePkzipRead() -{ - CString szTemp = m_pFile->GetFilePath(); + CZipString szTemp = m_pFile->GetFilePath(); m_pFile->Close(); CallCallback(-1 , szTemp); return szTemp; } -CString CZipStorage::ChangeTdRead() +CZipString CZipStorage::ChangeTdRead() { - CString szTemp = GetTdVolumeName(m_iCurrentDisk == m_iTdSpanData); + CZipString szTemp = GetTdVolumeName(m_iCurrentDisk == m_iTdSpanData); m_pFile->Close(); return szTemp; } +CZipString CZipStorage::RenameLastFileInTDSpan() +{ + ASSERT(m_iSpanMode == tdSpan); + // give to the last volume the zip extension + CZipString szFileName = m_pFile->GetFilePath(); + CZipString szNewFileName = GetTdVolumeName(true); + if (!m_bInMemory) + { + m_pFile->Flush(); + m_pFile->Close(); + } + if (ZipPlatform::FileExists(szNewFileName)) + ZipPlatform::RemoveFile(szNewFileName); + ZipPlatform::RenameFile(szFileName, szNewFileName); + return szNewFileName; +} + void CZipStorage::Close(bool bAfterException) { + bool bClose = true; if (!bAfterException) { Flush(); if ((m_iSpanMode == tdSpan) && (m_bNewSpan)) { - // give to the last volume the zip extension - CString szFileName = m_pFile->GetFilePath(); - CString szNewFileName = GetTdVolumeName(true); - m_pFile->Close(); - if (CZipArchive::FileExists(szNewFileName)) - CFile::Remove(szNewFileName); - CFile::Rename(szFileName, szNewFileName); + RenameLastFileInTDSpan(); + bClose = false;// already closed in RenameLastFileInTDSpan } - else -#ifdef _DEBUG // to prevent assertion if the file is already closed - if (m_pFile->m_hFile != (UINT)CFile::hFileNull) -#endif - m_pFile->Close(); } - else -#ifdef _DEBUG // to prevent assertion if the file is already closed - if (m_pFile->m_hFile != (UINT)CFile::hFileNull) -#endif - m_pFile->Close(); + + if (bClose && !m_bInMemory) + { + FlushFile(); + m_pFile->Close(); + } + m_pWriteBuffer.Release(); @@ -222,17 +229,17 @@ void CZipStorage::Close(bool bAfterException) m_pFile = NULL; } -CString CZipStorage::GetTdVolumeName(bool bLast, LPCTSTR lpszZipName) +CZipString CZipStorage::GetTdVolumeName(bool bLast, LPCTSTR lpszZipName) const { - CString szFilePath = lpszZipName ? lpszZipName : m_pFile->GetFilePath(); - CString szPath = CZipArchive::GetFilePath(szFilePath); - CString szName = CZipArchive::GetFileTitle(szFilePath); - CString szExt; + CZipString szFilePath = lpszZipName ? lpszZipName : (LPCTSTR)m_pFile->GetFilePath(); + CZipPathComponent zpc(szFilePath); + CZipString szExt; if (bLast) szExt = _T("zip"); else szExt.Format(_T("%.3d"), m_iCurrentDisk); - return szPath + szName + _T(".") + szExt; + zpc.SetExtension(szExt); + return zpc.GetFullPath(); } void CZipStorage::NextDisk(int iNeeded, LPCTSTR lpszFileName) @@ -244,19 +251,17 @@ void CZipStorage::NextDisk(int iNeeded, LPCTSTR lpszFileName) m_iBytesWritten = 0; m_iCurrentDisk++; if (m_iCurrentDisk >= 999) - ThrowError(ZIP_TOOMANYVOLUMES); + ThrowError(CZipException::tooManyVolumes); } - CString szFileName; + CZipString szFileName; bool bPkSpan = (m_iSpanMode == pkzipSpan); if (bPkSpan) - szFileName = lpszFileName ? lpszFileName : m_pFile->GetFilePath(); + szFileName = lpszFileName ? lpszFileName : (LPCTSTR)m_pFile->GetFilePath(); else szFileName = GetTdVolumeName(false, lpszFileName); -#ifdef _DEBUG // to prevent assertion if the file is already closed - if (m_pFile->m_hFile != (UINT)CFile::hFileNull) -#endif - m_pFile->Close(); // if it is closed, so it will not close + m_pFile->Flush(); + m_pFile->Close(); if (bPkSpan) { @@ -264,15 +269,15 @@ void CZipStorage::NextDisk(int iNeeded, LPCTSTR lpszFileName) while (true) { CallCallback(iCode, szFileName); - if (CZipArchive::FileExists(szFileName)) + if (ZipPlatform::FileExists(szFileName)) iCode = -2; else { - CString label; + CZipString label; label.Format(_T("pkback# %.3d"), m_iCurrentDisk + 1); - if (!SetVolumeLabel(CZipArchive::GetDrive(szFileName), label)) /*not write label*/ + if (!ZipPlatform::SetVolLabel(szFileName, label)) iCode = -3; - else if (!OpenFile(szFileName, CFile::modeCreate | CFile::modeReadWrite, false)) + else if (!OpenFile(szFileName, CZipFile::modeCreate | CZipFile::modeReadWrite, false)) iCode = -4; else break; @@ -284,30 +289,30 @@ void CZipStorage::NextDisk(int iNeeded, LPCTSTR lpszFileName) else { m_uCurrentVolSize = m_iTdSpanData; - OpenFile(szFileName, CFile::modeCreate | CFile::modeReadWrite); + OpenFile(szFileName, CZipFile::modeCreate | CZipFile::modeReadWrite); } } -void CZipStorage::CallCallback(int iCode, CString szTemp) +void CZipStorage::CallCallback(int iCode, CZipString szTemp) { - ASSERT(m_pZIPCALLBACKFUN); - if (!(*m_pZIPCALLBACKFUN)(m_iCurrentDisk + 1, iCode, m_pCallbackData)) - throw new CZipException(CZipException::aborted, szTemp); + ASSERT(m_pChangeDiskFunc); + m_pChangeDiskFunc->m_szExternalFile = szTemp; + m_pChangeDiskFunc->m_uDiskNeeded = m_iCurrentDisk + 1; + if (!m_pChangeDiskFunc->Callback(iCode)) + CZipException::Throw(CZipException::aborted, szTemp); } -DWORD CZipStorage::GetFreeVolumeSpace() +DWORD CZipStorage::GetFreeVolumeSpace() const { ASSERT (m_iSpanMode == pkzipSpan); - DWORD SectorsPerCluster, BytesPerSector, NumberOfFreeClusters, TotalNumberOfClusters; - if (!GetDiskFreeSpace( - CZipArchive::GetDrive(m_pFile->GetFilePath()), - &SectorsPerCluster, - &BytesPerSector, - &NumberOfFreeClusters, - &TotalNumberOfClusters)) - return 0; - _int64 total = SectorsPerCluster * BytesPerSector * NumberOfFreeClusters; - return (DWORD)total; + CZipString szTemp = m_pFile->GetFilePath(); + if (szTemp.IsEmpty()) // called once when creating a disk spanning archive + return 0; + else + { + CZipPathComponent zpc(szTemp); + return ZipPlatform::GetDeviceFreeSpace(zpc.GetFilePath()); + } } @@ -319,15 +324,15 @@ void CZipStorage::UpdateSpanMode(WORD uLastDisk) // disk spanning detected if (m_iSpanMode == suggestedAuto) - m_iSpanMode = CZipArchive::IsDriveRemovable(m_pFile->GetFilePath()) ? + m_iSpanMode = ZipPlatform::IsDriveRemovable(m_pFile->GetFilePath()) ? pkzipSpan : tdSpan; else m_iSpanMode = tdSpan; if (m_iSpanMode == pkzipSpan) { - if (!m_pZIPCALLBACKFUN) - ThrowError(ZIP_NOCALLBACK); + if (!m_pChangeDiskFunc) + ThrowError(CZipException::noCallback); } else /*if (m_iSpanMode == tdSpan)*/ m_iTdSpanData = uLastDisk; // disk with .zip extension ( the last one) @@ -339,7 +344,7 @@ void CZipStorage::UpdateSpanMode(WORD uLastDisk) } -void CZipStorage::Write(void *pBuf, DWORD iSize, bool bAtOnce) +void CZipStorage::Write(const void *pBuf, DWORD iSize, bool bAtOnce) { if (!IsSpanMode()) WriteInternalBuffer((char*)pBuf, iSize); @@ -376,7 +381,7 @@ void CZipStorage::Write(void *pBuf, DWORD iSize, bool bAtOnce) } -void CZipStorage::WriteInternalBuffer(char *pBuf, DWORD uSize) +void CZipStorage::WriteInternalBuffer(const char *pBuf, DWORD uSize) { DWORD uWritten = 0; while (uWritten < uSize) @@ -395,7 +400,7 @@ void CZipStorage::WriteInternalBuffer(char *pBuf, DWORD uSize) } } -DWORD CZipStorage::VolumeLeft() +DWORD CZipStorage::VolumeLeft() const { // for pkzip span m_uCurrentVolSize is updated after each flush() return m_uCurrentVolSize - m_uBytesInWriteBuffer - ((m_iSpanMode == pkzipSpan) ? 0 : m_iBytesWritten); @@ -403,26 +408,43 @@ DWORD CZipStorage::VolumeLeft() void CZipStorage::Flush() { - m_iBytesWritten += m_uBytesInWriteBuffer; + if (m_iSpanMode != noSpan) + m_iBytesWritten += m_uBytesInWriteBuffer; if (m_uBytesInWriteBuffer) { m_pFile->Write(m_pWriteBuffer, m_uBytesInWriteBuffer); m_uBytesInWriteBuffer = 0; } if (m_iSpanMode == pkzipSpan) - // after writting it is difficult to predict the free space due to + // after writing it is difficult to predict the free space due to // not completly written clusters, write operation may start from // the new cluster m_uCurrentVolSize = GetFreeVolumeSpace(); + } -DWORD CZipStorage::GetPosition() + + +void CZipStorage::FinalizeSpan() { - return m_pFile->GetPosition() + m_uBytesInWriteBuffer; -} + ASSERT(IsSpanMode() == 1); // span in creation + ASSERT(!m_bInMemory); - -DWORD CZipStorage::GetFreeInBuffer() -{ - return m_pWriteBuffer.GetSize() - m_uBytesInWriteBuffer; + CZipString szFileName; + if ((m_iSpanMode == tdSpan) && (m_bNewSpan)) + szFileName = RenameLastFileInTDSpan(); + else + { + szFileName = m_pFile->GetFilePath(); + // the file is already closed + m_pFile->Close(); + } + m_bNewSpan = false; + if (m_iCurrentDisk == 0) // one-disk span was converted to normal archive + m_iSpanMode = noSpan; + else + m_iTdSpanData = m_iCurrentDisk; + + OpenFile(szFileName, CZipFile::modeNoTruncate | (m_iSpanMode == noSpan ? CZipFile::modeReadWrite : CZipFile::modeRead)); + } diff --git a/stepmania/src/smpackage/ZipArchive/ZipStorage.h b/stepmania/src/smpackage/ZipArchive/ZipStorage.h index 9d203ae32e..3aa1e097f8 100644 --- a/stepmania/src/smpackage/ZipArchive/ZipStorage.h +++ b/stepmania/src/smpackage/ZipArchive/ZipStorage.h @@ -1,133 +1,578 @@ -// ZipStorage.h: interface for the CZipStorage class. +//////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipStorage.h $ +// $Archive: /ZipArchive/ZipStorage.h $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) // +// 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. +// +// For the licensing details see the file License.txt //////////////////////////////////////////////////////////////////////////////// -// Copyright (C) 2000 Tadeusz Dracz. -// For conditions of distribution and use, see copyright notice in ZipArchive.h -//////////////////////////////////////////////////////////////////////////////// + +/** +* \file ZipStorage.h +* Interface for the CZipStorage class. +* +*/ #if !defined(AFX_ZIPSTORAGE_H__941824FE_3320_4794_BDE3_BE334ED8984B__INCLUDED_) #define AFX_ZIPSTORAGE_H__941824FE_3320_4794_BDE3_BE334ED8984B__INCLUDED_ -#include "ZipBigFile.h" // Added by ClassView -#include "ZipAutoBuffer.h" // Added by ClassView +#include "ZipFile.h" +#include "ZipAutoBuffer.h" +#include "ZipString.h" +#include "ZipMemFile.h" + + #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER > 1000 -// callback function called when there is a need for a disk change -// calling CZipArchive functions, apart from the static ones, may have unexpected results -// iNumber - disk number needed -// iCode : -// -1 - disk needed for reading -// other codes occurs during writting -// >=0 : number of bytes needed -// -2 - the file with the archive name already exists on the disk -// -3 - the disk is probably write - protected -// -4 - couldn't create a file -// pData - user defined data -// return false to abort operation: the proper exception will be thrown -typedef bool (*ZIPCALLBACKFUN )(int iNumber, int iCode, void* pData); +/** + A base class for functional objects (functors) that are used as a callbacks during various actions. + You need to derive your own class and overload \c Callback method to use it. + Do not derive from CZipCallback directly but from CZipSpanCallback (as a callback when there is a need + for a disk change in a disk-spanning archive) or from CZipActionCallback for other actions. +*/ +struct CZipCallback +{ + /** + Method called as a callback. + Return \c false from inside the method to abort the current operation. If it is a span callback functor, + a CZipException with CZipException::aborted code will be thrown, otherwise the code will be CZipException::abortedAction or CZipException::abortedSafely. + The following actions can be safely aborted (without having the archive corrupted): + - counting bytes before deleting files + - testing + - saving central directory on non-disk-spanning archive + (saved data is removed in case of break and you can save it again); + it the archive is disk-spanning and if saving is aborted, the archive + will not be damaged, but saved part of the central directory will be not removed + and the new central directory will have to be saved after it + + \note Overrride this method in the derived class. If you define this method inside the class declaration, it should be inlined + by the compiler making the action progress faster. + */ + virtual bool Callback(int iProgress) = 0; + + + CZipString m_szExternalFile; ///< if the action (adding, extracting or disk-spanning) uses an external file, its filename is stored here +}; + +/** + Derive from this a class to be used as a callback functor for the disk change callback. + You need to override member function CZipCallback::Callback. The meaning of \e iProgress parameter is the reason for calling: + - -1 : a disk needed for reading
+ other codes occurs during writing: + - >=0 : min. number of bytes needed + - -2 : the file with the archive name already exists on the disk + - -3 : the disk is probably write - protected + - -4 : couldn't create a file + + + Return \c false from the callback function to abort operation: the proper exception will be thrown. + + \see CZipCallback::Callback + \see CZipArchive::SetSpanCallback +*/ +struct CZipSpanCallback : public CZipCallback +{ + DWORD m_uDiskNeeded; ///< the number of a disk needed (counting from 1) +}; + + + +/** + Derive from this a class to be used as a callback functors when adding, extracting, deleting, testing a file + or saving central directory. + You need to override member function CZipCallback::Callback. The meaning of \e iProgress parameter is the count + of data just processed. It is a smallest number of bytes after which the callback method is called and it depends + on the value of \e nBufSize in the CZipArchive methods that uses the callback feature. In case of saving the central + directory action it is the count of file headers just written (see CZipArchive::cbSave) + \see CZipCallback::Callback + \see CZipArchive::SetCallback +*/ +struct CZipActionCallback : public CZipCallback +{ + + CZipActionCallback() + { + m_uTotalToDo = 0; + m_uTotalSoFar = 0; + } + + /** + The type of the callback. It is set to one of CZipArchive::CallbackType values when the action begins. + It's useful if you have more than one callback assigned to the same functor. + */ + int m_iType; + + /** + Used to init the callback function with the filenames. Resets #m_uTotalToDo and #m_uTotalSoFar variables to 0. + #m_iType variable is already set to the proper value. Called at the beginning of the action. + */ + virtual void Init(LPCTSTR lpszFileInZip = NULL, LPCTSTR lpszExternalFile = NULL) + { + m_szFileInZip = lpszFileInZip; + m_szExternalFile = lpszExternalFile; + m_uTotalToDo = 0; // not yet known + m_uTotalSoFar = 0; // nothing yet done + } + + /** + Called by the ZipArchive functions that use the callback feature after calculating total data to process. + \param uTotalToDo + total data to process; set #m_uTotalToDo to this value + */ + virtual void SetTotal(DWORD uTotalToDo) + { + m_uTotalToDo = uTotalToDo; +// m_uTotalSoFar = 0; // already done in CZipArchive::CZipClbckStrg::Get + } + + + + /** + Total number of data to process. The value of this variable is set after calling by the library #SetTotal method (it is 0 before). + Depending on the action it is set then to: + - adding file: the size the external file being added (or if callback is CZipArchive::cbAddTmp, the size of compressed data: CZipFileHeader::m_uComprSize) + - extracting file: the size of uncompressed data (CZipFileHeader::m_uUncomprSize) + - testing file: the same as above + - deleting file: the count of bytes to move - the size of all files to remain above the first file to delete (calculated from offsets CZipFileHeader::m_uOffset + - saving central directory: the number of files in the archive + + */ + DWORD m_uTotalToDo; + DWORD m_uTotalSoFar; ///< total number of bytes processed so far + CZipString m_szFileInZip; ///< file in zip archive being currently processed + + + /** + \return the number of bytes left to process + */ + DWORD LeftToDo() {return m_uTotalToDo - m_uTotalSoFar;} + + + /** + Called after the action finishes (it is not called in case of an exception, but + it is called before throwing CZipException::abortedAction or CZipException::abortedSafely) + */ + virtual void CallbackEnd() + { + ASSERT(m_uTotalSoFar == m_uTotalToDo); + }; + + /** + Used internally to call Callback and increase #m_uTotalSoFar by \e iProgress + */ + virtual bool operator()(int iProgress) + { + m_uTotalSoFar += iProgress; + return Callback(iProgress); + } + + /** + Used only when creating map before deletion (see CZipArchive::cbDeleteCnt) or + saving the central directory record. You'll be notified every nth step (n is \e m_iStep value) with \e iProgress set to + \e m_iStep . Do not set it to low values or you can have a long waiting on archives + with huge number of files. The default is 256. + */ + static int m_iStep; + + + /** + Used internally to return #m_iStep value but not 0 (return 1 in this case). + */ + int GetStep(){return m_iStep ? m_iStep : 1;} // do not allow 0 (crash) + +}; + + +/** + A low-level class - operates physically on archive (CZipArchive operates logically) +*/ class CZipStorage { + friend class CZipCentralDir; public: - void Open(CMemFile& mf, int iMode); -// return the position in the file, taking into account the bytes in the write buffer - DWORD GetPosition(); + + /** + The type of the disk spanning archive. + \see CZipArchive::GetSpanMode + */ + enum ZipSpanMode { + noSpan, ///< no disk spanning + pkzipSpan, ///< \ref PKSpan "disk spanning compatible with PKZIP" + tdSpan, ///< \ref TDSpan "TD mode disk spanning archive" + /** + Detect the type automatically. + If the archive is on the removable device assume PKZIP compatible, + otherwise TD mode compatible. + */ + suggestedAuto, + /** + If the disk spanning archive is on the removable device + assume it is TD mode compatible + */ + suggestedTd + }; -// flush the data from the read buffer to the disk - void Flush(); - -// only called by CZipCentralDir when opening an existing archive - void UpdateSpanMode(WORD uLastDisk); -// the preset size of the write buffer - int m_iWriteBufferSize; - -// user data to be passed to the callback function - void* m_pCallbackData; - -// function used to change disks during writing to the disk spanning archive - void NextDisk(int iNeeded, LPCTSTR lpszFileName = NULL); - - void Close(bool bAfterException); - -// return the numer of the current disk - int GetCurrentDisk(); - - void SetCurrentDisk(int iNumber); - -// change the disk during extract operations - void ChangeDisk(int iNumber); - -// Function name : IsSpanMode -// Description : detect span mode -// Return type : int -// -1 - existing span opened -// 0 - no span -// 1 - new span - int IsSpanMode(); - - void Open(LPCTSTR szPathName, int iMode, int iVolumeSize); - void Write(void *pBuf, DWORD iSize, bool bAtOnce); - DWORD Read(void* pBuf, DWORD iSize, bool bAtOnce); - CZipBigFile m_internalfile; - CFile* m_pFile; CZipStorage(); virtual ~CZipStorage(); - enum {noSpan, pkzipSpan, tdSpan, suggestedAuto, suggestedTd}; - int m_iSpanMode; - ZIPCALLBACKFUN m_pZIPCALLBACKFUN; - static char m_gszExtHeaderSignat[]; -// open tdspan: last disk number, create tdspan: volume size -// create pkspan: not used +/** + Open the archive in memory (new or existing). + The parameters are the same as CZipArchive::OpenMode. + \param mf + \param iMode + \note Throws exceptions. + + \see CZipArchive::Open(LPCTSTR, int, int) +*/ + void Open(CZipMemFile& mf, int iMode); + +/** + Open or create an archive. + The parameters are the same as CZipArchive::Open. + \param szPathName + \param iMode + \param iVolumeSize + \note Throws exceptions. + + \see CZipArchive::Open(CZipMemFile& , int); +*/ + void Open(LPCTSTR szPathName, int iMode, int iVolumeSize); + + + /** + Close the disk-spanning archive and reopens as an existing disk-spanning archive or set mode to #noSpan + */ + void FinalizeSpan(); + + +/** + Called only by CZipCentralDir::Read() when opening an existing archive. + \param uLastDisk + the disk number the central directory is on + \note Throws exceptions. + +*/ + void UpdateSpanMode(WORD uLastDisk); + + +/** + Write chunk of data to the archive. + \param pBuf + buffer with data + \param iSize + bytes to write + \param bAtOnce + if \c true, the whole data must fit in the current volume, + otherwise the disk change is performed + \note Throws exceptions. +*/ + void Write(const void *pBuf, DWORD iSize, bool bAtOnce); + +/** + Read chunk of data from the archive. + \param pBuf + buffer to receive data + \param iSize + bytes to read + \param bAtOnce + if \c true, the specified number of bytes must be read from the same + volume (no disk change allowed) + \note Throws exceptions. +*/ + DWORD Read(void* pBuf, DWORD iSize, bool bAtOnce); + + /** + Return the position in the file, taking into account the bytes in the write buffer. + \note Throws exceptions. + */ + DWORD GetPosition() const {return m_pFile->GetPosition() + m_uBytesInWriteBuffer;} + + + /** + Flush the data from the read buffer to the disk. + \note Throws exceptions. + */ + void Flush(); + + + /** + Forces any data remaining in the file buffer to be written to the disk + */ + void FlushFile() + { + if (!m_bInMemory && !IsReadOnly()) + m_pFile->Flush(); + } + +/** + A method used to change disks during writing to the disk spanning archive. + \param iNeeded + no of bytes needed on the disk + \param lpszFileName + the archive filename + \note Throws exceptions. +*/ + void NextDisk(int iNeeded, LPCTSTR lpszFileName = NULL); + + +/** + \return a zero-based number of the current disk +*/ + int GetCurrentDisk() const {return m_iCurrentDisk;} + + +/** + Change the disk during extract operations. + \param iNumber + a zero-based disk number requested + \return +*/ + void ChangeDisk(int iNumber); + +/** + Detect the span mode. + \return + - -1 - existing disk spanning archive opened + - 0 - no disk spanning archive + - 1 - disk spanning archive in creation + +*/ + int IsSpanMode() const + { + return m_iSpanMode == noSpan ? 0 : (m_bNewSpan ? 1 : -1); + } + + /** + return \c true if the archive cannot be modified. + */ + bool IsReadOnly() + { + return m_bReadOnly || IsSpanMode() < 0; + } + +/** + + \param bAfterException + set to \c true after the library has throw an exception. + The simplified mode is used then. + In this case it'll be possible to reuse the object to operate on another + archive, but the current archive file will not be valid anyway. + \note Throws exceptions. +*/ + void Close(bool bAfterException); + + + /** + The size of the write buffer. + Set before opening the archive. + It is usually set with CZipArchive::SetAdvanced + (specify this value as the first argument). + \see CZipArchive::SetAdvanced + */ + int m_iWriteBufferSize; + + + /** + The physical archive file (on a storage device). + Not used when opening archive in memory + with Open(CZipMemFile& , int). + */ + CZipFile m_internalfile; + + /** + The buffer representing the archive. + It is a physical file or a memory buffer depending on what + method was used to open the archive. In the first case it is + a pointer to #m_internalfile. + \see Open(LPCTSTR, int, int); + \see Open(CZipMemFile& mf, int) + + */ + CZipAbstractFile* m_pFile; + + /** + Takes one of the values of #ZipSpanMode. + */ + int m_iSpanMode; + + /** + A callback functor which method \c Callback is called when there is a need for a disk change + while operating on a #pkzipSpan archive. + \see CZipArchive::SetSpanCallback + */ + CZipSpanCallback* m_pChangeDiskFunc; + + /** + The signature of the extended header + */ + static char m_gszExtHeaderSignat[]; +protected: + + /** + Flush without writing. Can be used only on non-disk spanning archives. + */ + void EmptyWriteBuffer() + { + m_uBytesInWriteBuffer = 0; + } + +/** + Open a physical file. + \param lpszName + the name of the file to open + \param uFlags + file open flags + \param bThrow + if \c true then throw an exception in case of failure + \return \c true if successful +*/ + bool OpenFile(LPCTSTR lpszName, UINT uFlags, bool bThrow = true); +/** + Throw an exception with the given code. + \param err + \see CZipException::Throw +*/ + void ThrowError(int err); + +/** + Return the number of bytes left on the current volume. +*/ + DWORD VolumeLeft() const; + + /** + Rename last file in TD mode disk spanning archive when done with creating + */ + CZipString RenameLastFileInTDSpan(); +/** + Write data to the internal buffer. + \param *pBuf + the buffer to copy data from + \param uSize + bytes to write + \note Throws exceptions. +*/ + void WriteInternalBuffer(const char *pBuf, DWORD uSize); + +/** + \return the number of free bytes on the current removable disk +*/ + DWORD GetFreeVolumeSpace() const; + +/** + Call the callback functor. + Throw an exception if the callback functor's method \c Callback returns \c false. + \param iCode + a code to be passed to the callback functor + \param szTemp + a string to be used as a filename (the second argument + of CZipException::Throw) when the exception must be thrown + \note Throws exceptions. + \see CZipArchive::SetSpanCallback + \see CZipException::Throw +*/ + void CallCallback(int iCode, CZipString szTemp); + + +/** + Construct the name of the volume in #tdSpan mode. + \param bLast + must be \c true if constructing the last volume name (an extension "zip" is given) + \param lpszZipName + the name of the archive + \return + the new volume name +*/ + CZipString GetTdVolumeName(bool bLast, LPCTSTR lpszZipName = NULL) const; + + /** + Change the disk in #tdSpan mode + */ + CZipString ChangeTdRead(); + + /** + Change the disk in #pkzipSpan mode + */ + CZipString ChangePkzipRead(); + + + /** + Used only in \ref TDSpan "TD span mode" . The value it holds depends on the open mode. + - Opened existing disk spanning archive - store the number of the last + disk ( the one with "zip" extension). + - Disk spanning archive in creation - the size of the volume. + + \see CZipArchive::Open + \see CZipArchive::GetSpanMode + + */ int m_iTdSpanData; -protected: -// how many bytes left free in the write buffer - DWORD GetFreeInBuffer(); - friend class CZipCentralDir; -// numer of bytes available in the write buffer + /** + \return the count bytes left free in the write buffer + */ + DWORD GetFreeInBuffer() const {return m_pWriteBuffer.GetSize() - m_uBytesInWriteBuffer;} + + /** + Number of bytes available in the write buffer. + */ DWORD m_uBytesInWriteBuffer; -// tdSpan : the total size of the current volume, pkSpan : free space on the current volume +/** + The value it holds depends on the open mode: + \par + - #tdSpan : the total size of the current volume + - #pkzipSpan: a free space on the current volume +*/ DWORD m_uCurrentVolSize; -// return the number of bytes left on the current volume - DWORD VolumeLeft(); -// write data to the internal buffer - void WriteInternalBuffer(char *pBuf, DWORD uSize); - -// number of bytes left free in the write buffer + /** + number of bytes left free in the write buffer + */ DWORD m_uVolumeFreeInBuffer; + /** + Write buffer caching data. + */ CZipAutoBuffer m_pWriteBuffer; -// return the number of free bytes on the current removable disk - DWORD GetFreeVolumeSpace(); - void CallCallback(int iCode, CString szTemp); - -// only disk spanning creation: tells how many bytes have been written physically to the current volume + /** + Used only during disk spanning archive creation. + Tells how many bytes have been written physically to the current volume. + */ DWORD m_iBytesWritten; -// construct the name of the volume in tdSpan mode - CString GetTdVolumeName(bool bLast, LPCTSTR lpszZipName = NULL); - -// change the disk in tdSpan mode - CString ChangeTdRead(); - -// change the disk in pkSpan mode - CString ChangePkzipRead(); - -// you can only add a new files to the new disk spanning archive and only extract -// them from the existing one + /** + \c True, if the current archive is a new disk spanning archive. + */ bool m_bNewSpan; + /** + The current disk in a disk spanning archive. + Disk no 0 is the first disk. + */ int m_iCurrentDisk; - bool OpenFile(LPCTSTR lpszName, UINT uFlags, bool bThrow = true); - void ThrowError(int err); + + /** + It is set to \e true when an archive is created in memory; \e false otherwise. + */ + bool m_bInMemory; + + /** + It is set to \e true if OpenMode::zipOpenReadOnly was specified when opening the archive + */ + bool m_bReadOnly; }; diff --git a/stepmania/src/smpackage/ZipArchive/ZipString.cpp b/stepmania/src/smpackage/ZipArchive/ZipString.cpp new file mode 100644 index 0000000000..1df02b1ef0 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/ZipString.cpp @@ -0,0 +1,25 @@ +//////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipString.cpp $ +// $Archive: /ZipArchive/ZipString.cpp $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt +//////////////////////////////////////////////////////////////////////////////// + +#include "ZipString.h" + +ZIPSTRINGCOMPARE GetCZipStrCompFunc(bool bCaseSensitive, bool bCollate) +{ + if (bCollate) + return bCaseSensitive ? & CZipString::Collate : & CZipString::CollateNoCase; + else + return bCaseSensitive ? & CZipString::Compare : & CZipString::CompareNoCase; +} diff --git a/stepmania/src/smpackage/ZipArchive/ZipString.h b/stepmania/src/smpackage/ZipArchive/ZipString.h new file mode 100644 index 0000000000..9e2cf7690e --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/ZipString.h @@ -0,0 +1,38 @@ +//////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipString.h $ +// $Archive: /ZipArchive/ZipString.h $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt +//////////////////////////////////////////////////////////////////////////////// + +#ifndef ZIPSTRING_DOT_H +#define ZIPSTRING_DOT_H +#include "stdafx.h" + + +typedef CString CZipString; + +/** + A poiter type to point to CZipString to Collate or CollateNoCase + or Compare or CompareNoCase +*/ +typedef int (CZipString::*ZIPSTRINGCOMPARE)( LPCTSTR ) const; + + + +/** + return a pointer to the function in CZipString structure, + used to compare elements depending on the arguments +*/ + ZIPSTRINGCOMPARE GetCZipStrCompFunc(bool bCaseSensitive, bool bCollate = true); + +#endif /* ZIPSTRING_DOT_H */ diff --git a/stepmania/src/smpackage/ZipArchive/__Windows_MFC.zcfg b/stepmania/src/smpackage/ZipArchive/__Windows_MFC.zcfg new file mode 100644 index 0000000000..e69de29bb2 diff --git a/stepmania/src/smpackage/ZipArchive/_version.txt b/stepmania/src/smpackage/ZipArchive/_version.txt new file mode 100644 index 0000000000..8bbe6cf74a --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/_version.txt @@ -0,0 +1 @@ +2.2 diff --git a/stepmania/src/smpackage/ZipArchive/faq.txt b/stepmania/src/smpackage/ZipArchive/faq.txt new file mode 100644 index 0000000000..3a28b2a777 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/faq.txt @@ -0,0 +1,211 @@ +/* + +For conditions of distribution and use, see the copyright notice in License.txt. +Please read the documentation instead of this document +(it may be difficult to read it due to formatting tags for an automatic documentation generation). +If you do not have it, please download it from http://www.artpol-software.com/ + +*/ + +/** \page pageFaq FAQ + + + +Q: I experience linking problems. What to do? + + + +Q: When do I need to purchase the commercial license? + + + + +Q: When I open a multi-disk archive (Pkzip mode) and the last disk is not in + the drive, I receive the CZipException::cdirNotFound exception. How to detect + whether the last disk is in the drive? + + + +Q: Of what size should be a single volume in a multi-disk archive created in +the TD span mode ? + + + + +Q: How can I detect the disk spanning mode of an archive? + + + +Q: How to integrate the library with the sample application? + + + +Q: Why the library doesn't want to extract archives (mostly old)? + + + +Q: In CZipArchive::AddNewFile and CZipArchive::ExtractFile I want to use partial +path for the filename inside the archive. + + + +Q: I want to create an archive that will be readable under Unix/Linux. + + + +Q: How can I use UNC path with CZipArchive::ExtractFile function ? + + + +Q: How to create a zip archive in memory and then write it to disk or +read the archive from the disk and extract from memory ? + + + +Q: How can I extract or delete files that matches a specified wildcard pattern ? + + +
+***************************************************************************** +\anchor q1 + +Q: I experience linking problems. What to do? + + +A: +\par If you get mostly LNK2005 : + You need to make sure that + the library and your program are both using single-threaded or both + multithreaded (or multithreaded DLL) run-time library. The option Project->Settings-> c/c++ ->Code Generation->Use run-time library + should be set to the same value in the ZipArchive library and the program + project options. Make sure that you link appropriate configurations (Release against Release, Debug against Debug...) + and that you're using MFC library in the same way (shared, static or not using) in those configurations. +\par If you get LNK1104 (e.g. cannot open file "mfc42u.lib") + You're trying to compile the Unicode version but you haven't installed the necessary libraries. +When installing Visual C++ Professional for example, you need to check the boxes "Static Libraries for Unicode" and +"Shared Libraries for Unicode". They are in "VC++ MFC and Template libraries\MS Foundation Class Libraries". +You don't need to reinstall the Visual Studio to add them. + + + + +\anchor q13 + +Q: When do I need to purchase the commercial license? + + +A: The ZipArchive library is distributed under GNU GPL which implies that it can only be used +with software that is licensed under conditions compliant with the GPL. It means that +you need to provide a customer with the source code of your software that uses the library. +The commercial license removes this obligation. You can find out more at \ref s1. + +\anchor q2 + +Q: When I open a multi-disk archive (Pkzip mode) and the last disk is not in + the drive, I receive the CZipException::cdirNotFound exception. How to detect + whether the last disk is in the drive? + + +A: The last disk can not be detected before opening an archive. The only way to +prevent the program from failing when an incorrect disk is inserted is to +catch the CZipException::cdirNotFound exception while opening the archive and keep prompting the user to insert the last disk into the drive. Please see the sample application on how +it can be done in details. + +\anchor q3 + +Q: Of what size should be a single volume in a multi-disk archive created in +the TD span mode ? + + +A: The size of the volume may be from 1 byte to the maximum integer value, and the bigger - the + faster is creation and extraction (no file changes meantime), but the size + of the whole archive is the same. The optimal solution is to set it to about + the size of the diskette (a little less to be comfortable when there are bad sectors found on the disk) to allow the future conversion to PKZIP span mode. + +\anchor q5 + +Q: How can I detect the disk spanning mode of an archive? + + +A: You need to open the archive and the call CZipArchive::GetSpanMode. When opening the archive in tdSpan mode on a removable device, you should set \e iVolumeSize to a non-zero value while opening the archive (with CZipArchive::Open). There is no universal way to distinguish a PKSpan archive from a TDSpan archive on a removable device, because they have identical internal structure. + + +\anchor q7 + +Q: How to integrate the library with the sample application? + + +A:The usual way is to put ZipArchive library at the same directory level what your +project is, and then use one of the \ref sectVisual "integration methods". +Make a directory structure like this:
+\htmlonly +---
+    |-ZipArc           // the application project
+    |-ZipArchive   // the ZipArchive library
+\endhtmlonly + +You can now follow the integration method 1 or 2 (the easier one). + +\anchor q8 + +Q: Why the library doesn't want to extract archives (mostly old)? + + +A: The common reason is that the data is compressed using \e imploded method (usually with old archivers). +The only methods supported by the zlib library are \e deflation which is the most commonly used by archivers and \e storing which is in fact not a compression method. You can use a compiled ZipArc application to find out what method the file was compressed with (View->File Info) + + +\anchor q9 + +Q: In CZipArchive::AddNewFile and CZipArchive::ExtractFile I want to use partial +path for the filename inside the archive. For example:
+When I compress some directory, like this: + c:\program files\example (full directory path: c:\program files\example\text\txt) + it comes with the whole path. I would like that the zip only get the EXAMPLE\text\txt path. + + + +A: You can set \e bFullPath argument to \c false in these functions and set +the beginning part of the path that you commonly want to eliminate with +CZipArchive::SetRootPath function. In the example above you'd set it to +c:\program files\ (the path separator at the end is added automatically). + +\anchor q10 + +Q: I want to create an archive that will be readable under Unix/Linux. + + +A: Inside the archive there is an information stored about the system it was +created under. It helps converting the file attributes that are stored inside +the archive to file attributes that are used on the system on which the file is extracted. +Some Unix archivers cannot convert Windows attributes to Unix, so that it is needed +to create the archive with the Unix attributes already (and the internal info about the +system set to a Unix value). To achieve that, simply call CZipArchive::SetSystemCompatibility +with the argument set to ZipCompatibility::zcUnix after creating the archive. + +\anchor q11 + +Q: How can I use UNC path with CZipArchive::ExtractFile function ? + + +A: You need to replace \\\\ at the beginning of the UNC path with \\\\?\UNC\ . + +\anchor q12 + +Q: How to create a zip archive in memory and then write it to a disk or +read the archive from the disk and extract from memory ? + + +A: See \ref sectMemory + +\anchor q14 + +Q: How can I extract or delete files that matches a specified wildcard pattern ? + + +A: You need to build a CZipWordArray with CZipArchive::FindMatches and then: +- to delete: use the array as an argument to CZipArchive::DeleteFiles +- to extract: the array stores the indexes of the files to extract; you need to +enumerate the array and pass the indexes one-by-one to CZipArchive::ExtractFile function + +*/ diff --git a/stepmania/src/smpackage/ZipArchive/gpl.txt b/stepmania/src/smpackage/ZipArchive/gpl.txt new file mode 100644 index 0000000000..29c8515ffa --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/gpl.txt @@ -0,0 +1,285 @@ +/** \page pageGPL GNU GENERAL PUBLIC LICENSE + + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Library General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + +*/ diff --git a/stepmania/src/smpackage/ZipArchive/mfc/ZipBaseException.h b/stepmania/src/smpackage/ZipArchive/mfc/ZipBaseException.h new file mode 100644 index 0000000000..c68c5ca511 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/mfc/ZipBaseException.h @@ -0,0 +1,22 @@ +/////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipBaseException.h $ +// $Archive: /ZipArchive/ZipBaseException.h $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt +//////////////////////////////////////////////////////////////////////////////// + +#ifndef __ZIPBASEEXCEPTION_H__ +#define __ZIPBASEEXCEPTION_H__ + +typedef CException CZipBaseException; + +#endif //__ZIPBASEEXCEPTION_H__4 diff --git a/stepmania/src/smpackage/ZipArchive/mfc/ZipCollections.h b/stepmania/src/smpackage/ZipArchive/mfc/ZipCollections.h new file mode 100644 index 0000000000..0bcdfe063e --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/mfc/ZipCollections.h @@ -0,0 +1,83 @@ +//////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipCollections.h $ +// $Archive: /ZipArchive/ZipCollections.h $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt +//////////////////////////////////////////////////////////////////////////////// + +#ifndef ZIPCOLLECTIONS_DOT_H +#define ZIPCOLLECTIONS_DOT_H + +#if _MSC_VER > 1000 +#pragma once +#pragma warning( push ) +#pragma warning (disable:4786) // 'identifier' : identifier was truncated to 'number' characters in the debug information +#endif // _MSC_VER > 1000 + +#include +typedef CStringArray CZipStringArray; + +template +class CZipArray : public CArray +{ + + static int CompareAsc(const void *pArg1, const void *pArg2) + { + TYPE w1 = *(TYPE*)pArg1; + TYPE w2 = *(TYPE*)pArg2; + return w1 == w2 ? 0 :(w2 > w1 ? - 1 : 1); + } + static int CompareDesc(const void *pArg1, const void *pArg2) + { + TYPE w1 = *(TYPE*)pArg1; + TYPE w2 = *(TYPE*)pArg2; + return w1 == w2 ? 0 :(w1 > w2 ? - 1 : 1); + } +public: + void Sort(bool bAscending) + { + int iSize = GetSize(); + if (!iSize) // if ommitted operator [] will fail if empty + return; + qsort((void*)&((*this)[0]),iSize , sizeof(TYPE), bAscending ? CompareAsc : CompareDesc); + } +}; + +typedef CZipArray CZipWordArray; + +template +class CZipPtrList : public CTypedPtrList +{ +public: + typedef POSITION iterator; + typedef POSITION const_iterator; + + bool IteratorValid(const iterator &iter) const + { + return iter != NULL; + } + +}; + +template +class CZipMap : public CMap +{ + +}; + +#ifdef _MFC_VER + #pragma warning( pop ) +#endif + + +#endif /* ZIPCOLLECTIONS_DOT_H */ + diff --git a/stepmania/src/smpackage/ZipArchive/mfc/ZipFile.cpp b/stepmania/src/smpackage/ZipArchive/mfc/ZipFile.cpp new file mode 100644 index 0000000000..9cabf1251c --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/mfc/ZipFile.cpp @@ -0,0 +1,54 @@ +//////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipFile.cpp $ +// $Archive: /ZipArchive/ZipFile.cpp $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt +//////////////////////////////////////////////////////////////////////////////// + +#include "stdafx.h" +#include "ZipFile.h" + +////////////////////////////////////////////////////////////////////// +// Construction/Destruction +////////////////////////////////////////////////////////////////////// + +// IMPLEMENT_DYNAMIC(CZipAbstractFile, CFile) +IMPLEMENT_DYNAMIC(CZipFile, CFile) + +CZipFile::CZipFile() +{ +} + +CZipFile::~CZipFile() +{ + +} + + +// __int64 CZipFile::Seek(__int64 dOff, UINT nFrom) +// { +// ASSERT_VALID(this); +// ASSERT(m_hFile != (UINT)hFileNull); +// ASSERT(nFrom == begin || nFrom == end || nFrom == current); +// ASSERT(begin == FILE_BEGIN && end == FILE_END && current == FILE_CURRENT); +// LARGE_INTEGER li; +// li.QuadPart = dOff; +// +// li.LowPart = ::SetFilePointer((HANDLE)m_hFile, li.LowPart, &li.HighPart, (DWORD)nFrom); +// DWORD dw = GetLastError(); +// if ((li.LowPart == (DWORD)-1) && (dw != NO_ERROR)) +// { +// CFileException::ThrowOsError((LONG)dw); +// } +// +// return li.QuadPart; +// } diff --git a/stepmania/src/smpackage/ZipArchive/mfc/ZipFile.h b/stepmania/src/smpackage/ZipArchive/mfc/ZipFile.h new file mode 100644 index 0000000000..af5b103704 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/mfc/ZipFile.h @@ -0,0 +1,67 @@ +//////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipFile.h $ +// $Archive: /ZipArchive/ZipFile.h $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt +//////////////////////////////////////////////////////////////////////////////// + +#if !defined(AFX_ZIPFILE_H__80609DE0_2C6D_4C94_A90C_0BE34A50C769__INCLUDED_) +#define AFX_ZIPFILE_H__80609DE0_2C6D_4C94_A90C_0BE34A50C769__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 +#include "ZipAbstractFile.h" + +class CZipFile :public CZipAbstractFile, public CFile +{ +public: + DECLARE_DYNAMIC(CZipFile) +// __int64 Seek(__int64 dOff, UINT nFrom); + void Flush(){CFile::Flush();} + DWORD GetPosition() const {return CFile::GetPosition() ;} + CZipString GetFilePath() const {return CFile::GetFilePath();} + void SetLength(long nNewLen) {CFile::SetLength(nNewLen);} + UINT Read(void *lpBuf, UINT nCount){return CFile::Read(lpBuf, nCount);} + void Write(const void* lpBuf, UINT nCount){CFile::Write(lpBuf, nCount);} + long Seek(long lOff, int nFrom){return CFile::Seek(lOff, nFrom);} + DWORD GetLength() const {return CFile::GetLength();} + bool Open( LPCTSTR lpszFileName, UINT nOpenFlags, bool bThrowExc) + { + CFileException* e = new CFileException; + bool bRet = CFile::Open(lpszFileName, nOpenFlags, e) != 0; + if (!bRet && bThrowExc) + throw e; + e->Delete(); + return bRet; + + } + CZipFile(); + bool IsClosed() const + { + return m_hFile == (UINT)CFile::hFileNull; + } + + + CZipFile( LPCTSTR lpszFileName, UINT nOpenFlags ):CFile(lpszFileName, nOpenFlags) + { + } + void Close( ) + { + if (!IsClosed()) + CFile::Close(); + } + virtual ~CZipFile(); + +}; + +#endif // !defined(AFX_ZIPFILE_H__80609DE0_2C6D_4C94_A90C_0BE34A50C769__INCLUDED_) diff --git a/stepmania/src/smpackage/ZipArchive/mfc/ZipString.h b/stepmania/src/smpackage/ZipArchive/mfc/ZipString.h new file mode 100644 index 0000000000..9e2cf7690e --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/mfc/ZipString.h @@ -0,0 +1,38 @@ +//////////////////////////////////////////////////////////////////////////////// +// $Workfile: ZipString.h $ +// $Archive: /ZipArchive/ZipString.h $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt +//////////////////////////////////////////////////////////////////////////////// + +#ifndef ZIPSTRING_DOT_H +#define ZIPSTRING_DOT_H +#include "stdafx.h" + + +typedef CString CZipString; + +/** + A poiter type to point to CZipString to Collate or CollateNoCase + or Compare or CompareNoCase +*/ +typedef int (CZipString::*ZIPSTRINGCOMPARE)( LPCTSTR ) const; + + + +/** + return a pointer to the function in CZipString structure, + used to compare elements depending on the arguments +*/ + ZIPSTRINGCOMPARE GetCZipStrCompFunc(bool bCaseSensitive, bool bCollate = true); + +#endif /* ZIPSTRING_DOT_H */ diff --git a/stepmania/src/smpackage/ZipArchive/mfc/stdafx.h b/stepmania/src/smpackage/ZipArchive/mfc/stdafx.h new file mode 100644 index 0000000000..ea94a961f8 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/mfc/stdafx.h @@ -0,0 +1,41 @@ +/////////////////////////////////////////////////////////////////////////////// +// $Workfile: stdafx.h $ +// $Archive: /ZipArchive/stdafx.h $ +// $Date$ $Author$ +//////////////////////////////////////////////////////////////////////////////// +// This source file is part of the ZipArchive library source distribution and +// is Copyright 2000-2002 by Tadeusz Dracz (http://www.artpol-software.com/) +// +// 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. +// +// For the licensing details see the file License.txt +//////////////////////////////////////////////////////////////////////////////// + + +#if !defined(AFX_STDAFX_H__926F70F4_1B34_49AA_9532_498E8D2F3495__INCLUDED_) +#define AFX_STDAFX_H__926F70F4_1B34_49AA_9532_498E8D2F3495__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#ifdef __BORLANDC__ +#define ZIPINLINE +#else +#define ZIPINLINE inline +#endif + +#define ZIP_ARCHIVE_MFC + +#define VC_EXTRALEAN // Exclude rarely-used stuff from Windows headers +#include +#include + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_STDAFX_H__926F70F4_1B34_49AA_9532_498E8D2F3495__INCLUDED_) + diff --git a/stepmania/src/smpackage/ZipArchive/zlib/Makefile b/stepmania/src/smpackage/ZipArchive/zlib/Makefile new file mode 100644 index 0000000000..0de2cbc6ee --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/zlib/Makefile @@ -0,0 +1,79 @@ +# Makefile for zlib +# Copyright (C) 1995-1998 Jean-loup Gailly. +# For conditions of distribution and use, see copyright notice in zlib.h +# To install /usr/lib/libz.* and /usr/include/zlib.h, type: +# make install + + +CC=cc + +CFLAGS=-O +#CFLAGS=-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7 +#CFLAGS=-g -DDEBUG +#CFLAGS=-O3 -Wall -Wwrite-strings -Wpointer-arith -Wconversion \ +# -Wstrict-prototypes -Wmissing-prototypes + +CPP=$(CC) -E + +VER=1.1.3 +LIBS=libz.a + +AR=ar rc +RANLIB=ranlib + +prefix = /usr +exec_prefix = ${prefix} +libdir = ${exec_prefix}/lib +includedir = ${prefix}/include + +OBJS = adler32.o compress.o crc32.o uncompr.o deflate.o trees.o \ + zutil.o inflate.o infblock.o inftrees.o infcodes.o infutil.o inffast.o + +OBJA = +# to use the asm code: make OBJA=match.o + +libz.a: $(OBJS) $(OBJA) + $(AR) $@ $(OBJS) $(OBJA) + -@ ($(RANLIB) $@ || true) >/dev/null 2>&1 + + +install: $(LIBS) + -@if [ ! -d $(includedir) ]; then mkdir $(includedir); fi + -@if [ ! -d $(libdir) ]; then mkdir $(libdir); fi + cp zlib.h zconf.h $(includedir) + chmod 644 $(includedir)/zlib.h $(includedir)/zconf.h + cp $(LIBS) $(libdir) + cd $(libdir); chmod 755 $(LIBS) + -@(cd $(libdir); $(RANLIB) libz.a || true) >/dev/null 2>&1 + +# The ranlib in install is needed on NeXTSTEP which checks file times +# ldconfig is for Linux + +uninstall: + cd $(includedir); \ + v=$(VER); \ + if test -f zlib.h; then \ + v=`sed -n '/VERSION "/s/.*"\(.*\)".*/\1/p' < zlib.h`; \ + rm -f zlib.h zconf.h; \ + fi; \ + cd $(libdir); rm -f libz.a; \ + +clean: + rm -f *.o *~ libz.a +# DO NOT DELETE THIS LINE -- make depend depends on it. + +adler32.o: zlib.h zconf.h +compress.o: zlib.h zconf.h +crc32.o: zlib.h zconf.h +deflate.o: deflate.h zutil.h zlib.h zconf.h +infblock.o: infblock.h inftrees.h infcodes.h infutil.h zutil.h zlib.h zconf.h +infcodes.o: zutil.h zlib.h zconf.h +infcodes.o: inftrees.h infblock.h infcodes.h infutil.h inffast.h +inffast.o: zutil.h zlib.h zconf.h inftrees.h +inffast.o: infblock.h infcodes.h infutil.h inffast.h +inflate.o: zutil.h zlib.h zconf.h infblock.h +inftrees.o: zutil.h zlib.h zconf.h inftrees.h +infutil.o: zutil.h zlib.h zconf.h infblock.h inftrees.h infcodes.h infutil.h +trees.o: deflate.h zutil.h zlib.h zconf.h trees.h +uncompr.o: zlib.h zconf.h +zutil.o: zutil.h zlib.h zconf.h diff --git a/stepmania/src/smpackage/ZipArchive/zlib/adler32.c b/stepmania/src/smpackage/ZipArchive/zlib/adler32.c new file mode 100644 index 0000000000..b2a48904bc --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/zlib/adler32.c @@ -0,0 +1,49 @@ +/* adler32.c -- compute the Adler-32 checksum of a data stream + * Copyright (C) 1995-1998 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + + + +#include "zlib.h" + +#define BASE 65521L /* largest prime smaller than 65536 */ +#define NMAX 5552 +/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */ + +#define DO1(buf,i) {s1 += buf[i]; s2 += s1;} +#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); +#define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); +#define DO8(buf,i) DO4(buf,i); DO4(buf,i+4); +#define DO16(buf) DO8(buf,0); DO8(buf,8); + +/* ========================================================================= */ +uLong ZEXPORT adler32(adler, buf, len) + uLong adler; + const Bytef *buf; + uInt len; +{ + unsigned long s1 = adler & 0xffff; + unsigned long s2 = (adler >> 16) & 0xffff; + int k; + + if (buf == Z_NULL) return 1L; + + while (len > 0) { + k = len < NMAX ? len : NMAX; + len -= k; + while (k >= 16) { + DO16(buf); + buf += 16; + k -= 16; + } + if (k != 0) do { + s1 += *buf++; + s2 += s1; + } while (--k); + s1 %= BASE; + s2 %= BASE; + } + return (s2 << 16) | s1; +} + diff --git a/stepmania/src/smpackage/ZipArchive/zlib/compress.c b/stepmania/src/smpackage/ZipArchive/zlib/compress.c new file mode 100644 index 0000000000..0919ff79f8 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/zlib/compress.c @@ -0,0 +1,68 @@ +/* compress.c -- compress a memory buffer + * Copyright (C) 1995-1998 Jean-loup Gailly. + * For conditions of distribution and use, see copyright notice in zlib.h + */ + + + +#include "zlib.h" + +/* =========================================================================== + Compresses the source buffer into the destination buffer. The level + parameter has the same meaning as in deflateInit. sourceLen is the byte + length of the source buffer. Upon entry, destLen is the total size of the + destination buffer, which must be at least 0.1% larger than sourceLen plus + 12 bytes. Upon exit, destLen is the actual size of the compressed buffer. + + compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_BUF_ERROR if there was not enough room in the output buffer, + Z_STREAM_ERROR if the level parameter is invalid. +*/ +int ZEXPORT compress2 (dest, destLen, source, sourceLen, level) + Bytef *dest; + uLongf *destLen; + const Bytef *source; + uLong sourceLen; + int level; +{ + z_stream stream; + int err; + + stream.next_in = (Bytef*)source; + stream.avail_in = (uInt)sourceLen; +#ifdef MAXSEG_64K + /* Check for source > 64K on 16-bit machine: */ + if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR; +#endif + stream.next_out = dest; + stream.avail_out = (uInt)*destLen; + if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR; + + stream.zalloc = (alloc_func)0; + stream.zfree = (free_func)0; + stream.opaque = (voidpf)0; + + err = deflateInit(&stream, level); + if (err != Z_OK) return err; + + err = deflate(&stream, Z_FINISH); + if (err != Z_STREAM_END) { + deflateEnd(&stream); + return err == Z_OK ? Z_BUF_ERROR : err; + } + *destLen = stream.total_out; + + err = deflateEnd(&stream); + return err; +} + +/* =========================================================================== + */ +int ZEXPORT compress (dest, destLen, source, sourceLen) + Bytef *dest; + uLongf *destLen; + const Bytef *source; + uLong sourceLen; +{ + return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION); +} diff --git a/stepmania/src/smpackage/ZipArchive/zlib/crc32.c b/stepmania/src/smpackage/ZipArchive/zlib/crc32.c new file mode 100644 index 0000000000..8e8ffc3f80 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/zlib/crc32.c @@ -0,0 +1,161 @@ +/* crc32.c -- compute the CRC-32 of a data stream + * Copyright (C) 1995-1998 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + + +#include "zlib.h" + +#define local static + +#ifdef DYNAMIC_CRC_TABLE + +local int crc_table_empty = 1; +local uLongf crc_table[256]; +local void make_crc_table OF((void)); + +/* + Generate a table for a byte-wise 32-bit CRC calculation on the polynomial: + x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1. + + Polynomials over GF(2) are represented in binary, one bit per coefficient, + with the lowest powers in the most significant bit. Then adding polynomials + is just exclusive-or, and multiplying a polynomial by x is a right shift by + one. If we call the above polynomial p, and represent a byte as the + polynomial q, also with the lowest power in the most significant bit (so the + byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p, + where a mod b means the remainder after dividing a by b. + + This calculation is done using the shift-register method of multiplying and + taking the remainder. The register is initialized to zero, and for each + incoming bit, x^32 is added mod p to the register if the bit is a one (where + x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by + x (which is shifting right by one and adding x^32 mod p if the bit shifted + out is a one). We start with the highest power (least significant bit) of + q and repeat for all eight bits of q. + + The table is simply the CRC of all possible eight bit values. This is all + the information needed to generate CRC's on data a byte at a time for all + combinations of CRC register values and incoming bytes. +*/ +local void make_crc_table() +{ + uLong c; + int n, k; + uLong poly; /* polynomial exclusive-or pattern */ + /* terms of polynomial defining this crc (except x^32): */ + static const Byte p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26}; + + /* make exclusive-or pattern from polynomial (0xedb88320L) */ + poly = 0L; + for (n = 0; n < sizeof(p)/sizeof(Byte); n++) + poly |= 1L << (31 - p[n]); + + for (n = 0; n < 256; n++) + { + c = (uLong)n; + for (k = 0; k < 8; k++) + c = c & 1 ? poly ^ (c >> 1) : c >> 1; + crc_table[n] = c; + } + crc_table_empty = 0; +} +#else +/* ======================================================================== + * Table of CRC-32's of all single-byte values (made by make_crc_table) + */ +local const uLongf crc_table[256] = { + 0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L, + 0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L, + 0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, + 0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL, + 0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L, + 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L, + 0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, + 0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL, + 0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L, + 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL, + 0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, + 0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L, + 0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L, + 0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL, + 0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, + 0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L, + 0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL, + 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L, + 0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, + 0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L, + 0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL, + 0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L, + 0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L, + 0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL, + 0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L, + 0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L, + 0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L, + 0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L, + 0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L, + 0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL, + 0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL, + 0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L, + 0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L, + 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL, + 0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL, + 0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L, + 0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL, + 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L, + 0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL, + 0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L, + 0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL, + 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L, + 0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L, + 0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL, + 0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L, + 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L, + 0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L, + 0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L, + 0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L, + 0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L, + 0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, + 0x2d02ef8dL +}; +#endif + +/* ========================================================================= + * This function can be used by asm versions of crc32() + */ +const uLongf * ZEXPORT get_crc_table() +{ +#ifdef DYNAMIC_CRC_TABLE + if (crc_table_empty) make_crc_table(); +#endif + return (const uLongf *)crc_table; +} + +/* ========================================================================= */ +#define DO1(buf) crc = crc_table[((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8); +#define DO2(buf) DO1(buf); DO1(buf); +#define DO4(buf) DO2(buf); DO2(buf); +#define DO8(buf) DO4(buf); DO4(buf); + +/* ========================================================================= */ +uLong ZEXPORT crc32(crc, buf, len) + uLong crc; + const Bytef *buf; + uInt len; +{ + if (buf == Z_NULL) return 0L; +#ifdef DYNAMIC_CRC_TABLE + if (crc_table_empty) + make_crc_table(); +#endif + crc = crc ^ 0xffffffffL; + while (len >= 8) + { + DO8(buf); + len -= 8; + } + if (len) do { + DO1(buf); + } while (--len); + return crc ^ 0xffffffffL; +} diff --git a/stepmania/src/smpackage/ZipArchive/zlib/deflate.c b/stepmania/src/smpackage/ZipArchive/zlib/deflate.c new file mode 100644 index 0000000000..3cdcc5a523 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/zlib/deflate.c @@ -0,0 +1,1349 @@ +/* deflate.c -- compress data using the deflation algorithm + * Copyright (C) 1995-1998 Jean-loup Gailly. + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* + * ALGORITHM + * + * The "deflation" process depends on being able to identify portions + * of the input text which are identical to earlier input (within a + * sliding window trailing behind the input currently being processed). + * + * The most straightforward technique turns out to be the fastest for + * most input files: try all possible matches and select the longest. + * The key feature of this algorithm is that insertions into the string + * dictionary are very simple and thus fast, and deletions are avoided + * completely. Insertions are performed at each input character, whereas + * string matches are performed only when the previous match ends. So it + * is preferable to spend more time in matches to allow very fast string + * insertions and avoid deletions. The matching algorithm for small + * strings is inspired from that of Rabin & Karp. A brute force approach + * is used to find longer strings when a small match has been found. + * A similar algorithm is used in comic (by Jan-Mark Wams) and freeze + * (by Leonid Broukhis). + * A previous version of this file used a more sophisticated algorithm + * (by Fiala and Greene) which is guaranteed to run in linear amortized + * time, but has a larger average cost, uses more memory and is patented. + * However the F&G algorithm may be faster for some highly redundant + * files if the parameter max_chain_length (described below) is too large. + * + * ACKNOWLEDGEMENTS + * + * The idea of lazy evaluation of matches is due to Jan-Mark Wams, and + * I found it in 'freeze' written by Leonid Broukhis. + * Thanks to many people for bug reports and testing. + * + * REFERENCES + * + * Deutsch, L.P.,"DEFLATE Compressed Data Format Specification". + * Available in ftp://ds.internic.net/rfc/rfc1951.txt + * + * A description of the Rabin and Karp algorithm is given in the book + * "Algorithms" by R. Sedgewick, Addison-Wesley, p252. + * + * Fiala,E.R., and Greene,D.H. + * Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595 + * + */ + + +#include "deflate.h" + +const char deflate_copyright[] = + " deflate 1.1.3 Copyright 1995-1998 Jean-loup Gailly "; +/* + If you use the zlib library in a product, an acknowledgment is welcome + in the documentation of your product. If for some reason you cannot + include such an acknowledgment, I would appreciate that you keep this + copyright string in the executable of your product. + */ + +/* =========================================================================== + * Function prototypes. + */ +typedef enum { + need_more, /* block not completed, need more input or more output */ + block_done, /* block flush performed */ + finish_started, /* finish started, need only more output at next deflate */ + finish_done /* finish done, accept no more input or output */ +} block_state; + +typedef block_state (*compress_func) OF((deflate_state *s, int flush)); +/* Compression function. Returns the block state after the call. */ + +local void fill_window OF((deflate_state *s)); +local block_state deflate_stored OF((deflate_state *s, int flush)); +local block_state deflate_fast OF((deflate_state *s, int flush)); +local block_state deflate_slow OF((deflate_state *s, int flush)); +local void lm_init OF((deflate_state *s)); +local void putShortMSB OF((deflate_state *s, uInt b)); +local void flush_pending OF((z_streamp strm)); +local int read_buf OF((z_streamp strm, Bytef *buf, unsigned size)); +#ifdef ASMV + void match_init OF((void)); /* asm code initialization */ + uInt longest_match OF((deflate_state *s, IPos cur_match)); +#else +local uInt longest_match OF((deflate_state *s, IPos cur_match)); +#endif + +#ifdef DEBUG +local void check_match OF((deflate_state *s, IPos start, IPos match, + int length)); +#endif + +/* =========================================================================== + * Local data + */ + +#define NIL 0 +/* Tail of hash chains */ + +#ifndef TOO_FAR +# define TOO_FAR 4096 +#endif +/* Matches of length 3 are discarded if their distance exceeds TOO_FAR */ + +#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1) +/* Minimum amount of lookahead, except at the end of the input file. + * See deflate.c for comments about the MIN_MATCH+1. + */ + +/* Values for max_lazy_match, good_match and max_chain_length, depending on + * the desired pack level (0..9). The values given below have been tuned to + * exclude worst case performance for pathological files. Better values may be + * found for specific files. + */ +typedef struct config_s { + ush good_length; /* reduce lazy search above this match length */ + ush max_lazy; /* do not perform lazy search above this match length */ + ush nice_length; /* quit search above this match length */ + ush max_chain; + compress_func func; +} config; + +local const config configuration_table[10] = { +/* good lazy nice chain */ +/* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */ +/* 1 */ {4, 4, 8, 4, deflate_fast}, /* maximum speed, no lazy matches */ +/* 2 */ {4, 5, 16, 8, deflate_fast}, +/* 3 */ {4, 6, 32, 32, deflate_fast}, + +/* 4 */ {4, 4, 16, 16, deflate_slow}, /* lazy matches */ +/* 5 */ {8, 16, 32, 32, deflate_slow}, +/* 6 */ {8, 16, 128, 128, deflate_slow}, +/* 7 */ {8, 32, 128, 256, deflate_slow}, +/* 8 */ {32, 128, 258, 1024, deflate_slow}, +/* 9 */ {32, 258, 258, 4096, deflate_slow}}; /* maximum compression */ + +/* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4 + * For deflate_fast() (levels <= 3) good is ignored and lazy has a different + * meaning. + */ + +#define EQUAL 0 +/* result of memcmp for equal strings */ + +struct static_tree_desc_s {int dummy;}; /* for buggy compilers */ + +/* =========================================================================== + * Update a hash value with the given input byte + * IN assertion: all calls to to UPDATE_HASH are made with consecutive + * input characters, so that a running hash key can be computed from the + * previous key instead of complete recalculation each time. + */ +#define UPDATE_HASH(s,h,c) (h = (((h)<hash_shift) ^ (c)) & s->hash_mask) + + +/* =========================================================================== + * Insert string str in the dictionary and set match_head to the previous head + * of the hash chain (the most recent string with same hash key). Return + * the previous length of the hash chain. + * If this file is compiled with -DFASTEST, the compression level is forced + * to 1, and no hash chains are maintained. + * IN assertion: all calls to to INSERT_STRING are made with consecutive + * input characters and the first MIN_MATCH bytes of str are valid + * (except for the last MIN_MATCH-1 bytes of the input file). + */ +#ifdef FASTEST +#define INSERT_STRING(s, str, match_head) \ + (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \ + match_head = s->head[s->ins_h], \ + s->head[s->ins_h] = (Pos)(str)) +#else +#define INSERT_STRING(s, str, match_head) \ + (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \ + s->prev[(str) & s->w_mask] = match_head = s->head[s->ins_h], \ + s->head[s->ins_h] = (Pos)(str)) +#endif + +/* =========================================================================== + * Initialize the hash table (avoiding 64K overflow for 16 bit systems). + * prev[] will be initialized on the fly. + */ +#define CLEAR_HASH(s) \ + s->head[s->hash_size-1] = NIL; \ + zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head)); + +/* ========================================================================= */ +int ZEXPORT deflateInit_(strm, level, version, stream_size) + z_streamp strm; + int level; + const char *version; + int stream_size; +{ + return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, + Z_DEFAULT_STRATEGY, version, stream_size); + /* To do: ignore strm->next_in if we use it as window */ +} + +/* ========================================================================= */ +int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy, + version, stream_size) + z_streamp strm; + int level; + int method; + int windowBits; + int memLevel; + int strategy; + const char *version; + int stream_size; +{ + deflate_state *s; + int noheader = 0; + static const char* my_version = ZLIB_VERSION; + + ushf *overlay; + /* We overlay pending_buf and d_buf+l_buf. This works since the average + * output size for (length,distance) codes is <= 24 bits. + */ + + if (version == Z_NULL || version[0] != my_version[0] || + stream_size != sizeof(z_stream)) { + return Z_VERSION_ERROR; + } + if (strm == Z_NULL) return Z_STREAM_ERROR; + + strm->msg = Z_NULL; + if (strm->zalloc == Z_NULL) { + strm->zalloc = zcalloc; + strm->opaque = (voidpf)0; + } + if (strm->zfree == Z_NULL) strm->zfree = zcfree; + + if (level == Z_DEFAULT_COMPRESSION) level = 6; +#ifdef FASTEST + level = 1; +#endif + + if (windowBits < 0) { /* undocumented feature: suppress zlib header */ + noheader = 1; + windowBits = -windowBits; + } + if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED || + windowBits < 8 || windowBits > 15 || level < 0 || level > 9 || + strategy < 0 || strategy > Z_HUFFMAN_ONLY) { + return Z_STREAM_ERROR; + } + s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state)); + if (s == Z_NULL) return Z_MEM_ERROR; + strm->state = (struct internal_state FAR *)s; + s->strm = strm; + + s->noheader = noheader; + s->w_bits = windowBits; + s->w_size = 1 << s->w_bits; + s->w_mask = s->w_size - 1; + + s->hash_bits = memLevel + 7; + s->hash_size = 1 << s->hash_bits; + s->hash_mask = s->hash_size - 1; + s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH); + + s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte)); + s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos)); + s->head = (Posf *) ZALLOC(strm, s->hash_size, sizeof(Pos)); + + s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */ + + overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2); + s->pending_buf = (uchf *) overlay; + s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush)+2L); + + if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL || + s->pending_buf == Z_NULL) { + strm->msg = (char*)ERR_MSG(Z_MEM_ERROR); + deflateEnd (strm); + return Z_MEM_ERROR; + } + s->d_buf = overlay + s->lit_bufsize/sizeof(ush); + s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize; + + s->level = level; + s->strategy = strategy; + s->method = (Byte)method; + + return deflateReset(strm); +} + +/* ========================================================================= */ +int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength) + z_streamp strm; + const Bytef *dictionary; + uInt dictLength; +{ + deflate_state *s; + uInt length = dictLength; + uInt n; + IPos hash_head = 0; + + if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL || + strm->state->status != INIT_STATE) return Z_STREAM_ERROR; + + s = strm->state; + strm->adler = adler32(strm->adler, dictionary, dictLength); + + if (length < MIN_MATCH) return Z_OK; + if (length > MAX_DIST(s)) { + length = MAX_DIST(s); +#ifndef USE_DICT_HEAD + dictionary += dictLength - length; /* use the tail of the dictionary */ +#endif + } + zmemcpy(s->window, dictionary, length); + s->strstart = length; + s->block_start = (long)length; + + /* Insert all strings in the hash table (except for the last two bytes). + * s->lookahead stays null, so s->ins_h will be recomputed at the next + * call of fill_window. + */ + s->ins_h = s->window[0]; + UPDATE_HASH(s, s->ins_h, s->window[1]); + for (n = 0; n <= length - MIN_MATCH; n++) { + INSERT_STRING(s, n, hash_head); + } + if (hash_head) hash_head = 0; /* to make compiler happy */ + return Z_OK; +} + +/* ========================================================================= */ +int ZEXPORT deflateReset (strm) + z_streamp strm; +{ + deflate_state *s; + + if (strm == Z_NULL || strm->state == Z_NULL || + strm->zalloc == Z_NULL || strm->zfree == Z_NULL) return Z_STREAM_ERROR; + + strm->total_in = strm->total_out = 0; + strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */ + strm->data_type = Z_UNKNOWN; + + s = (deflate_state *)strm->state; + s->pending = 0; + s->pending_out = s->pending_buf; + + if (s->noheader < 0) { + s->noheader = 0; /* was set to -1 by deflate(..., Z_FINISH); */ + } + s->status = s->noheader ? BUSY_STATE : INIT_STATE; + strm->adler = 1; + s->last_flush = Z_NO_FLUSH; + + _tr_init(s); + lm_init(s); + + return Z_OK; +} + +/* ========================================================================= */ +int ZEXPORT deflateParams(strm, level, strategy) + z_streamp strm; + int level; + int strategy; +{ + deflate_state *s; + compress_func func; + int err = Z_OK; + + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + s = strm->state; + + if (level == Z_DEFAULT_COMPRESSION) { + level = 6; + } + if (level < 0 || level > 9 || strategy < 0 || strategy > Z_HUFFMAN_ONLY) { + return Z_STREAM_ERROR; + } + func = configuration_table[s->level].func; + + if (func != configuration_table[level].func && strm->total_in != 0) { + /* Flush the last buffer: */ + err = deflate(strm, Z_PARTIAL_FLUSH); + } + if (s->level != level) { + s->level = level; + s->max_lazy_match = configuration_table[level].max_lazy; + s->good_match = configuration_table[level].good_length; + s->nice_match = configuration_table[level].nice_length; + s->max_chain_length = configuration_table[level].max_chain; + } + s->strategy = strategy; + return err; +} + +/* ========================================================================= + * Put a short in the pending buffer. The 16-bit value is put in MSB order. + * IN assertion: the stream state is correct and there is enough room in + * pending_buf. + */ +local void putShortMSB (s, b) + deflate_state *s; + uInt b; +{ + put_byte(s, (Byte)(b >> 8)); + put_byte(s, (Byte)(b & 0xff)); +} + +/* ========================================================================= + * Flush as much pending output as possible. All deflate() output goes + * through this function so some applications may wish to modify it + * to avoid allocating a large strm->next_out buffer and copying into it. + * (See also read_buf()). + */ +local void flush_pending(strm) + z_streamp strm; +{ + unsigned len = strm->state->pending; + + if (len > strm->avail_out) len = strm->avail_out; + if (len == 0) return; + + zmemcpy(strm->next_out, strm->state->pending_out, len); + strm->next_out += len; + strm->state->pending_out += len; + strm->total_out += len; + strm->avail_out -= len; + strm->state->pending -= len; + if (strm->state->pending == 0) { + strm->state->pending_out = strm->state->pending_buf; + } +} + +/* ========================================================================= */ +int ZEXPORT deflate (strm, flush) + z_streamp strm; + int flush; +{ + int old_flush; /* value of flush param for previous deflate call */ + deflate_state *s; + + if (strm == Z_NULL || strm->state == Z_NULL || + flush > Z_FINISH || flush < 0) { + return Z_STREAM_ERROR; + } + s = strm->state; + + if (strm->next_out == Z_NULL || + (strm->next_in == Z_NULL && strm->avail_in != 0) || + (s->status == FINISH_STATE && flush != Z_FINISH)) { + ERR_RETURN(strm, Z_STREAM_ERROR); + } + if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR); + + s->strm = strm; /* just in case */ + old_flush = s->last_flush; + s->last_flush = flush; + + /* Write the zlib header */ + if (s->status == INIT_STATE) { + + uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8; + uInt level_flags = (s->level-1) >> 1; + + if (level_flags > 3) level_flags = 3; + header |= (level_flags << 6); + if (s->strstart != 0) header |= PRESET_DICT; + header += 31 - (header % 31); + + s->status = BUSY_STATE; + putShortMSB(s, header); + + /* Save the adler32 of the preset dictionary: */ + if (s->strstart != 0) { + putShortMSB(s, (uInt)(strm->adler >> 16)); + putShortMSB(s, (uInt)(strm->adler & 0xffff)); + } + strm->adler = 1L; + } + + /* Flush as much pending output as possible */ + if (s->pending != 0) { + flush_pending(strm); + if (strm->avail_out == 0) { + /* Since avail_out is 0, deflate will be called again with + * more output space, but possibly with both pending and + * avail_in equal to zero. There won't be anything to do, + * but this is not an error situation so make sure we + * return OK instead of BUF_ERROR at next call of deflate: + */ + s->last_flush = -1; + return Z_OK; + } + + /* Make sure there is something to do and avoid duplicate consecutive + * flushes. For repeated and useless calls with Z_FINISH, we keep + * returning Z_STREAM_END instead of Z_BUFF_ERROR. + */ + } else if (strm->avail_in == 0 && flush <= old_flush && + flush != Z_FINISH) { + ERR_RETURN(strm, Z_BUF_ERROR); + } + + /* User must not provide more input after the first FINISH: */ + if (s->status == FINISH_STATE && strm->avail_in != 0) { + ERR_RETURN(strm, Z_BUF_ERROR); + } + + /* Start a new block or continue the current one. + */ + if (strm->avail_in != 0 || s->lookahead != 0 || + (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) { + block_state bstate; + + bstate = (*(configuration_table[s->level].func))(s, flush); + + if (bstate == finish_started || bstate == finish_done) { + s->status = FINISH_STATE; + } + if (bstate == need_more || bstate == finish_started) { + if (strm->avail_out == 0) { + s->last_flush = -1; /* avoid BUF_ERROR next call, see above */ + } + return Z_OK; + /* If flush != Z_NO_FLUSH && avail_out == 0, the next call + * of deflate should use the same flush parameter to make sure + * that the flush is complete. So we don't have to output an + * empty block here, this will be done at next call. This also + * ensures that for a very small output buffer, we emit at most + * one empty block. + */ + } + if (bstate == block_done) { + if (flush == Z_PARTIAL_FLUSH) { + _tr_align(s); + } else { /* FULL_FLUSH or SYNC_FLUSH */ + _tr_stored_block(s, (char*)0, 0L, 0); + /* For a full flush, this empty block will be recognized + * as a special marker by inflate_sync(). + */ + if (flush == Z_FULL_FLUSH) { + CLEAR_HASH(s); /* forget history */ + } + } + flush_pending(strm); + if (strm->avail_out == 0) { + s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */ + return Z_OK; + } + } + } + Assert(strm->avail_out > 0, "bug2"); + + if (flush != Z_FINISH) return Z_OK; + if (s->noheader) return Z_STREAM_END; + + /* Write the zlib trailer (adler32) */ + putShortMSB(s, (uInt)(strm->adler >> 16)); + putShortMSB(s, (uInt)(strm->adler & 0xffff)); + flush_pending(strm); + /* If avail_out is zero, the application will call deflate again + * to flush the rest. + */ + s->noheader = -1; /* write the trailer only once! */ + return s->pending != 0 ? Z_OK : Z_STREAM_END; +} + +/* ========================================================================= */ +int ZEXPORT deflateEnd (strm) + z_streamp strm; +{ + int status; + + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + + status = strm->state->status; + if (status != INIT_STATE && status != BUSY_STATE && + status != FINISH_STATE) { + return Z_STREAM_ERROR; + } + + /* Deallocate in reverse order of allocations: */ + TRY_FREE(strm, strm->state->pending_buf); + TRY_FREE(strm, strm->state->head); + TRY_FREE(strm, strm->state->prev); + TRY_FREE(strm, strm->state->window); + + ZFREE(strm, strm->state); + strm->state = Z_NULL; + + return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK; +} + +/* ========================================================================= + * Copy the source state to the destination state. + * To simplify the source, this is not supported for 16-bit MSDOS (which + * doesn't have enough memory anyway to duplicate compression states). + */ +int ZEXPORT deflateCopy (dest, source) + z_streamp dest; + z_streamp source; +{ +#ifdef MAXSEG_64K + return Z_STREAM_ERROR; +#else + deflate_state *ds; + deflate_state *ss; + ushf *overlay; + + + if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) { + return Z_STREAM_ERROR; + } + + ss = source->state; + + *dest = *source; + + ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state)); + if (ds == Z_NULL) return Z_MEM_ERROR; + dest->state = (struct internal_state FAR *) ds; + *ds = *ss; + ds->strm = dest; + + ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte)); + ds->prev = (Posf *) ZALLOC(dest, ds->w_size, sizeof(Pos)); + ds->head = (Posf *) ZALLOC(dest, ds->hash_size, sizeof(Pos)); + overlay = (ushf *) ZALLOC(dest, ds->lit_bufsize, sizeof(ush)+2); + ds->pending_buf = (uchf *) overlay; + + if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL || + ds->pending_buf == Z_NULL) { + deflateEnd (dest); + return Z_MEM_ERROR; + } + /* following zmemcpy do not work for 16-bit MSDOS */ + zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte)); + zmemcpy(ds->prev, ss->prev, ds->w_size * sizeof(Pos)); + zmemcpy(ds->head, ss->head, ds->hash_size * sizeof(Pos)); + zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size); + + ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf); + ds->d_buf = overlay + ds->lit_bufsize/sizeof(ush); + ds->l_buf = ds->pending_buf + (1+sizeof(ush))*ds->lit_bufsize; + + ds->l_desc.dyn_tree = ds->dyn_ltree; + ds->d_desc.dyn_tree = ds->dyn_dtree; + ds->bl_desc.dyn_tree = ds->bl_tree; + + return Z_OK; +#endif +} + +/* =========================================================================== + * Read a new buffer from the current input stream, update the adler32 + * and total number of bytes read. All deflate() input goes through + * this function so some applications may wish to modify it to avoid + * allocating a large strm->next_in buffer and copying from it. + * (See also flush_pending()). + */ +local int read_buf(strm, buf, size) + z_streamp strm; + Bytef *buf; + unsigned size; +{ + unsigned len = strm->avail_in; + + if (len > size) len = size; + if (len == 0) return 0; + + strm->avail_in -= len; + + if (!strm->state->noheader) { + strm->adler = adler32(strm->adler, strm->next_in, len); + } + zmemcpy(buf, strm->next_in, len); + strm->next_in += len; + strm->total_in += len; + + return (int)len; +} + +/* =========================================================================== + * Initialize the "longest match" routines for a new zlib stream + */ +local void lm_init (s) + deflate_state *s; +{ + s->window_size = (ulg)2L*s->w_size; + + CLEAR_HASH(s); + + /* Set the default configuration parameters: + */ + s->max_lazy_match = configuration_table[s->level].max_lazy; + s->good_match = configuration_table[s->level].good_length; + s->nice_match = configuration_table[s->level].nice_length; + s->max_chain_length = configuration_table[s->level].max_chain; + + s->strstart = 0; + s->block_start = 0L; + s->lookahead = 0; + s->match_length = s->prev_length = MIN_MATCH-1; + s->match_available = 0; + s->ins_h = 0; +#ifdef ASMV + match_init(); /* initialize the asm code */ +#endif +} + +/* =========================================================================== + * Set match_start to the longest match starting at the given string and + * return its length. Matches shorter or equal to prev_length are discarded, + * in which case the result is equal to prev_length and match_start is + * garbage. + * IN assertions: cur_match is the head of the hash chain for the current + * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1 + * OUT assertion: the match length is not greater than s->lookahead. + */ +#ifndef ASMV +/* For 80x86 and 680x0, an optimized version will be provided in match.asm or + * match.S. The code will be functionally equivalent. + */ +#ifndef FASTEST +local uInt longest_match(s, cur_match) + deflate_state *s; + IPos cur_match; /* current match */ +{ + unsigned chain_length = s->max_chain_length;/* max hash chain length */ + register Bytef *scan = s->window + s->strstart; /* current string */ + register Bytef *match; /* matched string */ + register int len; /* length of current match */ + int best_len = s->prev_length; /* best match length so far */ + int nice_match = s->nice_match; /* stop if match long enough */ + IPos limit = s->strstart > (IPos)MAX_DIST(s) ? + s->strstart - (IPos)MAX_DIST(s) : NIL; + /* Stop when cur_match becomes <= limit. To simplify the code, + * we prevent matches with the string of window index 0. + */ + Posf *prev = s->prev; + uInt wmask = s->w_mask; + +#ifdef UNALIGNED_OK + /* Compare two bytes at a time. Note: this is not always beneficial. + * Try with and without -DUNALIGNED_OK to check. + */ + register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1; + register ush scan_start = *(ushf*)scan; + register ush scan_end = *(ushf*)(scan+best_len-1); +#else + register Bytef *strend = s->window + s->strstart + MAX_MATCH; + register Byte scan_end1 = scan[best_len-1]; + register Byte scan_end = scan[best_len]; +#endif + + /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. + * It is easy to get rid of this optimization if necessary. + */ + Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); + + /* Do not waste too much time if we already have a good match: */ + if (s->prev_length >= s->good_match) { + chain_length >>= 2; + } + /* Do not look for matches beyond the end of the input. This is necessary + * to make deflate deterministic. + */ + if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; + + Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); + + do { + Assert(cur_match < s->strstart, "no future"); + match = s->window + cur_match; + + /* Skip to next match if the match length cannot increase + * or if the match length is less than 2: + */ +#if (defined(UNALIGNED_OK) && MAX_MATCH == 258) + /* This code assumes sizeof(unsigned short) == 2. Do not use + * UNALIGNED_OK if your compiler uses a different size. + */ + if (*(ushf*)(match+best_len-1) != scan_end || + *(ushf*)match != scan_start) continue; + + /* It is not necessary to compare scan[2] and match[2] since they are + * always equal when the other bytes match, given that the hash keys + * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at + * strstart+3, +5, ... up to strstart+257. We check for insufficient + * lookahead only every 4th comparison; the 128th check will be made + * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is + * necessary to put more guard bytes at the end of the window, or + * to check more often for insufficient lookahead. + */ + Assert(scan[2] == match[2], "scan[2]?"); + scan++, match++; + do { + } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) && + *(ushf*)(scan+=2) == *(ushf*)(match+=2) && + *(ushf*)(scan+=2) == *(ushf*)(match+=2) && + *(ushf*)(scan+=2) == *(ushf*)(match+=2) && + scan < strend); + /* The funny "do {}" generates better code on most compilers */ + + /* Here, scan <= window+strstart+257 */ + Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); + if (*scan == *match) scan++; + + len = (MAX_MATCH - 1) - (int)(strend-scan); + scan = strend - (MAX_MATCH-1); + +#else /* UNALIGNED_OK */ + + if (match[best_len] != scan_end || + match[best_len-1] != scan_end1 || + *match != *scan || + *++match != scan[1]) continue; + + /* The check at best_len-1 can be removed because it will be made + * again later. (This heuristic is not always a win.) + * It is not necessary to compare scan[2] and match[2] since they + * are always equal when the other bytes match, given that + * the hash keys are equal and that HASH_BITS >= 8. + */ + scan += 2, match++; + Assert(*scan == *match, "match[2]?"); + + /* We check for insufficient lookahead only every 8th comparison; + * the 256th check will be made at strstart+258. + */ + do { + } while (*++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + scan < strend); + + Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); + + len = MAX_MATCH - (int)(strend - scan); + scan = strend - MAX_MATCH; + +#endif /* UNALIGNED_OK */ + + if (len > best_len) { + s->match_start = cur_match; + best_len = len; + if (len >= nice_match) break; +#ifdef UNALIGNED_OK + scan_end = *(ushf*)(scan+best_len-1); +#else + scan_end1 = scan[best_len-1]; + scan_end = scan[best_len]; +#endif + } + } while ((cur_match = prev[cur_match & wmask]) > limit + && --chain_length != 0); + + if ((uInt)best_len <= s->lookahead) return (uInt)best_len; + return s->lookahead; +} + +#else /* FASTEST */ +/* --------------------------------------------------------------------------- + * Optimized version for level == 1 only + */ +local uInt longest_match(s, cur_match) + deflate_state *s; + IPos cur_match; /* current match */ +{ + register Bytef *scan = s->window + s->strstart; /* current string */ + register Bytef *match; /* matched string */ + register int len; /* length of current match */ + register Bytef *strend = s->window + s->strstart + MAX_MATCH; + + /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. + * It is easy to get rid of this optimization if necessary. + */ + Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); + + Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); + + Assert(cur_match < s->strstart, "no future"); + + match = s->window + cur_match; + + /* Return failure if the match length is less than 2: + */ + if (match[0] != scan[0] || match[1] != scan[1]) return MIN_MATCH-1; + + /* The check at best_len-1 can be removed because it will be made + * again later. (This heuristic is not always a win.) + * It is not necessary to compare scan[2] and match[2] since they + * are always equal when the other bytes match, given that + * the hash keys are equal and that HASH_BITS >= 8. + */ + scan += 2, match += 2; + Assert(*scan == *match, "match[2]?"); + + /* We check for insufficient lookahead only every 8th comparison; + * the 256th check will be made at strstart+258. + */ + do { + } while (*++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + scan < strend); + + Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); + + len = MAX_MATCH - (int)(strend - scan); + + if (len < MIN_MATCH) return MIN_MATCH - 1; + + s->match_start = cur_match; + return len <= s->lookahead ? len : s->lookahead; +} +#endif /* FASTEST */ +#endif /* ASMV */ + +#ifdef DEBUG +/* =========================================================================== + * Check that the match at match_start is indeed a match. + */ +local void check_match(s, start, match, length) + deflate_state *s; + IPos start, match; + int length; +{ + /* check that the match is indeed a match */ + if (zmemcmp(s->window + match, + s->window + start, length) != EQUAL) { + fprintf(stderr, " start %u, match %u, length %d\n", + start, match, length); + do { + fprintf(stderr, "%c%c", s->window[match++], s->window[start++]); + } while (--length != 0); + z_error("invalid match"); + } + if (z_verbose > 1) { + fprintf(stderr,"\\[%d,%d]", start-match, length); + do { putc(s->window[start++], stderr); } while (--length != 0); + } +} +#else +# define check_match(s, start, match, length) +#endif + +/* =========================================================================== + * Fill the window when the lookahead becomes insufficient. + * Updates strstart and lookahead. + * + * IN assertion: lookahead < MIN_LOOKAHEAD + * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD + * At least one byte has been read, or avail_in == 0; reads are + * performed for at least two bytes (required for the zip translate_eol + * option -- not supported here). + */ +local void fill_window(s) + deflate_state *s; +{ + register unsigned n, m; + register Posf *p; + unsigned more; /* Amount of free space at the end of the window. */ + uInt wsize = s->w_size; + + do { + more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart); + + /* Deal with !@#$% 64K limit: */ + if (more == 0 && s->strstart == 0 && s->lookahead == 0) { + more = wsize; + + } else if (more == (unsigned)(-1)) { + /* Very unlikely, but possible on 16 bit machine if strstart == 0 + * and lookahead == 1 (input done one byte at time) + */ + more--; + + /* If the window is almost full and there is insufficient lookahead, + * move the upper half to the lower one to make room in the upper half. + */ + } else if (s->strstart >= wsize+MAX_DIST(s)) { + + zmemcpy(s->window, s->window+wsize, (unsigned)wsize); + s->match_start -= wsize; + s->strstart -= wsize; /* we now have strstart >= MAX_DIST */ + s->block_start -= (long) wsize; + + /* Slide the hash table (could be avoided with 32 bit values + at the expense of memory usage). We slide even when level == 0 + to keep the hash table consistent if we switch back to level > 0 + later. (Using level 0 permanently is not an optimal usage of + zlib, so we don't care about this pathological case.) + */ + n = s->hash_size; + p = &s->head[n]; + do { + m = *--p; + *p = (Pos)(m >= wsize ? m-wsize : NIL); + } while (--n); + + n = wsize; +#ifndef FASTEST + p = &s->prev[n]; + do { + m = *--p; + *p = (Pos)(m >= wsize ? m-wsize : NIL); + /* If n is not on any hash chain, prev[n] is garbage but + * its value will never be used. + */ + } while (--n); +#endif + more += wsize; + } + if (s->strm->avail_in == 0) return; + + /* If there was no sliding: + * strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 && + * more == window_size - lookahead - strstart + * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1) + * => more >= window_size - 2*WSIZE + 2 + * In the BIG_MEM or MMAP case (not yet supported), + * window_size == input_size + MIN_LOOKAHEAD && + * strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD. + * Otherwise, window_size == 2*WSIZE so more >= 2. + * If there was sliding, more >= WSIZE. So in all cases, more >= 2. + */ + Assert(more >= 2, "more < 2"); + + n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more); + s->lookahead += n; + + /* Initialize the hash value now that we have some input: */ + if (s->lookahead >= MIN_MATCH) { + s->ins_h = s->window[s->strstart]; + UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]); +#if MIN_MATCH != 3 + Call UPDATE_HASH() MIN_MATCH-3 more times +#endif + } + /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage, + * but this is not important since only literal bytes will be emitted. + */ + + } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0); +} + +/* =========================================================================== + * Flush the current block, with given end-of-file flag. + * IN assertion: strstart is set to the end of the current match. + */ +#define FLUSH_BLOCK_ONLY(s, eof) { \ + _tr_flush_block(s, (s->block_start >= 0L ? \ + (charf *)&s->window[(unsigned)s->block_start] : \ + (charf *)Z_NULL), \ + (ulg)((long)s->strstart - s->block_start), \ + (eof)); \ + s->block_start = s->strstart; \ + flush_pending(s->strm); \ + Tracev((stderr,"[FLUSH]")); \ +} + +/* Same but force premature exit if necessary. */ +#define FLUSH_BLOCK(s, eof) { \ + FLUSH_BLOCK_ONLY(s, eof); \ + if (s->strm->avail_out == 0) return (eof) ? finish_started : need_more; \ +} + +/* =========================================================================== + * Copy without compression as much as possible from the input stream, return + * the current block state. + * This function does not insert new strings in the dictionary since + * uncompressible data is probably not useful. This function is used + * only for the level=0 compression option. + * NOTE: this function should be optimized to avoid extra copying from + * window to pending_buf. + */ +local block_state deflate_stored(s, flush) + deflate_state *s; + int flush; +{ + /* Stored blocks are limited to 0xffff bytes, pending_buf is limited + * to pending_buf_size, and each stored block has a 5 byte header: + */ + ulg max_block_size = 0xffff; + ulg max_start; + + if (max_block_size > s->pending_buf_size - 5) { + max_block_size = s->pending_buf_size - 5; + } + + /* Copy as much as possible from input to output: */ + for (;;) { + /* Fill the window as much as possible: */ + if (s->lookahead <= 1) { + + Assert(s->strstart < s->w_size+MAX_DIST(s) || + s->block_start >= (long)s->w_size, "slide too late"); + + fill_window(s); + if (s->lookahead == 0 && flush == Z_NO_FLUSH) return need_more; + + if (s->lookahead == 0) break; /* flush the current block */ + } + Assert(s->block_start >= 0L, "block gone"); + + s->strstart += s->lookahead; + s->lookahead = 0; + + /* Emit a stored block if pending_buf will be full: */ + max_start = s->block_start + max_block_size; + if (s->strstart == 0 || (ulg)s->strstart >= max_start) { + /* strstart == 0 is possible when wraparound on 16-bit machine */ + s->lookahead = (uInt)(s->strstart - max_start); + s->strstart = (uInt)max_start; + FLUSH_BLOCK(s, 0); + } + /* Flush if we may have to slide, otherwise block_start may become + * negative and the data will be gone: + */ + if (s->strstart - (uInt)s->block_start >= MAX_DIST(s)) { + FLUSH_BLOCK(s, 0); + } + } + FLUSH_BLOCK(s, flush == Z_FINISH); + return flush == Z_FINISH ? finish_done : block_done; +} + +/* =========================================================================== + * Compress as much as possible from the input stream, return the current + * block state. + * This function does not perform lazy evaluation of matches and inserts + * new strings in the dictionary only for unmatched strings or for short + * matches. It is used only for the fast compression options. + */ +local block_state deflate_fast(s, flush) + deflate_state *s; + int flush; +{ + IPos hash_head = NIL; /* head of the hash chain */ + int bflush; /* set if current block must be flushed */ + + for (;;) { + /* Make sure that we always have enough lookahead, except + * at the end of the input file. We need MAX_MATCH bytes + * for the next match, plus MIN_MATCH bytes to insert the + * string following the next match. + */ + if (s->lookahead < MIN_LOOKAHEAD) { + fill_window(s); + if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { + return need_more; + } + if (s->lookahead == 0) break; /* flush the current block */ + } + + /* Insert the string window[strstart .. strstart+2] in the + * dictionary, and set hash_head to the head of the hash chain: + */ + if (s->lookahead >= MIN_MATCH) { + INSERT_STRING(s, s->strstart, hash_head); + } + + /* Find the longest match, discarding those <= prev_length. + * At this point we have always match_length < MIN_MATCH + */ + if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) { + /* To simplify the code, we prevent matches with the string + * of window index 0 (in particular we have to avoid a match + * of the string with itself at the start of the input file). + */ + if (s->strategy != Z_HUFFMAN_ONLY) { + s->match_length = longest_match (s, hash_head); + } + /* longest_match() sets match_start */ + } + if (s->match_length >= MIN_MATCH) { + check_match(s, s->strstart, s->match_start, s->match_length); + + _tr_tally_dist(s, s->strstart - s->match_start, + s->match_length - MIN_MATCH, bflush); + + s->lookahead -= s->match_length; + + /* Insert new strings in the hash table only if the match length + * is not too large. This saves time but degrades compression. + */ +#ifndef FASTEST + if (s->match_length <= s->max_insert_length && + s->lookahead >= MIN_MATCH) { + s->match_length--; /* string at strstart already in hash table */ + do { + s->strstart++; + INSERT_STRING(s, s->strstart, hash_head); + /* strstart never exceeds WSIZE-MAX_MATCH, so there are + * always MIN_MATCH bytes ahead. + */ + } while (--s->match_length != 0); + s->strstart++; + } else +#endif + { + s->strstart += s->match_length; + s->match_length = 0; + s->ins_h = s->window[s->strstart]; + UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]); +#if MIN_MATCH != 3 + Call UPDATE_HASH() MIN_MATCH-3 more times +#endif + /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not + * matter since it will be recomputed at next deflate call. + */ + } + } else { + /* No match, output a literal byte */ + Tracevv((stderr,"%c", s->window[s->strstart])); + _tr_tally_lit (s, s->window[s->strstart], bflush); + s->lookahead--; + s->strstart++; + } + if (bflush) FLUSH_BLOCK(s, 0); + } + FLUSH_BLOCK(s, flush == Z_FINISH); + return flush == Z_FINISH ? finish_done : block_done; +} + +/* =========================================================================== + * Same as above, but achieves better compression. We use a lazy + * evaluation for matches: a match is finally adopted only if there is + * no better match at the next window position. + */ +local block_state deflate_slow(s, flush) + deflate_state *s; + int flush; +{ + IPos hash_head = NIL; /* head of hash chain */ + int bflush; /* set if current block must be flushed */ + + /* Process the input block. */ + for (;;) { + /* Make sure that we always have enough lookahead, except + * at the end of the input file. We need MAX_MATCH bytes + * for the next match, plus MIN_MATCH bytes to insert the + * string following the next match. + */ + if (s->lookahead < MIN_LOOKAHEAD) { + fill_window(s); + if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { + return need_more; + } + if (s->lookahead == 0) break; /* flush the current block */ + } + + /* Insert the string window[strstart .. strstart+2] in the + * dictionary, and set hash_head to the head of the hash chain: + */ + if (s->lookahead >= MIN_MATCH) { + INSERT_STRING(s, s->strstart, hash_head); + } + + /* Find the longest match, discarding those <= prev_length. + */ + s->prev_length = s->match_length, s->prev_match = s->match_start; + s->match_length = MIN_MATCH-1; + + if (hash_head != NIL && s->prev_length < s->max_lazy_match && + s->strstart - hash_head <= MAX_DIST(s)) { + /* To simplify the code, we prevent matches with the string + * of window index 0 (in particular we have to avoid a match + * of the string with itself at the start of the input file). + */ + if (s->strategy != Z_HUFFMAN_ONLY) { + s->match_length = longest_match (s, hash_head); + } + /* longest_match() sets match_start */ + + if (s->match_length <= 5 && (s->strategy == Z_FILTERED || + (s->match_length == MIN_MATCH && + s->strstart - s->match_start > TOO_FAR))) { + + /* If prev_match is also MIN_MATCH, match_start is garbage + * but we will ignore the current match anyway. + */ + s->match_length = MIN_MATCH-1; + } + } + /* If there was a match at the previous step and the current + * match is not better, output the previous match: + */ + if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) { + uInt max_insert = s->strstart + s->lookahead - MIN_MATCH; + /* Do not insert strings in hash table beyond this. */ + + check_match(s, s->strstart-1, s->prev_match, s->prev_length); + + _tr_tally_dist(s, s->strstart -1 - s->prev_match, + s->prev_length - MIN_MATCH, bflush); + + /* Insert in hash table all strings up to the end of the match. + * strstart-1 and strstart are already inserted. If there is not + * enough lookahead, the last two strings are not inserted in + * the hash table. + */ + s->lookahead -= s->prev_length-1; + s->prev_length -= 2; + do { + if (++s->strstart <= max_insert) { + INSERT_STRING(s, s->strstart, hash_head); + } + } while (--s->prev_length != 0); + s->match_available = 0; + s->match_length = MIN_MATCH-1; + s->strstart++; + + if (bflush) FLUSH_BLOCK(s, 0); + + } else if (s->match_available) { + /* If there was no match at the previous position, output a + * single literal. If there was a match but the current match + * is longer, truncate the previous match to a single literal. + */ + Tracevv((stderr,"%c", s->window[s->strstart-1])); + _tr_tally_lit(s, s->window[s->strstart-1], bflush); + if (bflush) { + FLUSH_BLOCK_ONLY(s, 0); + } + s->strstart++; + s->lookahead--; + if (s->strm->avail_out == 0) return need_more; + } else { + /* There is no previous match to compare with, wait for + * the next step to decide. + */ + s->match_available = 1; + s->strstart++; + s->lookahead--; + } + } + Assert (flush != Z_NO_FLUSH, "no flush?"); + if (s->match_available) { + Tracevv((stderr,"%c", s->window[s->strstart-1])); + _tr_tally_lit(s, s->window[s->strstart-1], bflush); + s->match_available = 0; + } + FLUSH_BLOCK(s, flush == Z_FINISH); + return flush == Z_FINISH ? finish_done : block_done; +} diff --git a/stepmania/src/smpackage/ZipArchive/zlib/deflate.h b/stepmania/src/smpackage/ZipArchive/zlib/deflate.h new file mode 100644 index 0000000000..d49f991292 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/zlib/deflate.h @@ -0,0 +1,317 @@ +/* deflate.h -- internal compression state + * Copyright (C) 1995-1998 Jean-loup Gailly + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* WARNING: this file should *not* be used by applications. It is + part of the implementation of the compression library and is + subject to change. Applications should only use zlib.h. + */ + + +#ifndef _DEFLATE_H +#define _DEFLATE_H + +#include "zutil.h" + +/* =========================================================================== + * Internal compression state. + */ + +#define LENGTH_CODES 29 +/* number of length codes, not counting the special END_BLOCK code */ + +#define LITERALS 256 +/* number of literal bytes 0..255 */ + +#define L_CODES (LITERALS+1+LENGTH_CODES) +/* number of Literal or Length codes, including the END_BLOCK code */ + +#define D_CODES 30 +/* number of distance codes */ + +#define BL_CODES 19 +/* number of codes used to transfer the bit lengths */ + +#define HEAP_SIZE (2*L_CODES+1) +/* maximum heap size */ + +#define MAX_BITS 15 +/* All codes must not exceed MAX_BITS bits */ + +#define INIT_STATE 42 +#define BUSY_STATE 113 +#define FINISH_STATE 666 +/* Stream status */ + + +/* Data structure describing a single value and its code string. */ +typedef struct ct_data_s { + union { + ush freq; /* frequency count */ + ush code; /* bit string */ + } fc; + union { + ush dad; /* father node in Huffman tree */ + ush len; /* length of bit string */ + } dl; +} FAR ct_data; + +#define Freq fc.freq +#define Code fc.code +#define Dad dl.dad +#define Len dl.len + +typedef struct static_tree_desc_s static_tree_desc; + +typedef struct tree_desc_s { + ct_data *dyn_tree; /* the dynamic tree */ + int max_code; /* largest code with non zero frequency */ + static_tree_desc *stat_desc; /* the corresponding static tree */ +} FAR tree_desc; + +typedef ush Pos; +typedef Pos FAR Posf; +typedef unsigned IPos; + +/* A Pos is an index in the character window. We use short instead of int to + * save space in the various tables. IPos is used only for parameter passing. + */ + +typedef struct internal_state { + z_streamp strm; /* pointer back to this zlib stream */ + int status; /* as the name implies */ + Bytef *pending_buf; /* output still pending */ + ulg pending_buf_size; /* size of pending_buf */ + Bytef *pending_out; /* next pending byte to output to the stream */ + int pending; /* nb of bytes in the pending buffer */ + int noheader; /* suppress zlib header and adler32 */ + Byte data_type; /* UNKNOWN, BINARY or ASCII */ + Byte method; /* STORED (for zip only) or DEFLATED */ + int last_flush; /* value of flush param for previous deflate call */ + + /* used by deflate.c: */ + + uInt w_size; /* LZ77 window size (32K by default) */ + uInt w_bits; /* log2(w_size) (8..16) */ + uInt w_mask; /* w_size - 1 */ + + Bytef *window; + /* Sliding window. Input bytes are read into the second half of the window, + * and move to the first half later to keep a dictionary of at least wSize + * bytes. With this organization, matches are limited to a distance of + * wSize-MAX_MATCH bytes, but this ensures that IO is always + * performed with a length multiple of the block size. Also, it limits + * the window size to 64K, which is quite useful on MSDOS. + * To do: use the user input buffer as sliding window. + */ + + ulg window_size; + /* Actual size of window: 2*wSize, except when the user input buffer + * is directly used as sliding window. + */ + + Posf *prev; + /* Link to older string with same hash index. To limit the size of this + * array to 64K, this link is maintained only for the last 32K strings. + * An index in this array is thus a window index modulo 32K. + */ + + Posf *head; /* Heads of the hash chains or NIL. */ + + uInt ins_h; /* hash index of string to be inserted */ + uInt hash_size; /* number of elements in hash table */ + uInt hash_bits; /* log2(hash_size) */ + uInt hash_mask; /* hash_size-1 */ + + uInt hash_shift; + /* Number of bits by which ins_h must be shifted at each input + * step. It must be such that after MIN_MATCH steps, the oldest + * byte no longer takes part in the hash key, that is: + * hash_shift * MIN_MATCH >= hash_bits + */ + + long block_start; + /* Window position at the beginning of the current output block. Gets + * negative when the window is moved backwards. + */ + + uInt match_length; /* length of best match */ + IPos prev_match; /* previous match */ + int match_available; /* set if previous match exists */ + uInt strstart; /* start of string to insert */ + uInt match_start; /* start of matching string */ + uInt lookahead; /* number of valid bytes ahead in window */ + + uInt prev_length; + /* Length of the best match at previous step. Matches not greater than this + * are discarded. This is used in the lazy match evaluation. + */ + + uInt max_chain_length; + /* To speed up deflation, hash chains are never searched beyond this + * length. A higher limit improves compression ratio but degrades the + * speed. + */ + + uInt max_lazy_match; + /* Attempt to find a better match only when the current match is strictly + * smaller than this value. This mechanism is used only for compression + * levels >= 4. + */ +# define max_insert_length max_lazy_match + /* Insert new strings in the hash table only if the match length is not + * greater than this length. This saves time but degrades compression. + * max_insert_length is used only for compression levels <= 3. + */ + + int level; /* compression level (1..9) */ + int strategy; /* favor or force Huffman coding*/ + + uInt good_match; + /* Use a faster search when the previous match is longer than this */ + + int nice_match; /* Stop searching when current match exceeds this */ + + /* used by trees.c: */ + /* Didn't use ct_data typedef below to supress compiler warning */ + struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */ + struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */ + struct ct_data_s bl_tree[2*BL_CODES+1]; /* Huffman tree for bit lengths */ + + struct tree_desc_s l_desc; /* desc. for literal tree */ + struct tree_desc_s d_desc; /* desc. for distance tree */ + struct tree_desc_s bl_desc; /* desc. for bit length tree */ + + ush bl_count[MAX_BITS+1]; + /* number of codes at each bit length for an optimal tree */ + + int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */ + int heap_len; /* number of elements in the heap */ + int heap_max; /* element of largest frequency */ + /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used. + * The same heap array is used to build all trees. + */ + + uch depth[2*L_CODES+1]; + /* Depth of each subtree used as tie breaker for trees of equal frequency + */ + + uchf *l_buf; /* buffer for literals or lengths */ + + uInt lit_bufsize; + /* Size of match buffer for literals/lengths. There are 4 reasons for + * limiting lit_bufsize to 64K: + * - frequencies can be kept in 16 bit counters + * - if compression is not successful for the first block, all input + * data is still in the window so we can still emit a stored block even + * when input comes from standard input. (This can also be done for + * all blocks if lit_bufsize is not greater than 32K.) + * - if compression is not successful for a file smaller than 64K, we can + * even emit a stored file instead of a stored block (saving 5 bytes). + * This is applicable only for zip (not gzip or zlib). + * - creating new Huffman trees less frequently may not provide fast + * adaptation to changes in the input data statistics. (Take for + * example a binary file with poorly compressible code followed by + * a highly compressible string table.) Smaller buffer sizes give + * fast adaptation but have of course the overhead of transmitting + * trees more frequently. + * - I can't count above 4 + */ + + uInt last_lit; /* running index in l_buf */ + + ushf *d_buf; + /* Buffer for distances. To simplify the code, d_buf and l_buf have + * the same number of elements. To use different lengths, an extra flag + * array would be necessary. + */ + + ulg opt_len; /* bit length of current block with optimal trees */ + ulg static_len; /* bit length of current block with static trees */ + uInt matches; /* number of string matches in current block */ + int last_eob_len; /* bit length of EOB code for last block */ + +#ifdef DEBUG + ulg compressed_len; /* total bit length of compressed file mod 2^32 */ + ulg bits_sent; /* bit length of compressed data sent mod 2^32 */ +#endif + + ush bi_buf; + /* Output buffer. bits are inserted starting at the bottom (least + * significant bits). + */ + int bi_valid; + /* Number of valid bits in bi_buf. All bits above the last valid bit + * are always zero. + */ + +} FAR deflate_state; + +/* Output a byte on the stream. + * IN assertion: there is enough room in pending_buf. + */ +#define put_byte(s, c) {s->pending_buf[s->pending++] = (c);} + + +#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1) +/* Minimum amount of lookahead, except at the end of the input file. + * See deflate.c for comments about the MIN_MATCH+1. + */ + +#define MAX_DIST(s) ((s)->w_size-MIN_LOOKAHEAD) +/* In order to simplify the code, particularly on 16 bit machines, match + * distances are limited to MAX_DIST instead of WSIZE. + */ + + /* in trees.c */ +void _tr_init OF((deflate_state *s)); +int _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc)); +void _tr_flush_block OF((deflate_state *s, charf *buf, ulg stored_len, + int eof)); +void _tr_align OF((deflate_state *s)); +void _tr_stored_block OF((deflate_state *s, charf *buf, ulg stored_len, + int eof)); + +#define d_code(dist) \ + ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)]) +/* Mapping from a distance to a distance code. dist is the distance - 1 and + * must not have side effects. _dist_code[256] and _dist_code[257] are never + * used. + */ + +#ifndef DEBUG +/* Inline versions of _tr_tally for speed: */ + +#if defined(GEN_TREES_H) || !defined(STDC) + extern uch _length_code[]; + extern uch _dist_code[]; +#else + extern const uch _length_code[]; + extern const uch _dist_code[]; +#endif + +# define _tr_tally_lit(s, c, flush) \ + { uch cc = (c); \ + s->d_buf[s->last_lit] = 0; \ + s->l_buf[s->last_lit++] = cc; \ + s->dyn_ltree[cc].Freq++; \ + flush = (s->last_lit == s->lit_bufsize-1); \ + } +# define _tr_tally_dist(s, distance, length, flush) \ + { uch len = (length); \ + ush dist = (distance); \ + s->d_buf[s->last_lit] = dist; \ + s->l_buf[s->last_lit++] = len; \ + dist--; \ + s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \ + s->dyn_dtree[d_code(dist)].Freq++; \ + flush = (s->last_lit == s->lit_bufsize-1); \ + } +#else +# define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c) +# define _tr_tally_dist(s, distance, length, flush) \ + flush = _tr_tally(s, distance, length) +#endif + +#endif diff --git a/stepmania/src/smpackage/ZipArchive/zlib/gvmat32c.c b/stepmania/src/smpackage/ZipArchive/zlib/gvmat32c.c new file mode 100644 index 0000000000..06d107b70c --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/zlib/gvmat32c.c @@ -0,0 +1,209 @@ +/* gvmat32.c -- C portion of the optimized longest_match for 32 bits x86 + * Copyright (C) 1995-1996 Jean-loup Gailly and Gilles Vollant. + * File written by Gilles Vollant, by modifiying the longest_match + * from Jean-loup Gailly in deflate.c + * it prepare all parameters and call the assembly longest_match_gvasm + * longest_match execute standard C code is wmask != 0x7fff + * (assembly code is faster with a fixed wmask) + * + */ + +#include "deflate.h" + +#undef FAR +//#include + +#ifdef ASMV +#define NIL 0 + +#define UNALIGNED_OK + + +/* if your C compiler don't add underline before function name, + define ADD_UNDERLINE_ASMFUNC */ +#ifdef ADD_UNDERLINE_ASMFUNC +#define longest_match_7fff _longest_match_7fff +#define longest_match_686 _longest_match_686 +#define cpudetect32 _cpudetect32 +#endif + + + +void match_init() +{ +} + +unsigned long cpudetect32(); + +uInt longest_match_c( + deflate_state *s, + IPos cur_match); /* current match */ + + +uInt longest_match_7fff( + deflate_state *s, + IPos cur_match); /* current match */ + +uInt longest_match_686( + deflate_state *s, + IPos cur_match); /* current match */ + +uInt longest_match( + deflate_state *s, + IPos cur_match) /* current match */ +{ + static uInt iIsPPro=2; + + if ((s->w_mask == 0x7fff) && (iIsPPro==0)) + return longest_match_7fff(s,cur_match); + + if (iIsPPro==1) + return longest_match_686(s,cur_match); + + if (iIsPPro==2) + iIsPPro = (((cpudetect32()/0x100)&0xf)>=6) ? 1 : 0; + + return longest_match_c(s,cur_match); +} + + + +uInt longest_match_c(s, cur_match) + deflate_state *s; + IPos cur_match; /* current match */ +{ + unsigned chain_length = s->max_chain_length;/* max hash chain length */ + register Bytef *scan = s->window + s->strstart; /* current string */ + register Bytef *match; /* matched string */ + register int len; /* length of current match */ + int best_len = s->prev_length; /* best match length so far */ + int nice_match = s->nice_match; /* stop if match long enough */ + IPos limit = s->strstart > (IPos)MAX_DIST(s) ? + s->strstart - (IPos)MAX_DIST(s) : NIL; + /* Stop when cur_match becomes <= limit. To simplify the code, + * we prevent matches with the string of window index 0. + */ + Posf *prev = s->prev; + uInt wmask = s->w_mask; + +#ifdef UNALIGNED_OK + /* Compare two bytes at a time. Note: this is not always beneficial. + * Try with and without -DUNALIGNED_OK to check. + */ + register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1; + register ush scan_start = *(ushf*)scan; + register ush scan_end = *(ushf*)(scan+best_len-1); +#else + register Bytef *strend = s->window + s->strstart + MAX_MATCH; + register Byte scan_end1 = scan[best_len-1]; + register Byte scan_end = scan[best_len]; +#endif + + /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. + * It is easy to get rid of this optimization if necessary. + */ + Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); + + /* Do not waste too much time if we already have a good match: */ + if (s->prev_length >= s->good_match) { + chain_length >>= 2; + } + /* Do not look for matches beyond the end of the input. This is necessary + * to make deflate deterministic. + */ + if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; + + Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); + + do { + Assert(cur_match < s->strstart, "no future"); + match = s->window + cur_match; + + /* Skip to next match if the match length cannot increase + * or if the match length is less than 2: + */ +#if (defined(UNALIGNED_OK) && MAX_MATCH == 258) + /* This code assumes sizeof(unsigned short) == 2. Do not use + * UNALIGNED_OK if your compiler uses a different size. + */ + if (*(ushf*)(match+best_len-1) != scan_end || + *(ushf*)match != scan_start) continue; + + /* It is not necessary to compare scan[2] and match[2] since they are + * always equal when the other bytes match, given that the hash keys + * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at + * strstart+3, +5, ... up to strstart+257. We check for insufficient + * lookahead only every 4th comparison; the 128th check will be made + * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is + * necessary to put more guard bytes at the end of the window, or + * to check more often for insufficient lookahead. + */ + Assert(scan[2] == match[2], "scan[2]?"); + scan++, match++; + do { + } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) && + *(ushf*)(scan+=2) == *(ushf*)(match+=2) && + *(ushf*)(scan+=2) == *(ushf*)(match+=2) && + *(ushf*)(scan+=2) == *(ushf*)(match+=2) && + scan < strend); + /* The funny "do {}" generates better code on most compilers */ + + /* Here, scan <= window+strstart+257 */ + Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); + if (*scan == *match) scan++; + + len = (MAX_MATCH - 1) - (int)(strend-scan); + scan = strend - (MAX_MATCH-1); + +#else /* UNALIGNED_OK */ + + if (match[best_len] != scan_end || + match[best_len-1] != scan_end1 || + *match != *scan || + *++match != scan[1]) continue; + + /* The check at best_len-1 can be removed because it will be made + * again later. (This heuristic is not always a win.) + * It is not necessary to compare scan[2] and match[2] since they + * are always equal when the other bytes match, given that + * the hash keys are equal and that HASH_BITS >= 8. + */ + scan += 2, match++; + Assert(*scan == *match, "match[2]?"); + + /* We check for insufficient lookahead only every 8th comparison; + * the 256th check will be made at strstart+258. + */ + do { + } while (*++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + scan < strend); + + Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); + + len = MAX_MATCH - (int)(strend - scan); + scan = strend - MAX_MATCH; + +#endif /* UNALIGNED_OK */ + + if (len > best_len) { + s->match_start = cur_match; + best_len = len; + if (len >= nice_match) break; +#ifdef UNALIGNED_OK + scan_end = *(ushf*)(scan+best_len-1); +#else + scan_end1 = scan[best_len-1]; + scan_end = scan[best_len]; +#endif + } + } while ((cur_match = prev[cur_match & wmask]) > limit + && --chain_length != 0); + + if ((uInt)best_len <= s->lookahead) return (uInt)best_len; + return s->lookahead; +} + +#endif /* ASMV */ diff --git a/stepmania/src/smpackage/ZipArchive/zlib/infblock.c b/stepmania/src/smpackage/ZipArchive/zlib/infblock.c new file mode 100644 index 0000000000..f4920faa5e --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/zlib/infblock.c @@ -0,0 +1,398 @@ +/* infblock.c -- interpret and process block types to last block + * Copyright (C) 1995-1998 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#include "zutil.h" +#include "infblock.h" +#include "inftrees.h" +#include "infcodes.h" +#include "infutil.h" + +struct inflate_codes_state {int dummy;}; /* for buggy compilers */ + +/* simplify the use of the inflate_huft type with some defines */ +#define exop word.what.Exop +#define bits word.what.Bits + +/* Table for deflate from PKZIP's appnote.txt. */ +local const uInt border[] = { /* Order of the bit length code lengths */ + 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; + +/* + Notes beyond the 1.93a appnote.txt: + + 1. Distance pointers never point before the beginning of the output + stream. + 2. Distance pointers can point back across blocks, up to 32k away. + 3. There is an implied maximum of 7 bits for the bit length table and + 15 bits for the actual data. + 4. If only one code exists, then it is encoded using one bit. (Zero + would be more efficient, but perhaps a little confusing.) If two + codes exist, they are coded using one bit each (0 and 1). + 5. There is no way of sending zero distance codes--a dummy must be + sent if there are none. (History: a pre 2.0 version of PKZIP would + store blocks with no distance codes, but this was discovered to be + too harsh a criterion.) Valid only for 1.93a. 2.04c does allow + zero distance codes, which is sent as one code of zero bits in + length. + 6. There are up to 286 literal/length codes. Code 256 represents the + end-of-block. Note however that the static length tree defines + 288 codes just to fill out the Huffman codes. Codes 286 and 287 + cannot be used though, since there is no length base or extra bits + defined for them. Similarily, there are up to 30 distance codes. + However, static trees define 32 codes (all 5 bits) to fill out the + Huffman codes, but the last two had better not show up in the data. + 7. Unzip can check dynamic Huffman blocks for complete code sets. + The exception is that a single code would not be complete (see #4). + 8. The five bits following the block type is really the number of + literal codes sent minus 257. + 9. Length codes 8,16,16 are interpreted as 13 length codes of 8 bits + (1+6+6). Therefore, to output three times the length, you output + three codes (1+1+1), whereas to output four times the same length, + you only need two codes (1+3). Hmm. + 10. In the tree reconstruction algorithm, Code = Code + Increment + only if BitLength(i) is not zero. (Pretty obvious.) + 11. Correction: 4 Bits: # of Bit Length codes - 4 (4 - 19) + 12. Note: length code 284 can represent 227-258, but length code 285 + really is 258. The last length deserves its own, short code + since it gets used a lot in very redundant files. The length + 258 is special since 258 - 3 (the min match length) is 255. + 13. The literal/length and distance code bit lengths are read as a + single stream of lengths. It is possible (and advantageous) for + a repeat code (16, 17, or 18) to go across the boundary between + the two sets of lengths. + */ + + +void inflate_blocks_reset(s, z, c) +inflate_blocks_statef *s; +z_streamp z; +uLongf *c; +{ + if (c != Z_NULL) + *c = s->check; + if (s->mode == BTREE || s->mode == DTREE) + ZFREE(z, s->sub.trees.blens); + if (s->mode == CODES) + inflate_codes_free(s->sub.decode.codes, z); + s->mode = TYPE; + s->bitk = 0; + s->bitb = 0; + s->read = s->write = s->window; + if (s->checkfn != Z_NULL) + z->adler = s->check = (*s->checkfn)(0L, (const Bytef *)Z_NULL, 0); + Tracev((stderr, "inflate: blocks reset\n")); +} + + +inflate_blocks_statef *inflate_blocks_new(z, c, w) +z_streamp z; +check_func c; +uInt w; +{ + inflate_blocks_statef *s; + + if ((s = (inflate_blocks_statef *)ZALLOC + (z,1,sizeof(struct inflate_blocks_state))) == Z_NULL) + return s; + if ((s->hufts = + (inflate_huft *)ZALLOC(z, sizeof(inflate_huft), MANY)) == Z_NULL) + { + ZFREE(z, s); + return Z_NULL; + } + if ((s->window = (Bytef *)ZALLOC(z, 1, w)) == Z_NULL) + { + ZFREE(z, s->hufts); + ZFREE(z, s); + return Z_NULL; + } + s->end = s->window + w; + s->checkfn = c; + s->mode = TYPE; + Tracev((stderr, "inflate: blocks allocated\n")); + inflate_blocks_reset(s, z, Z_NULL); + return s; +} + + +int inflate_blocks(s, z, r) +inflate_blocks_statef *s; +z_streamp z; +int r; +{ + uInt t; /* temporary storage */ + uLong b; /* bit buffer */ + uInt k; /* bits in bit buffer */ + Bytef *p; /* input data pointer */ + uInt n; /* bytes available there */ + Bytef *q; /* output window write pointer */ + uInt m; /* bytes to end of window or read pointer */ + + /* copy input/output information to locals (UPDATE macro restores) */ + LOAD + + /* process input based on current state */ + while (1) switch (s->mode) + { + case TYPE: + NEEDBITS(3) + t = (uInt)b & 7; + s->last = t & 1; + switch (t >> 1) + { + case 0: /* stored */ + Tracev((stderr, "inflate: stored block%s\n", + s->last ? " (last)" : "")); + DUMPBITS(3) + t = k & 7; /* go to byte boundary */ + DUMPBITS(t) + s->mode = LENS; /* get length of stored block */ + break; + case 1: /* fixed */ + Tracev((stderr, "inflate: fixed codes block%s\n", + s->last ? " (last)" : "")); + { + uInt bl, bd; + inflate_huft *tl, *td; + + inflate_trees_fixed(&bl, &bd, &tl, &td, z); + s->sub.decode.codes = inflate_codes_new(bl, bd, tl, td, z); + if (s->sub.decode.codes == Z_NULL) + { + r = Z_MEM_ERROR; + LEAVE + } + } + DUMPBITS(3) + s->mode = CODES; + break; + case 2: /* dynamic */ + Tracev((stderr, "inflate: dynamic codes block%s\n", + s->last ? " (last)" : "")); + DUMPBITS(3) + s->mode = TABLE; + break; + case 3: /* illegal */ + DUMPBITS(3) + s->mode = BAD; + z->msg = (char*)"invalid block type"; + r = Z_DATA_ERROR; + LEAVE + } + break; + case LENS: + NEEDBITS(32) + if ((((~b) >> 16) & 0xffff) != (b & 0xffff)) + { + s->mode = BAD; + z->msg = (char*)"invalid stored block lengths"; + r = Z_DATA_ERROR; + LEAVE + } + s->sub.left = (uInt)b & 0xffff; + b = k = 0; /* dump bits */ + Tracev((stderr, "inflate: stored length %u\n", s->sub.left)); + s->mode = s->sub.left ? STORED : (s->last ? DRY : TYPE); + break; + case STORED: + if (n == 0) + LEAVE + NEEDOUT + t = s->sub.left; + if (t > n) t = n; + if (t > m) t = m; + zmemcpy(q, p, t); + p += t; n -= t; + q += t; m -= t; + if ((s->sub.left -= t) != 0) + break; + Tracev((stderr, "inflate: stored end, %lu total out\n", + z->total_out + (q >= s->read ? q - s->read : + (s->end - s->read) + (q - s->window)))); + s->mode = s->last ? DRY : TYPE; + break; + case TABLE: + NEEDBITS(14) + s->sub.trees.table = t = (uInt)b & 0x3fff; +#ifndef PKZIP_BUG_WORKAROUND + if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29) + { + s->mode = BAD; + z->msg = (char*)"too many length or distance symbols"; + r = Z_DATA_ERROR; + LEAVE + } +#endif + t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f); + if ((s->sub.trees.blens = (uIntf*)ZALLOC(z, t, sizeof(uInt))) == Z_NULL) + { + r = Z_MEM_ERROR; + LEAVE + } + DUMPBITS(14) + s->sub.trees.index = 0; + Tracev((stderr, "inflate: table sizes ok\n")); + s->mode = BTREE; + case BTREE: + while (s->sub.trees.index < 4 + (s->sub.trees.table >> 10)) + { + NEEDBITS(3) + s->sub.trees.blens[border[s->sub.trees.index++]] = (uInt)b & 7; + DUMPBITS(3) + } + while (s->sub.trees.index < 19) + s->sub.trees.blens[border[s->sub.trees.index++]] = 0; + s->sub.trees.bb = 7; + t = inflate_trees_bits(s->sub.trees.blens, &s->sub.trees.bb, + &s->sub.trees.tb, s->hufts, z); + if (t != Z_OK) + { + ZFREE(z, s->sub.trees.blens); + r = t; + if (r == Z_DATA_ERROR) + s->mode = BAD; + LEAVE + } + s->sub.trees.index = 0; + Tracev((stderr, "inflate: bits tree ok\n")); + s->mode = DTREE; + case DTREE: + while (t = s->sub.trees.table, + s->sub.trees.index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f)) + { + inflate_huft *h; + uInt i, j, c; + + t = s->sub.trees.bb; + NEEDBITS(t) + h = s->sub.trees.tb + ((uInt)b & inflate_mask[t]); + t = h->bits; + c = h->base; + if (c < 16) + { + DUMPBITS(t) + s->sub.trees.blens[s->sub.trees.index++] = c; + } + else /* c == 16..18 */ + { + i = c == 18 ? 7 : c - 14; + j = c == 18 ? 11 : 3; + NEEDBITS(t + i) + DUMPBITS(t) + j += (uInt)b & inflate_mask[i]; + DUMPBITS(i) + i = s->sub.trees.index; + t = s->sub.trees.table; + if (i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) || + (c == 16 && i < 1)) + { + ZFREE(z, s->sub.trees.blens); + s->mode = BAD; + z->msg = (char*)"invalid bit length repeat"; + r = Z_DATA_ERROR; + LEAVE + } + c = c == 16 ? s->sub.trees.blens[i - 1] : 0; + do { + s->sub.trees.blens[i++] = c; + } while (--j); + s->sub.trees.index = i; + } + } + s->sub.trees.tb = Z_NULL; + { + uInt bl, bd; + inflate_huft *tl, *td; + inflate_codes_statef *c; + + bl = 9; /* must be <= 9 for lookahead assumptions */ + bd = 6; /* must be <= 9 for lookahead assumptions */ + t = s->sub.trees.table; + t = inflate_trees_dynamic(257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f), + s->sub.trees.blens, &bl, &bd, &tl, &td, + s->hufts, z); + ZFREE(z, s->sub.trees.blens); + if (t != Z_OK) + { + if (t == (uInt)Z_DATA_ERROR) + s->mode = BAD; + r = t; + LEAVE + } + Tracev((stderr, "inflate: trees ok\n")); + if ((c = inflate_codes_new(bl, bd, tl, td, z)) == Z_NULL) + { + r = Z_MEM_ERROR; + LEAVE + } + s->sub.decode.codes = c; + } + s->mode = CODES; + case CODES: + UPDATE + if ((r = inflate_codes(s, z, r)) != Z_STREAM_END) + return inflate_flush(s, z, r); + r = Z_OK; + inflate_codes_free(s->sub.decode.codes, z); + LOAD + Tracev((stderr, "inflate: codes end, %lu total out\n", + z->total_out + (q >= s->read ? q - s->read : + (s->end - s->read) + (q - s->window)))); + if (!s->last) + { + s->mode = TYPE; + break; + } + s->mode = DRY; + case DRY: + FLUSH + if (s->read != s->write) + LEAVE + s->mode = DONE; + case DONE: + r = Z_STREAM_END; + LEAVE + case BAD: + r = Z_DATA_ERROR; + LEAVE + default: + r = Z_STREAM_ERROR; + LEAVE + } +} + + +int inflate_blocks_free(s, z) +inflate_blocks_statef *s; +z_streamp z; +{ + inflate_blocks_reset(s, z, Z_NULL); + ZFREE(z, s->window); + ZFREE(z, s->hufts); + ZFREE(z, s); + Tracev((stderr, "inflate: blocks freed\n")); + return Z_OK; +} + + +void inflate_set_dictionary(s, d, n) +inflate_blocks_statef *s; +const Bytef *d; +uInt n; +{ + zmemcpy(s->window, d, n); + s->read = s->write = s->window + n; +} + + +/* Returns true if inflate is currently at the end of a block generated + * by Z_SYNC_FLUSH or Z_FULL_FLUSH. + * IN assertion: s != Z_NULL + */ +int inflate_blocks_sync_point(s) +inflate_blocks_statef *s; +{ + return s->mode == LENS; +} diff --git a/stepmania/src/smpackage/ZipArchive/zlib/infblock.h b/stepmania/src/smpackage/ZipArchive/zlib/infblock.h new file mode 100644 index 0000000000..bd25c80753 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/zlib/infblock.h @@ -0,0 +1,39 @@ +/* infblock.h -- header to use infblock.c + * Copyright (C) 1995-1998 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* WARNING: this file should *not* be used by applications. It is + part of the implementation of the compression library and is + subject to change. Applications should only use zlib.h. + */ + +struct inflate_blocks_state; +typedef struct inflate_blocks_state FAR inflate_blocks_statef; + +extern inflate_blocks_statef * inflate_blocks_new OF(( + z_streamp z, + check_func c, /* check function */ + uInt w)); /* window size */ + +extern int inflate_blocks OF(( + inflate_blocks_statef *, + z_streamp , + int)); /* initial return code */ + +extern void inflate_blocks_reset OF(( + inflate_blocks_statef *, + z_streamp , + uLongf *)); /* check value on output */ + +extern int inflate_blocks_free OF(( + inflate_blocks_statef *, + z_streamp)); + +extern void inflate_set_dictionary OF(( + inflate_blocks_statef *s, + const Bytef *d, /* dictionary */ + uInt n)); /* dictionary length */ + +extern int inflate_blocks_sync_point OF(( + inflate_blocks_statef *s)); diff --git a/stepmania/src/smpackage/ZipArchive/zlib/infcodes.c b/stepmania/src/smpackage/ZipArchive/zlib/infcodes.c new file mode 100644 index 0000000000..d4e5ee9a55 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/zlib/infcodes.c @@ -0,0 +1,257 @@ +/* infcodes.c -- process literals and length/distance pairs + * Copyright (C) 1995-1998 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#include "zutil.h" +#include "inftrees.h" +#include "infblock.h" +#include "infcodes.h" +#include "infutil.h" +#include "inffast.h" + +/* simplify the use of the inflate_huft type with some defines */ +#define exop word.what.Exop +#define bits word.what.Bits + +typedef enum { /* waiting for "i:"=input, "o:"=output, "x:"=nothing */ + START, /* x: set up for LEN */ + LEN, /* i: get length/literal/eob next */ + LENEXT, /* i: getting length extra (have base) */ + DIST, /* i: get distance next */ + DISTEXT, /* i: getting distance extra */ + COPY, /* o: copying bytes in window, waiting for space */ + LIT, /* o: got literal, waiting for output space */ + WASH, /* o: got eob, possibly still output waiting */ + END, /* x: got eob and all data flushed */ + BADCODE} /* x: got error */ +inflate_codes_mode; + +/* inflate codes private state */ +struct inflate_codes_state { + + /* mode */ + inflate_codes_mode mode; /* current inflate_codes mode */ + + /* mode dependent information */ + uInt len; + union { + struct { + inflate_huft *tree; /* pointer into tree */ + uInt need; /* bits needed */ + } code; /* if LEN or DIST, where in tree */ + uInt lit; /* if LIT, literal */ + struct { + uInt get; /* bits to get for extra */ + uInt dist; /* distance back to copy from */ + } copy; /* if EXT or COPY, where and how much */ + } sub; /* submode */ + + /* mode independent information */ + Byte lbits; /* ltree bits decoded per branch */ + Byte dbits; /* dtree bits decoder per branch */ + inflate_huft *ltree; /* literal/length/eob tree */ + inflate_huft *dtree; /* distance tree */ + +}; + + +inflate_codes_statef *inflate_codes_new(bl, bd, tl, td, z) +uInt bl, bd; +inflate_huft *tl; +inflate_huft *td; /* need separate declaration for Borland C++ */ +z_streamp z; +{ + inflate_codes_statef *c; + + if ((c = (inflate_codes_statef *) + ZALLOC(z,1,sizeof(struct inflate_codes_state))) != Z_NULL) + { + c->mode = START; + c->lbits = (Byte)bl; + c->dbits = (Byte)bd; + c->ltree = tl; + c->dtree = td; + Tracev((stderr, "inflate: codes new\n")); + } + return c; +} + + +int inflate_codes(s, z, r) +inflate_blocks_statef *s; +z_streamp z; +int r; +{ + uInt j; /* temporary storage */ + inflate_huft *t; /* temporary pointer */ + uInt e; /* extra bits or operation */ + uLong b; /* bit buffer */ + uInt k; /* bits in bit buffer */ + Bytef *p; /* input data pointer */ + uInt n; /* bytes available there */ + Bytef *q; /* output window write pointer */ + uInt m; /* bytes to end of window or read pointer */ + Bytef *f; /* pointer to copy strings from */ + inflate_codes_statef *c = s->sub.decode.codes; /* codes state */ + + /* copy input/output information to locals (UPDATE macro restores) */ + LOAD + + /* process input and output based on current state */ + while (1) switch (c->mode) + { /* waiting for "i:"=input, "o:"=output, "x:"=nothing */ + case START: /* x: set up for LEN */ +#ifndef SLOW + if (m >= 258 && n >= 10) + { + UPDATE + r = inflate_fast(c->lbits, c->dbits, c->ltree, c->dtree, s, z); + LOAD + if (r != Z_OK) + { + c->mode = r == Z_STREAM_END ? WASH : BADCODE; + break; + } + } +#endif /* !SLOW */ + c->sub.code.need = c->lbits; + c->sub.code.tree = c->ltree; + c->mode = LEN; + case LEN: /* i: get length/literal/eob next */ + j = c->sub.code.need; + NEEDBITS(j) + t = c->sub.code.tree + ((uInt)b & inflate_mask[j]); + DUMPBITS(t->bits) + e = (uInt)(t->exop); + if (e == 0) /* literal */ + { + c->sub.lit = t->base; + Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ? + "inflate: literal '%c'\n" : + "inflate: literal 0x%02x\n", t->base)); + c->mode = LIT; + break; + } + if (e & 16) /* length */ + { + c->sub.copy.get = e & 15; + c->len = t->base; + c->mode = LENEXT; + break; + } + if ((e & 64) == 0) /* next table */ + { + c->sub.code.need = e; + c->sub.code.tree = t + t->base; + break; + } + if (e & 32) /* end of block */ + { + Tracevv((stderr, "inflate: end of block\n")); + c->mode = WASH; + break; + } + c->mode = BADCODE; /* invalid code */ + z->msg = (char*)"invalid literal/length code"; + r = Z_DATA_ERROR; + LEAVE + case LENEXT: /* i: getting length extra (have base) */ + j = c->sub.copy.get; + NEEDBITS(j) + c->len += (uInt)b & inflate_mask[j]; + DUMPBITS(j) + c->sub.code.need = c->dbits; + c->sub.code.tree = c->dtree; + Tracevv((stderr, "inflate: length %u\n", c->len)); + c->mode = DIST; + case DIST: /* i: get distance next */ + j = c->sub.code.need; + NEEDBITS(j) + t = c->sub.code.tree + ((uInt)b & inflate_mask[j]); + DUMPBITS(t->bits) + e = (uInt)(t->exop); + if (e & 16) /* distance */ + { + c->sub.copy.get = e & 15; + c->sub.copy.dist = t->base; + c->mode = DISTEXT; + break; + } + if ((e & 64) == 0) /* next table */ + { + c->sub.code.need = e; + c->sub.code.tree = t + t->base; + break; + } + c->mode = BADCODE; /* invalid code */ + z->msg = (char*)"invalid distance code"; + r = Z_DATA_ERROR; + LEAVE + case DISTEXT: /* i: getting distance extra */ + j = c->sub.copy.get; + NEEDBITS(j) + c->sub.copy.dist += (uInt)b & inflate_mask[j]; + DUMPBITS(j) + Tracevv((stderr, "inflate: distance %u\n", c->sub.copy.dist)); + c->mode = COPY; + case COPY: /* o: copying bytes in window, waiting for space */ +#ifndef __TURBOC__ /* Turbo C bug for following expression */ + f = (uInt)(q - s->window) < c->sub.copy.dist ? + s->end - (c->sub.copy.dist - (q - s->window)) : + q - c->sub.copy.dist; +#else + f = q - c->sub.copy.dist; + if ((uInt)(q - s->window) < c->sub.copy.dist) + f = s->end - (c->sub.copy.dist - (uInt)(q - s->window)); +#endif + while (c->len) + { + NEEDOUT + OUTBYTE(*f++) + if (f == s->end) + f = s->window; + c->len--; + } + c->mode = START; + break; + case LIT: /* o: got literal, waiting for output space */ + NEEDOUT + OUTBYTE(c->sub.lit) + c->mode = START; + break; + case WASH: /* o: got eob, possibly more output */ + if (k > 7) /* return unused byte, if any */ + { + Assert(k < 16, "inflate_codes grabbed too many bytes") + k -= 8; + n++; + p--; /* can always return one */ + } + FLUSH + if (s->read != s->write) + LEAVE + c->mode = END; + case END: + r = Z_STREAM_END; + LEAVE + case BADCODE: /* x: got error */ + r = Z_DATA_ERROR; + LEAVE + default: + r = Z_STREAM_ERROR; + LEAVE + } +#ifdef NEED_DUMMY_RETURN + return Z_STREAM_ERROR; /* Some dumb compilers complain without this */ +#endif +} + + +void inflate_codes_free(c, z) +inflate_codes_statef *c; +z_streamp z; +{ + ZFREE(z, c); + Tracev((stderr, "inflate: codes free\n")); +} diff --git a/stepmania/src/smpackage/ZipArchive/zlib/infcodes.h b/stepmania/src/smpackage/ZipArchive/zlib/infcodes.h new file mode 100644 index 0000000000..6c750d896f --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/zlib/infcodes.h @@ -0,0 +1,27 @@ +/* infcodes.h -- header to use infcodes.c + * Copyright (C) 1995-1998 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* WARNING: this file should *not* be used by applications. It is + part of the implementation of the compression library and is + subject to change. Applications should only use zlib.h. + */ + +struct inflate_codes_state; +typedef struct inflate_codes_state FAR inflate_codes_statef; + +extern inflate_codes_statef *inflate_codes_new OF(( + uInt, uInt, + inflate_huft *, inflate_huft *, + z_streamp )); + +extern int inflate_codes OF(( + inflate_blocks_statef *, + z_streamp , + int)); + +extern void inflate_codes_free OF(( + inflate_codes_statef *, + z_streamp )); + diff --git a/stepmania/src/smpackage/ZipArchive/zlib/inffast.c b/stepmania/src/smpackage/ZipArchive/zlib/inffast.c new file mode 100644 index 0000000000..61a78ee933 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/zlib/inffast.c @@ -0,0 +1,170 @@ +/* inffast.c -- process literals and length/distance pairs fast + * Copyright (C) 1995-1998 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#include "zutil.h" +#include "inftrees.h" +#include "infblock.h" +#include "infcodes.h" +#include "infutil.h" +#include "inffast.h" + +struct inflate_codes_state {int dummy;}; /* for buggy compilers */ + +/* simplify the use of the inflate_huft type with some defines */ +#define exop word.what.Exop +#define bits word.what.Bits + +/* macros for bit input with no checking and for returning unused bytes */ +#define GRABBITS(j) {while(k<(j)){b|=((uLong)NEXTBYTE)<avail_in-n;c=(k>>3)>3:c;n+=c;p-=c;k-=c<<3;} + +/* Called with number of bytes left to write in window at least 258 + (the maximum string length) and number of input bytes available + at least ten. The ten bytes are six bytes for the longest length/ + distance pair plus four bytes for overloading the bit buffer. */ + +int inflate_fast(bl, bd, tl, td, s, z) +uInt bl, bd; +inflate_huft *tl; +inflate_huft *td; /* need separate declaration for Borland C++ */ +inflate_blocks_statef *s; +z_streamp z; +{ + inflate_huft *t; /* temporary pointer */ + uInt e; /* extra bits or operation */ + uLong b; /* bit buffer */ + uInt k; /* bits in bit buffer */ + Bytef *p; /* input data pointer */ + uInt n; /* bytes available there */ + Bytef *q; /* output window write pointer */ + uInt m; /* bytes to end of window or read pointer */ + uInt ml; /* mask for literal/length tree */ + uInt md; /* mask for distance tree */ + uInt c; /* bytes to copy */ + uInt d; /* distance back to copy from */ + Bytef *r; /* copy source pointer */ + + /* load input, output, bit values */ + LOAD + + /* initialize masks */ + ml = inflate_mask[bl]; + md = inflate_mask[bd]; + + /* do until not enough input or output space for fast loop */ + do { /* assume called with m >= 258 && n >= 10 */ + /* get literal/length code */ + GRABBITS(20) /* max bits for literal/length code */ + if ((e = (t = tl + ((uInt)b & ml))->exop) == 0) + { + DUMPBITS(t->bits) + Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ? + "inflate: * literal '%c'\n" : + "inflate: * literal 0x%02x\n", t->base)); + *q++ = (Byte)t->base; + m--; + continue; + } + do { + DUMPBITS(t->bits) + if (e & 16) + { + /* get extra bits for length */ + e &= 15; + c = t->base + ((uInt)b & inflate_mask[e]); + DUMPBITS(e) + Tracevv((stderr, "inflate: * length %u\n", c)); + + /* decode distance base of block to copy */ + GRABBITS(15); /* max bits for distance code */ + e = (t = td + ((uInt)b & md))->exop; + do { + DUMPBITS(t->bits) + if (e & 16) + { + /* get extra bits to add to distance base */ + e &= 15; + GRABBITS(e) /* get extra bits (up to 13) */ + d = t->base + ((uInt)b & inflate_mask[e]); + DUMPBITS(e) + Tracevv((stderr, "inflate: * distance %u\n", d)); + + /* do the copy */ + m -= c; + if ((uInt)(q - s->window) >= d) /* offset before dest */ + { /* just copy */ + r = q - d; + *q++ = *r++; c--; /* minimum count is three, */ + *q++ = *r++; c--; /* so unroll loop a little */ + } + else /* else offset after destination */ + { + e = d - (uInt)(q - s->window); /* bytes from offset to end */ + r = s->end - e; /* pointer to offset */ + if (c > e) /* if source crosses, */ + { + c -= e; /* copy to end of window */ + do { + *q++ = *r++; + } while (--e); + r = s->window; /* copy rest from start of window */ + } + } + do { /* copy all or what's left */ + *q++ = *r++; + } while (--c); + break; + } + else if ((e & 64) == 0) + { + t += t->base; + e = (t += ((uInt)b & inflate_mask[e]))->exop; + } + else + { + z->msg = (char*)"invalid distance code"; + UNGRAB + UPDATE + return Z_DATA_ERROR; + } + } while (1); + break; + } + if ((e & 64) == 0) + { + t += t->base; + if ((e = (t += ((uInt)b & inflate_mask[e]))->exop) == 0) + { + DUMPBITS(t->bits) + Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ? + "inflate: * literal '%c'\n" : + "inflate: * literal 0x%02x\n", t->base)); + *q++ = (Byte)t->base; + m--; + break; + } + } + else if (e & 32) + { + Tracevv((stderr, "inflate: * end of block\n")); + UNGRAB + UPDATE + return Z_STREAM_END; + } + else + { + z->msg = (char*)"invalid literal/length code"; + UNGRAB + UPDATE + return Z_DATA_ERROR; + } + } while (1); + } while (m >= 258 && n >= 10); + + /* not enough input or output--restore pointers and return */ + UNGRAB + UPDATE + return Z_OK; +} diff --git a/stepmania/src/smpackage/ZipArchive/zlib/inffast.h b/stepmania/src/smpackage/ZipArchive/zlib/inffast.h new file mode 100644 index 0000000000..8facec5531 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/zlib/inffast.h @@ -0,0 +1,17 @@ +/* inffast.h -- header to use inffast.c + * Copyright (C) 1995-1998 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* WARNING: this file should *not* be used by applications. It is + part of the implementation of the compression library and is + subject to change. Applications should only use zlib.h. + */ + +extern int inflate_fast OF(( + uInt, + uInt, + inflate_huft *, + inflate_huft *, + inflate_blocks_statef *, + z_streamp )); diff --git a/stepmania/src/smpackage/ZipArchive/zlib/inffixed.h b/stepmania/src/smpackage/ZipArchive/zlib/inffixed.h new file mode 100644 index 0000000000..77f7e76314 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/zlib/inffixed.h @@ -0,0 +1,151 @@ +/* inffixed.h -- table for decoding fixed codes + * Generated automatically by the maketree.c program + */ + +/* WARNING: this file should *not* be used by applications. It is + part of the implementation of the compression library and is + subject to change. Applications should only use zlib.h. + */ + +local uInt fixed_bl = 9; +local uInt fixed_bd = 5; +local inflate_huft fixed_tl[] = { + {{{96,7}},256}, {{{0,8}},80}, {{{0,8}},16}, {{{84,8}},115}, + {{{82,7}},31}, {{{0,8}},112}, {{{0,8}},48}, {{{0,9}},192}, + {{{80,7}},10}, {{{0,8}},96}, {{{0,8}},32}, {{{0,9}},160}, + {{{0,8}},0}, {{{0,8}},128}, {{{0,8}},64}, {{{0,9}},224}, + {{{80,7}},6}, {{{0,8}},88}, {{{0,8}},24}, {{{0,9}},144}, + {{{83,7}},59}, {{{0,8}},120}, {{{0,8}},56}, {{{0,9}},208}, + {{{81,7}},17}, {{{0,8}},104}, {{{0,8}},40}, {{{0,9}},176}, + {{{0,8}},8}, {{{0,8}},136}, {{{0,8}},72}, {{{0,9}},240}, + {{{80,7}},4}, {{{0,8}},84}, {{{0,8}},20}, {{{85,8}},227}, + {{{83,7}},43}, {{{0,8}},116}, {{{0,8}},52}, {{{0,9}},200}, + {{{81,7}},13}, {{{0,8}},100}, {{{0,8}},36}, {{{0,9}},168}, + {{{0,8}},4}, {{{0,8}},132}, {{{0,8}},68}, {{{0,9}},232}, + {{{80,7}},8}, {{{0,8}},92}, {{{0,8}},28}, {{{0,9}},152}, + {{{84,7}},83}, {{{0,8}},124}, {{{0,8}},60}, {{{0,9}},216}, + {{{82,7}},23}, {{{0,8}},108}, {{{0,8}},44}, {{{0,9}},184}, + {{{0,8}},12}, {{{0,8}},140}, {{{0,8}},76}, {{{0,9}},248}, + {{{80,7}},3}, {{{0,8}},82}, {{{0,8}},18}, {{{85,8}},163}, + {{{83,7}},35}, {{{0,8}},114}, {{{0,8}},50}, {{{0,9}},196}, + {{{81,7}},11}, {{{0,8}},98}, {{{0,8}},34}, {{{0,9}},164}, + {{{0,8}},2}, {{{0,8}},130}, {{{0,8}},66}, {{{0,9}},228}, + {{{80,7}},7}, {{{0,8}},90}, {{{0,8}},26}, {{{0,9}},148}, + {{{84,7}},67}, {{{0,8}},122}, {{{0,8}},58}, {{{0,9}},212}, + {{{82,7}},19}, {{{0,8}},106}, {{{0,8}},42}, {{{0,9}},180}, + {{{0,8}},10}, {{{0,8}},138}, {{{0,8}},74}, {{{0,9}},244}, + {{{80,7}},5}, {{{0,8}},86}, {{{0,8}},22}, {{{192,8}},0}, + {{{83,7}},51}, {{{0,8}},118}, {{{0,8}},54}, {{{0,9}},204}, + {{{81,7}},15}, {{{0,8}},102}, {{{0,8}},38}, {{{0,9}},172}, + {{{0,8}},6}, {{{0,8}},134}, {{{0,8}},70}, {{{0,9}},236}, + {{{80,7}},9}, {{{0,8}},94}, {{{0,8}},30}, {{{0,9}},156}, + {{{84,7}},99}, {{{0,8}},126}, {{{0,8}},62}, {{{0,9}},220}, + {{{82,7}},27}, {{{0,8}},110}, {{{0,8}},46}, {{{0,9}},188}, + {{{0,8}},14}, {{{0,8}},142}, {{{0,8}},78}, {{{0,9}},252}, + {{{96,7}},256}, {{{0,8}},81}, {{{0,8}},17}, {{{85,8}},131}, + {{{82,7}},31}, {{{0,8}},113}, {{{0,8}},49}, {{{0,9}},194}, + {{{80,7}},10}, {{{0,8}},97}, {{{0,8}},33}, {{{0,9}},162}, + {{{0,8}},1}, {{{0,8}},129}, {{{0,8}},65}, {{{0,9}},226}, + {{{80,7}},6}, {{{0,8}},89}, {{{0,8}},25}, {{{0,9}},146}, + {{{83,7}},59}, {{{0,8}},121}, {{{0,8}},57}, {{{0,9}},210}, + {{{81,7}},17}, {{{0,8}},105}, {{{0,8}},41}, {{{0,9}},178}, + {{{0,8}},9}, {{{0,8}},137}, {{{0,8}},73}, {{{0,9}},242}, + {{{80,7}},4}, {{{0,8}},85}, {{{0,8}},21}, {{{80,8}},258}, + {{{83,7}},43}, {{{0,8}},117}, {{{0,8}},53}, {{{0,9}},202}, + {{{81,7}},13}, {{{0,8}},101}, {{{0,8}},37}, {{{0,9}},170}, + {{{0,8}},5}, {{{0,8}},133}, {{{0,8}},69}, {{{0,9}},234}, + {{{80,7}},8}, {{{0,8}},93}, {{{0,8}},29}, {{{0,9}},154}, + {{{84,7}},83}, {{{0,8}},125}, {{{0,8}},61}, {{{0,9}},218}, + {{{82,7}},23}, {{{0,8}},109}, {{{0,8}},45}, {{{0,9}},186}, + {{{0,8}},13}, {{{0,8}},141}, {{{0,8}},77}, {{{0,9}},250}, + {{{80,7}},3}, {{{0,8}},83}, {{{0,8}},19}, {{{85,8}},195}, + {{{83,7}},35}, {{{0,8}},115}, {{{0,8}},51}, {{{0,9}},198}, + {{{81,7}},11}, {{{0,8}},99}, {{{0,8}},35}, {{{0,9}},166}, + {{{0,8}},3}, {{{0,8}},131}, {{{0,8}},67}, {{{0,9}},230}, + {{{80,7}},7}, {{{0,8}},91}, {{{0,8}},27}, {{{0,9}},150}, + {{{84,7}},67}, {{{0,8}},123}, {{{0,8}},59}, {{{0,9}},214}, + {{{82,7}},19}, {{{0,8}},107}, {{{0,8}},43}, {{{0,9}},182}, + {{{0,8}},11}, {{{0,8}},139}, {{{0,8}},75}, {{{0,9}},246}, + {{{80,7}},5}, {{{0,8}},87}, {{{0,8}},23}, {{{192,8}},0}, + {{{83,7}},51}, {{{0,8}},119}, {{{0,8}},55}, {{{0,9}},206}, + {{{81,7}},15}, {{{0,8}},103}, {{{0,8}},39}, {{{0,9}},174}, + {{{0,8}},7}, {{{0,8}},135}, {{{0,8}},71}, {{{0,9}},238}, + {{{80,7}},9}, {{{0,8}},95}, {{{0,8}},31}, {{{0,9}},158}, + {{{84,7}},99}, {{{0,8}},127}, {{{0,8}},63}, {{{0,9}},222}, + {{{82,7}},27}, {{{0,8}},111}, {{{0,8}},47}, {{{0,9}},190}, + {{{0,8}},15}, {{{0,8}},143}, {{{0,8}},79}, {{{0,9}},254}, + {{{96,7}},256}, {{{0,8}},80}, {{{0,8}},16}, {{{84,8}},115}, + {{{82,7}},31}, {{{0,8}},112}, {{{0,8}},48}, {{{0,9}},193}, + {{{80,7}},10}, {{{0,8}},96}, {{{0,8}},32}, {{{0,9}},161}, + {{{0,8}},0}, {{{0,8}},128}, {{{0,8}},64}, {{{0,9}},225}, + {{{80,7}},6}, {{{0,8}},88}, {{{0,8}},24}, {{{0,9}},145}, + {{{83,7}},59}, {{{0,8}},120}, {{{0,8}},56}, {{{0,9}},209}, + {{{81,7}},17}, {{{0,8}},104}, {{{0,8}},40}, {{{0,9}},177}, + {{{0,8}},8}, {{{0,8}},136}, {{{0,8}},72}, {{{0,9}},241}, + {{{80,7}},4}, {{{0,8}},84}, {{{0,8}},20}, {{{85,8}},227}, + {{{83,7}},43}, {{{0,8}},116}, {{{0,8}},52}, {{{0,9}},201}, + {{{81,7}},13}, {{{0,8}},100}, {{{0,8}},36}, {{{0,9}},169}, + {{{0,8}},4}, {{{0,8}},132}, {{{0,8}},68}, {{{0,9}},233}, + {{{80,7}},8}, {{{0,8}},92}, {{{0,8}},28}, {{{0,9}},153}, + {{{84,7}},83}, {{{0,8}},124}, {{{0,8}},60}, {{{0,9}},217}, + {{{82,7}},23}, {{{0,8}},108}, {{{0,8}},44}, {{{0,9}},185}, + {{{0,8}},12}, {{{0,8}},140}, {{{0,8}},76}, {{{0,9}},249}, + {{{80,7}},3}, {{{0,8}},82}, {{{0,8}},18}, {{{85,8}},163}, + {{{83,7}},35}, {{{0,8}},114}, {{{0,8}},50}, {{{0,9}},197}, + {{{81,7}},11}, {{{0,8}},98}, {{{0,8}},34}, {{{0,9}},165}, + {{{0,8}},2}, {{{0,8}},130}, {{{0,8}},66}, {{{0,9}},229}, + {{{80,7}},7}, {{{0,8}},90}, {{{0,8}},26}, {{{0,9}},149}, + {{{84,7}},67}, {{{0,8}},122}, {{{0,8}},58}, {{{0,9}},213}, + {{{82,7}},19}, {{{0,8}},106}, {{{0,8}},42}, {{{0,9}},181}, + {{{0,8}},10}, {{{0,8}},138}, {{{0,8}},74}, {{{0,9}},245}, + {{{80,7}},5}, {{{0,8}},86}, {{{0,8}},22}, {{{192,8}},0}, + {{{83,7}},51}, {{{0,8}},118}, {{{0,8}},54}, {{{0,9}},205}, + {{{81,7}},15}, {{{0,8}},102}, {{{0,8}},38}, {{{0,9}},173}, + {{{0,8}},6}, {{{0,8}},134}, {{{0,8}},70}, {{{0,9}},237}, + {{{80,7}},9}, {{{0,8}},94}, {{{0,8}},30}, {{{0,9}},157}, + {{{84,7}},99}, {{{0,8}},126}, {{{0,8}},62}, {{{0,9}},221}, + {{{82,7}},27}, {{{0,8}},110}, {{{0,8}},46}, {{{0,9}},189}, + {{{0,8}},14}, {{{0,8}},142}, {{{0,8}},78}, {{{0,9}},253}, + {{{96,7}},256}, {{{0,8}},81}, {{{0,8}},17}, {{{85,8}},131}, + {{{82,7}},31}, {{{0,8}},113}, {{{0,8}},49}, {{{0,9}},195}, + {{{80,7}},10}, {{{0,8}},97}, {{{0,8}},33}, {{{0,9}},163}, + {{{0,8}},1}, {{{0,8}},129}, {{{0,8}},65}, {{{0,9}},227}, + {{{80,7}},6}, {{{0,8}},89}, {{{0,8}},25}, {{{0,9}},147}, + {{{83,7}},59}, {{{0,8}},121}, {{{0,8}},57}, {{{0,9}},211}, + {{{81,7}},17}, {{{0,8}},105}, {{{0,8}},41}, {{{0,9}},179}, + {{{0,8}},9}, {{{0,8}},137}, {{{0,8}},73}, {{{0,9}},243}, + {{{80,7}},4}, {{{0,8}},85}, {{{0,8}},21}, {{{80,8}},258}, + {{{83,7}},43}, {{{0,8}},117}, {{{0,8}},53}, {{{0,9}},203}, + {{{81,7}},13}, {{{0,8}},101}, {{{0,8}},37}, {{{0,9}},171}, + {{{0,8}},5}, {{{0,8}},133}, {{{0,8}},69}, {{{0,9}},235}, + {{{80,7}},8}, {{{0,8}},93}, {{{0,8}},29}, {{{0,9}},155}, + {{{84,7}},83}, {{{0,8}},125}, {{{0,8}},61}, {{{0,9}},219}, + {{{82,7}},23}, {{{0,8}},109}, {{{0,8}},45}, {{{0,9}},187}, + {{{0,8}},13}, {{{0,8}},141}, {{{0,8}},77}, {{{0,9}},251}, + {{{80,7}},3}, {{{0,8}},83}, {{{0,8}},19}, {{{85,8}},195}, + {{{83,7}},35}, {{{0,8}},115}, {{{0,8}},51}, {{{0,9}},199}, + {{{81,7}},11}, {{{0,8}},99}, {{{0,8}},35}, {{{0,9}},167}, + {{{0,8}},3}, {{{0,8}},131}, {{{0,8}},67}, {{{0,9}},231}, + {{{80,7}},7}, {{{0,8}},91}, {{{0,8}},27}, {{{0,9}},151}, + {{{84,7}},67}, {{{0,8}},123}, {{{0,8}},59}, {{{0,9}},215}, + {{{82,7}},19}, {{{0,8}},107}, {{{0,8}},43}, {{{0,9}},183}, + {{{0,8}},11}, {{{0,8}},139}, {{{0,8}},75}, {{{0,9}},247}, + {{{80,7}},5}, {{{0,8}},87}, {{{0,8}},23}, {{{192,8}},0}, + {{{83,7}},51}, {{{0,8}},119}, {{{0,8}},55}, {{{0,9}},207}, + {{{81,7}},15}, {{{0,8}},103}, {{{0,8}},39}, {{{0,9}},175}, + {{{0,8}},7}, {{{0,8}},135}, {{{0,8}},71}, {{{0,9}},239}, + {{{80,7}},9}, {{{0,8}},95}, {{{0,8}},31}, {{{0,9}},159}, + {{{84,7}},99}, {{{0,8}},127}, {{{0,8}},63}, {{{0,9}},223}, + {{{82,7}},27}, {{{0,8}},111}, {{{0,8}},47}, {{{0,9}},191}, + {{{0,8}},15}, {{{0,8}},143}, {{{0,8}},79}, {{{0,9}},255} + }; +local inflate_huft fixed_td[] = { + {{{80,5}},1}, {{{87,5}},257}, {{{83,5}},17}, {{{91,5}},4097}, + {{{81,5}},5}, {{{89,5}},1025}, {{{85,5}},65}, {{{93,5}},16385}, + {{{80,5}},3}, {{{88,5}},513}, {{{84,5}},33}, {{{92,5}},8193}, + {{{82,5}},9}, {{{90,5}},2049}, {{{86,5}},129}, {{{192,5}},24577}, + {{{80,5}},2}, {{{87,5}},385}, {{{83,5}},25}, {{{91,5}},6145}, + {{{81,5}},7}, {{{89,5}},1537}, {{{85,5}},97}, {{{93,5}},24577}, + {{{80,5}},4}, {{{88,5}},769}, {{{84,5}},49}, {{{92,5}},12289}, + {{{82,5}},13}, {{{90,5}},3073}, {{{86,5}},193}, {{{192,5}},24577} + }; diff --git a/stepmania/src/smpackage/ZipArchive/zlib/inflate.c b/stepmania/src/smpackage/ZipArchive/zlib/inflate.c new file mode 100644 index 0000000000..32e9b8de67 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/zlib/inflate.c @@ -0,0 +1,366 @@ +/* inflate.c -- zlib interface to inflate modules + * Copyright (C) 1995-1998 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#include "zutil.h" +#include "infblock.h" + +struct inflate_blocks_state {int dummy;}; /* for buggy compilers */ + +typedef enum { + METHOD, /* waiting for method byte */ + FLAG, /* waiting for flag byte */ + DICT4, /* four dictionary check bytes to go */ + DICT3, /* three dictionary check bytes to go */ + DICT2, /* two dictionary check bytes to go */ + DICT1, /* one dictionary check byte to go */ + DICT0, /* waiting for inflateSetDictionary */ + BLOCKS, /* decompressing blocks */ + CHECK4, /* four check bytes to go */ + CHECK3, /* three check bytes to go */ + CHECK2, /* two check bytes to go */ + CHECK1, /* one check byte to go */ + DONE, /* finished check, done */ + BAD} /* got an error--stay here */ +inflate_mode; + +/* inflate private state */ +struct internal_state { + + /* mode */ + inflate_mode mode; /* current inflate mode */ + + /* mode dependent information */ + union { + uInt method; /* if FLAGS, method byte */ + struct { + uLong was; /* computed check value */ + uLong need; /* stream check value */ + } check; /* if CHECK, check values to compare */ + uInt marker; /* if BAD, inflateSync's marker bytes count */ + } sub; /* submode */ + + /* mode independent information */ + int nowrap; /* flag for no wrapper */ + uInt wbits; /* log2(window size) (8..15, defaults to 15) */ + inflate_blocks_statef + *blocks; /* current inflate_blocks state */ + +}; + + +int ZEXPORT inflateReset(z) +z_streamp z; +{ + if (z == Z_NULL || z->state == Z_NULL) + return Z_STREAM_ERROR; + z->total_in = z->total_out = 0; + z->msg = Z_NULL; + z->state->mode = z->state->nowrap ? BLOCKS : METHOD; + inflate_blocks_reset(z->state->blocks, z, Z_NULL); + Tracev((stderr, "inflate: reset\n")); + return Z_OK; +} + + +int ZEXPORT inflateEnd(z) +z_streamp z; +{ + if (z == Z_NULL || z->state == Z_NULL || z->zfree == Z_NULL) + return Z_STREAM_ERROR; + if (z->state->blocks != Z_NULL) + inflate_blocks_free(z->state->blocks, z); + ZFREE(z, z->state); + z->state = Z_NULL; + Tracev((stderr, "inflate: end\n")); + return Z_OK; +} + + +int ZEXPORT inflateInit2_(z, w, version, stream_size) +z_streamp z; +int w; +const char *version; +int stream_size; +{ + if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || + stream_size != sizeof(z_stream)) + return Z_VERSION_ERROR; + + /* initialize state */ + if (z == Z_NULL) + return Z_STREAM_ERROR; + z->msg = Z_NULL; + if (z->zalloc == Z_NULL) + { + z->zalloc = zcalloc; + z->opaque = (voidpf)0; + } + if (z->zfree == Z_NULL) z->zfree = zcfree; + if ((z->state = (struct internal_state FAR *) + ZALLOC(z,1,sizeof(struct internal_state))) == Z_NULL) + return Z_MEM_ERROR; + z->state->blocks = Z_NULL; + + /* handle undocumented nowrap option (no zlib header or check) */ + z->state->nowrap = 0; + if (w < 0) + { + w = - w; + z->state->nowrap = 1; + } + + /* set window size */ + if (w < 8 || w > 15) + { + inflateEnd(z); + return Z_STREAM_ERROR; + } + z->state->wbits = (uInt)w; + + /* create inflate_blocks state */ + if ((z->state->blocks = + inflate_blocks_new(z, z->state->nowrap ? Z_NULL : adler32, (uInt)1 << w)) + == Z_NULL) + { + inflateEnd(z); + return Z_MEM_ERROR; + } + Tracev((stderr, "inflate: allocated\n")); + + /* reset state */ + inflateReset(z); + return Z_OK; +} + + +int ZEXPORT inflateInit_(z, version, stream_size) +z_streamp z; +const char *version; +int stream_size; +{ + return inflateInit2_(z, DEF_WBITS, version, stream_size); +} + + +#define NEEDBYTE {if(z->avail_in==0)return r;r=f;} +#define NEXTBYTE (z->avail_in--,z->total_in++,*z->next_in++) + +int ZEXPORT inflate(z, f) +z_streamp z; +int f; +{ + int r; + uInt b; + + if (z == Z_NULL || z->state == Z_NULL || z->next_in == Z_NULL) + return Z_STREAM_ERROR; + f = f == Z_FINISH ? Z_BUF_ERROR : Z_OK; + r = Z_BUF_ERROR; + while (1) switch (z->state->mode) + { + case METHOD: + NEEDBYTE + if (((z->state->sub.method = NEXTBYTE) & 0xf) != Z_DEFLATED) + { + z->state->mode = BAD; + z->msg = (char*)"unknown compression method"; + z->state->sub.marker = 5; /* can't try inflateSync */ + break; + } + if ((z->state->sub.method >> 4) + 8 > z->state->wbits) + { + z->state->mode = BAD; + z->msg = (char*)"invalid window size"; + z->state->sub.marker = 5; /* can't try inflateSync */ + break; + } + z->state->mode = FLAG; + case FLAG: + NEEDBYTE + b = NEXTBYTE; + if (((z->state->sub.method << 8) + b) % 31) + { + z->state->mode = BAD; + z->msg = (char*)"incorrect header check"; + z->state->sub.marker = 5; /* can't try inflateSync */ + break; + } + Tracev((stderr, "inflate: zlib header ok\n")); + if (!(b & PRESET_DICT)) + { + z->state->mode = BLOCKS; + break; + } + z->state->mode = DICT4; + case DICT4: + NEEDBYTE + z->state->sub.check.need = (uLong)NEXTBYTE << 24; + z->state->mode = DICT3; + case DICT3: + NEEDBYTE + z->state->sub.check.need += (uLong)NEXTBYTE << 16; + z->state->mode = DICT2; + case DICT2: + NEEDBYTE + z->state->sub.check.need += (uLong)NEXTBYTE << 8; + z->state->mode = DICT1; + case DICT1: + NEEDBYTE + z->state->sub.check.need += (uLong)NEXTBYTE; + z->adler = z->state->sub.check.need; + z->state->mode = DICT0; + return Z_NEED_DICT; + case DICT0: + z->state->mode = BAD; + z->msg = (char*)"need dictionary"; + z->state->sub.marker = 0; /* can try inflateSync */ + return Z_STREAM_ERROR; + case BLOCKS: + r = inflate_blocks(z->state->blocks, z, r); + if (r == Z_DATA_ERROR) + { + z->state->mode = BAD; + z->state->sub.marker = 0; /* can try inflateSync */ + break; + } + if (r == Z_OK) + r = f; + if (r != Z_STREAM_END) + return r; + r = f; + inflate_blocks_reset(z->state->blocks, z, &z->state->sub.check.was); + if (z->state->nowrap) + { + z->state->mode = DONE; + break; + } + z->state->mode = CHECK4; + case CHECK4: + NEEDBYTE + z->state->sub.check.need = (uLong)NEXTBYTE << 24; + z->state->mode = CHECK3; + case CHECK3: + NEEDBYTE + z->state->sub.check.need += (uLong)NEXTBYTE << 16; + z->state->mode = CHECK2; + case CHECK2: + NEEDBYTE + z->state->sub.check.need += (uLong)NEXTBYTE << 8; + z->state->mode = CHECK1; + case CHECK1: + NEEDBYTE + z->state->sub.check.need += (uLong)NEXTBYTE; + + if (z->state->sub.check.was != z->state->sub.check.need) + { + z->state->mode = BAD; + z->msg = (char*)"incorrect data check"; + z->state->sub.marker = 5; /* can't try inflateSync */ + break; + } + Tracev((stderr, "inflate: zlib check ok\n")); + z->state->mode = DONE; + case DONE: + return Z_STREAM_END; + case BAD: + return Z_DATA_ERROR; + default: + return Z_STREAM_ERROR; + } +#ifdef NEED_DUMMY_RETURN + return Z_STREAM_ERROR; /* Some dumb compilers complain without this */ +#endif +} + + +int ZEXPORT inflateSetDictionary(z, dictionary, dictLength) +z_streamp z; +const Bytef *dictionary; +uInt dictLength; +{ + uInt length = dictLength; + + if (z == Z_NULL || z->state == Z_NULL || z->state->mode != DICT0) + return Z_STREAM_ERROR; + + if (adler32(1L, dictionary, dictLength) != z->adler) return Z_DATA_ERROR; + z->adler = 1L; + + if (length >= ((uInt)1<state->wbits)) + { + length = (1<state->wbits)-1; + dictionary += dictLength - length; + } + inflate_set_dictionary(z->state->blocks, dictionary, length); + z->state->mode = BLOCKS; + return Z_OK; +} + + +int ZEXPORT inflateSync(z) +z_streamp z; +{ + uInt n; /* number of bytes to look at */ + Bytef *p; /* pointer to bytes */ + uInt m; /* number of marker bytes found in a row */ + uLong r, w; /* temporaries to save total_in and total_out */ + + /* set up */ + if (z == Z_NULL || z->state == Z_NULL) + return Z_STREAM_ERROR; + if (z->state->mode != BAD) + { + z->state->mode = BAD; + z->state->sub.marker = 0; + } + if ((n = z->avail_in) == 0) + return Z_BUF_ERROR; + p = z->next_in; + m = z->state->sub.marker; + + /* search */ + while (n && m < 4) + { + static const Byte mark[4] = {0, 0, 0xff, 0xff}; + if (*p == mark[m]) + m++; + else if (*p) + m = 0; + else + m = 4 - m; + p++, n--; + } + + /* restore */ + z->total_in += p - z->next_in; + z->next_in = p; + z->avail_in = n; + z->state->sub.marker = m; + + /* return no joy or set up to restart on a new block */ + if (m != 4) + return Z_DATA_ERROR; + r = z->total_in; w = z->total_out; + inflateReset(z); + z->total_in = r; z->total_out = w; + z->state->mode = BLOCKS; + return Z_OK; +} + + +/* Returns true if inflate is currently at the end of a block generated + * by Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP + * implementation to provide an additional safety check. PPP uses Z_SYNC_FLUSH + * but removes the length bytes of the resulting empty stored block. When + * decompressing, PPP checks that at the end of input packet, inflate is + * waiting for these length bytes. + */ +int ZEXPORT inflateSyncPoint(z) +z_streamp z; +{ + if (z == Z_NULL || z->state == Z_NULL || z->state->blocks == Z_NULL) + return Z_STREAM_ERROR; + return inflate_blocks_sync_point(z->state->blocks); +} diff --git a/stepmania/src/smpackage/ZipArchive/zlib/inftrees.c b/stepmania/src/smpackage/ZipArchive/zlib/inftrees.c new file mode 100644 index 0000000000..ef1e0b6b87 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/zlib/inftrees.c @@ -0,0 +1,455 @@ +/* inftrees.c -- generate Huffman trees for efficient decoding + * Copyright (C) 1995-1998 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#include "zutil.h" +#include "inftrees.h" + +#if !defined(BUILDFIXED) && !defined(STDC) +# define BUILDFIXED /* non ANSI compilers may not accept inffixed.h */ +#endif + +const char inflate_copyright[] = + " inflate 1.1.3 Copyright 1995-1998 Mark Adler "; +/* + If you use the zlib library in a product, an acknowledgment is welcome + in the documentation of your product. If for some reason you cannot + include such an acknowledgment, I would appreciate that you keep this + copyright string in the executable of your product. + */ +struct internal_state {int dummy;}; /* for buggy compilers */ + +/* simplify the use of the inflate_huft type with some defines */ +#define exop word.what.Exop +#define bits word.what.Bits + + +local int huft_build OF(( + uIntf *, /* code lengths in bits */ + uInt, /* number of codes */ + uInt, /* number of "simple" codes */ + const uIntf *, /* list of base values for non-simple codes */ + const uIntf *, /* list of extra bits for non-simple codes */ + inflate_huft * FAR*,/* result: starting table */ + uIntf *, /* maximum lookup bits (returns actual) */ + inflate_huft *, /* space for trees */ + uInt *, /* hufts used in space */ + uIntf * )); /* space for values */ + +/* Tables for deflate from PKZIP's appnote.txt. */ +local const uInt cplens[31] = { /* Copy lengths for literal codes 257..285 */ + 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, + 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0}; + /* see note #13 above about 258 */ +local const uInt cplext[31] = { /* Extra bits for literal codes 257..285 */ + 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, + 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 112, 112}; /* 112==invalid */ +local const uInt cpdist[30] = { /* Copy offsets for distance codes 0..29 */ + 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, + 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, + 8193, 12289, 16385, 24577}; +local const uInt cpdext[30] = { /* Extra bits for distance codes */ + 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, + 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, + 12, 12, 13, 13}; + +/* + Huffman code decoding is performed using a multi-level table lookup. + The fastest way to decode is to simply build a lookup table whose + size is determined by the longest code. However, the time it takes + to build this table can also be a factor if the data being decoded + is not very long. The most common codes are necessarily the + shortest codes, so those codes dominate the decoding time, and hence + the speed. The idea is you can have a shorter table that decodes the + shorter, more probable codes, and then point to subsidiary tables for + the longer codes. The time it costs to decode the longer codes is + then traded against the time it takes to make longer tables. + + This results of this trade are in the variables lbits and dbits + below. lbits is the number of bits the first level table for literal/ + length codes can decode in one step, and dbits is the same thing for + the distance codes. Subsequent tables are also less than or equal to + those sizes. These values may be adjusted either when all of the + codes are shorter than that, in which case the longest code length in + bits is used, or when the shortest code is *longer* than the requested + table size, in which case the length of the shortest code in bits is + used. + + There are two different values for the two tables, since they code a + different number of possibilities each. The literal/length table + codes 286 possible values, or in a flat code, a little over eight + bits. The distance table codes 30 possible values, or a little less + than five bits, flat. The optimum values for speed end up being + about one bit more than those, so lbits is 8+1 and dbits is 5+1. + The optimum values may differ though from machine to machine, and + possibly even between compilers. Your mileage may vary. + */ + + +/* If BMAX needs to be larger than 16, then h and x[] should be uLong. */ +#define BMAX 15 /* maximum bit length of any code */ + +local int huft_build(b, n, s, d, e, t, m, hp, hn, v) +uIntf *b; /* code lengths in bits (all assumed <= BMAX) */ +uInt n; /* number of codes (assumed <= 288) */ +uInt s; /* number of simple-valued codes (0..s-1) */ +const uIntf *d; /* list of base values for non-simple codes */ +const uIntf *e; /* list of extra bits for non-simple codes */ +inflate_huft * FAR *t; /* result: starting table */ +uIntf *m; /* maximum lookup bits, returns actual */ +inflate_huft *hp; /* space for trees */ +uInt *hn; /* hufts used in space */ +uIntf *v; /* working area: values in order of bit length */ +/* Given a list of code lengths and a maximum table size, make a set of + tables to decode that set of codes. Return Z_OK on success, Z_BUF_ERROR + if the given code set is incomplete (the tables are still built in this + case), Z_DATA_ERROR if the input is invalid (an over-subscribed set of + lengths), or Z_MEM_ERROR if not enough memory. */ +{ + + uInt a; /* counter for codes of length k */ + uInt c[BMAX+1]; /* bit length count table */ + uInt f; /* i repeats in table every f entries */ + int g; /* maximum code length */ + int h; /* table level */ + register uInt i; /* counter, current code */ + register uInt j; /* counter */ + register int k; /* number of bits in current code */ + int l; /* bits per table (returned in m) */ + uInt mask; /* (1 << w) - 1, to avoid cc -O bug on HP */ + register uIntf *p; /* pointer into c[], b[], or v[] */ + inflate_huft *q; /* points to current table */ + struct inflate_huft_s r; /* table entry for structure assignment */ + inflate_huft *u[BMAX]; /* table stack */ + register int w; /* bits before this table == (l * h) */ + uInt x[BMAX+1]; /* bit offsets, then code stack */ + uIntf *xp; /* pointer into x */ + int y; /* number of dummy codes added */ + uInt z; /* number of entries in current table */ + + + /* Generate counts for each bit length */ + p = c; +#define C0 *p++ = 0; +#define C2 C0 C0 C0 C0 +#define C4 C2 C2 C2 C2 + C4 /* clear c[]--assume BMAX+1 is 16 */ + p = b; i = n; + do { + c[*p++]++; /* assume all entries <= BMAX */ + } while (--i); + if (c[0] == n) /* null input--all zero length codes */ + { + *t = (inflate_huft *)Z_NULL; + *m = 0; + return Z_OK; + } + + + /* Find minimum and maximum length, bound *m by those */ + l = *m; + for (j = 1; j <= BMAX; j++) + if (c[j]) + break; + k = j; /* minimum code length */ + if ((uInt)l < j) + l = j; + for (i = BMAX; i; i--) + if (c[i]) + break; + g = i; /* maximum code length */ + if ((uInt)l > i) + l = i; + *m = l; + + + /* Adjust last length count to fill out codes, if needed */ + for (y = 1 << j; j < i; j++, y <<= 1) + if ((y -= c[j]) < 0) + return Z_DATA_ERROR; + if ((y -= c[i]) < 0) + return Z_DATA_ERROR; + c[i] += y; + + + /* Generate starting offsets into the value table for each length */ + x[1] = j = 0; + p = c + 1; xp = x + 2; + while (--i) { /* note that i == g from above */ + *xp++ = (j += *p++); + } + + + /* Make a table of values in order of bit lengths */ + p = b; i = 0; + do { + if ((j = *p++) != 0) + v[x[j]++] = i; + } while (++i < n); + n = x[g]; /* set n to length of v */ + + + /* Generate the Huffman codes and for each, make the table entries */ + x[0] = i = 0; /* first Huffman code is zero */ + p = v; /* grab values in bit order */ + h = -1; /* no tables yet--level -1 */ + w = -l; /* bits decoded == (l * h) */ + u[0] = (inflate_huft *)Z_NULL; /* just to keep compilers happy */ + q = (inflate_huft *)Z_NULL; /* ditto */ + z = 0; /* ditto */ + + /* go through the bit lengths (k already is bits in shortest code) */ + for (; k <= g; k++) + { + a = c[k]; + while (a--) + { + /* here i is the Huffman code of length k bits for value *p */ + /* make tables up to required level */ + while (k > w + l) + { + h++; + w += l; /* previous table always l bits */ + + /* compute minimum size table less than or equal to l bits */ + z = g - w; + z = z > (uInt)l ? l : z; /* table size upper limit */ + if ((f = 1 << (j = k - w)) > a + 1) /* try a k-w bit table */ + { /* too few codes for k-w bit table */ + f -= a + 1; /* deduct codes from patterns left */ + xp = c + k; + if (j < z) + while (++j < z) /* try smaller tables up to z bits */ + { + if ((f <<= 1) <= *++xp) + break; /* enough codes to use up j bits */ + f -= *xp; /* else deduct codes from patterns */ + } + } + z = 1 << j; /* table entries for j-bit table */ + + /* allocate new table */ + if (*hn + z > MANY) /* (note: doesn't matter for fixed) */ + return Z_MEM_ERROR; /* not enough memory */ + u[h] = q = hp + *hn; + *hn += z; + + /* connect to last table, if there is one */ + if (h) + { + x[h] = i; /* save pattern for backing up */ + r.bits = (Byte)l; /* bits to dump before this table */ + r.exop = (Byte)j; /* bits in this table */ + j = i >> (w - l); + r.base = (uInt)(q - u[h-1] - j); /* offset to this table */ + u[h-1][j] = r; /* connect to last table */ + } + else + *t = q; /* first table is returned result */ + } + + /* set up table entry in r */ + r.bits = (Byte)(k - w); + if (p >= v + n) + r.exop = 128 + 64; /* out of values--invalid code */ + else if (*p < s) + { + r.exop = (Byte)(*p < 256 ? 0 : 32 + 64); /* 256 is end-of-block */ + r.base = *p++; /* simple code is just the value */ + } + else + { + r.exop = (Byte)(e[*p - s] + 16 + 64);/* non-simple--look up in lists */ + r.base = d[*p++ - s]; + } + + /* fill code-like entries with r */ + f = 1 << (k - w); + for (j = i >> w; j < z; j += f) + q[j] = r; + + /* backwards increment the k-bit code i */ + for (j = 1 << (k - 1); i & j; j >>= 1) + i ^= j; + i ^= j; + + /* backup over finished tables */ + mask = (1 << w) - 1; /* needed on HP, cc -O bug */ + while ((i & mask) != x[h]) + { + h--; /* don't need to update q */ + w -= l; + mask = (1 << w) - 1; + } + } + } + + + /* Return Z_BUF_ERROR if we were given an incomplete table */ + return y != 0 && g != 1 ? Z_BUF_ERROR : Z_OK; +} + + +int inflate_trees_bits(c, bb, tb, hp, z) +uIntf *c; /* 19 code lengths */ +uIntf *bb; /* bits tree desired/actual depth */ +inflate_huft * FAR *tb; /* bits tree result */ +inflate_huft *hp; /* space for trees */ +z_streamp z; /* for messages */ +{ + int r; + uInt hn = 0; /* hufts used in space */ + uIntf *v; /* work area for huft_build */ + + if ((v = (uIntf*)ZALLOC(z, 19, sizeof(uInt))) == Z_NULL) + return Z_MEM_ERROR; + r = huft_build(c, 19, 19, (uIntf*)Z_NULL, (uIntf*)Z_NULL, + tb, bb, hp, &hn, v); + if (r == Z_DATA_ERROR) + z->msg = (char*)"oversubscribed dynamic bit lengths tree"; + else if (r == Z_BUF_ERROR || *bb == 0) + { + z->msg = (char*)"incomplete dynamic bit lengths tree"; + r = Z_DATA_ERROR; + } + ZFREE(z, v); + return r; +} + + +int inflate_trees_dynamic(nl, nd, c, bl, bd, tl, td, hp, z) +uInt nl; /* number of literal/length codes */ +uInt nd; /* number of distance codes */ +uIntf *c; /* that many (total) code lengths */ +uIntf *bl; /* literal desired/actual bit depth */ +uIntf *bd; /* distance desired/actual bit depth */ +inflate_huft * FAR *tl; /* literal/length tree result */ +inflate_huft * FAR *td; /* distance tree result */ +inflate_huft *hp; /* space for trees */ +z_streamp z; /* for messages */ +{ + int r; + uInt hn = 0; /* hufts used in space */ + uIntf *v; /* work area for huft_build */ + + /* allocate work area */ + if ((v = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL) + return Z_MEM_ERROR; + + /* build literal/length tree */ + r = huft_build(c, nl, 257, cplens, cplext, tl, bl, hp, &hn, v); + if (r != Z_OK || *bl == 0) + { + if (r == Z_DATA_ERROR) + z->msg = (char*)"oversubscribed literal/length tree"; + else if (r != Z_MEM_ERROR) + { + z->msg = (char*)"incomplete literal/length tree"; + r = Z_DATA_ERROR; + } + ZFREE(z, v); + return r; + } + + /* build distance tree */ + r = huft_build(c + nl, nd, 0, cpdist, cpdext, td, bd, hp, &hn, v); + if (r != Z_OK || (*bd == 0 && nl > 257)) + { + if (r == Z_DATA_ERROR) + z->msg = (char*)"oversubscribed distance tree"; + else if (r == Z_BUF_ERROR) { +#ifdef PKZIP_BUG_WORKAROUND + r = Z_OK; + } +#else + z->msg = (char*)"incomplete distance tree"; + r = Z_DATA_ERROR; + } + else if (r != Z_MEM_ERROR) + { + z->msg = (char*)"empty distance tree with lengths"; + r = Z_DATA_ERROR; + } + ZFREE(z, v); + return r; +#endif + } + + /* done */ + ZFREE(z, v); + return Z_OK; +} + + +/* build fixed tables only once--keep them here */ +#ifdef BUILDFIXED +local int fixed_built = 0; +#define FIXEDH 544 /* number of hufts used by fixed tables */ +local inflate_huft fixed_mem[FIXEDH]; +local uInt fixed_bl; +local uInt fixed_bd; +local inflate_huft *fixed_tl; +local inflate_huft *fixed_td; +#else +#include "inffixed.h" +#endif + + +int inflate_trees_fixed(bl, bd, tl, td, z) +uIntf *bl; /* literal desired/actual bit depth */ +uIntf *bd; /* distance desired/actual bit depth */ +inflate_huft * FAR *tl; /* literal/length tree result */ +inflate_huft * FAR *td; /* distance tree result */ +z_streamp z; /* for memory allocation */ +{ +#ifdef BUILDFIXED + /* build fixed tables if not already */ + if (!fixed_built) + { + int k; /* temporary variable */ + uInt f = 0; /* number of hufts used in fixed_mem */ + uIntf *c; /* length list for huft_build */ + uIntf *v; /* work area for huft_build */ + + /* allocate memory */ + if ((c = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL) + return Z_MEM_ERROR; + if ((v = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL) + { + ZFREE(z, c); + return Z_MEM_ERROR; + } + + /* literal table */ + for (k = 0; k < 144; k++) + c[k] = 8; + for (; k < 256; k++) + c[k] = 9; + for (; k < 280; k++) + c[k] = 7; + for (; k < 288; k++) + c[k] = 8; + fixed_bl = 9; + huft_build(c, 288, 257, cplens, cplext, &fixed_tl, &fixed_bl, + fixed_mem, &f, v); + + /* distance table */ + for (k = 0; k < 30; k++) + c[k] = 5; + fixed_bd = 5; + huft_build(c, 30, 0, cpdist, cpdext, &fixed_td, &fixed_bd, + fixed_mem, &f, v); + + /* done */ + ZFREE(z, v); + ZFREE(z, c); + fixed_built = 1; + } +#endif + *bl = fixed_bl; + *bd = fixed_bd; + *tl = fixed_tl; + *td = fixed_td; + return Z_OK; +} diff --git a/stepmania/src/smpackage/ZipArchive/zlib/inftrees.h b/stepmania/src/smpackage/ZipArchive/zlib/inftrees.h new file mode 100644 index 0000000000..85853e097b --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/zlib/inftrees.h @@ -0,0 +1,58 @@ +/* inftrees.h -- header to use inftrees.c + * Copyright (C) 1995-1998 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* WARNING: this file should *not* be used by applications. It is + part of the implementation of the compression library and is + subject to change. Applications should only use zlib.h. + */ + +/* Huffman code lookup table entry--this entry is four bytes for machines + that have 16-bit pointers (e.g. PC's in the small or medium model). */ + +typedef struct inflate_huft_s FAR inflate_huft; + +struct inflate_huft_s { + union { + struct { + Byte Exop; /* number of extra bits or operation */ + Byte Bits; /* number of bits in this code or subcode */ + } what; + uInt pad; /* pad structure to a power of 2 (4 bytes for */ + } word; /* 16-bit, 8 bytes for 32-bit int's) */ + uInt base; /* literal, length base, distance base, + or table offset */ +}; + +/* Maximum size of dynamic tree. The maximum found in a long but non- + exhaustive search was 1004 huft structures (850 for length/literals + and 154 for distances, the latter actually the result of an + exhaustive search). The actual maximum is not known, but the + value below is more than safe. */ +#define MANY 1440 + +extern int inflate_trees_bits OF(( + uIntf *, /* 19 code lengths */ + uIntf *, /* bits tree desired/actual depth */ + inflate_huft * FAR *, /* bits tree result */ + inflate_huft *, /* space for trees */ + z_streamp)); /* for messages */ + +extern int inflate_trees_dynamic OF(( + uInt, /* number of literal/length codes */ + uInt, /* number of distance codes */ + uIntf *, /* that many (total) code lengths */ + uIntf *, /* literal desired/actual bit depth */ + uIntf *, /* distance desired/actual bit depth */ + inflate_huft * FAR *, /* literal/length tree result */ + inflate_huft * FAR *, /* distance tree result */ + inflate_huft *, /* space for trees */ + z_streamp)); /* for messages */ + +extern int inflate_trees_fixed OF(( + uIntf *, /* literal desired/actual bit depth */ + uIntf *, /* distance desired/actual bit depth */ + inflate_huft * FAR *, /* literal/length tree result */ + inflate_huft * FAR *, /* distance tree result */ + z_streamp)); /* for memory allocation */ diff --git a/stepmania/src/smpackage/ZipArchive/zlib/infutil.c b/stepmania/src/smpackage/ZipArchive/zlib/infutil.c new file mode 100644 index 0000000000..824dab5712 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/zlib/infutil.c @@ -0,0 +1,87 @@ +/* inflate_util.c -- data and routines common to blocks and codes + * Copyright (C) 1995-1998 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#include "zutil.h" +#include "infblock.h" +#include "inftrees.h" +#include "infcodes.h" +#include "infutil.h" + +struct inflate_codes_state {int dummy;}; /* for buggy compilers */ + +/* And'ing with mask[n] masks the lower n bits */ +uInt inflate_mask[17] = { + 0x0000, + 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff, + 0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff +}; + + +/* copy as much as possible from the sliding window to the output area */ +int inflate_flush(s, z, r) +inflate_blocks_statef *s; +z_streamp z; +int r; +{ + uInt n; + Bytef *p; + Bytef *q; + + /* local copies of source and destination pointers */ + p = z->next_out; + q = s->read; + + /* compute number of bytes to copy as far as end of window */ + n = (uInt)((q <= s->write ? s->write : s->end) - q); + if (n > z->avail_out) n = z->avail_out; + if (n && r == Z_BUF_ERROR) r = Z_OK; + + /* update counters */ + z->avail_out -= n; + z->total_out += n; + + /* update check information */ + if (s->checkfn != Z_NULL) + z->adler = s->check = (*s->checkfn)(s->check, q, n); + + /* copy as far as end of window */ + zmemcpy(p, q, n); + p += n; + q += n; + + /* see if more to copy at beginning of window */ + if (q == s->end) + { + /* wrap pointers */ + q = s->window; + if (s->write == s->end) + s->write = s->window; + + /* compute bytes to copy */ + n = (uInt)(s->write - q); + if (n > z->avail_out) n = z->avail_out; + if (n && r == Z_BUF_ERROR) r = Z_OK; + + /* update counters */ + z->avail_out -= n; + z->total_out += n; + + /* update check information */ + if (s->checkfn != Z_NULL) + z->adler = s->check = (*s->checkfn)(s->check, q, n); + + /* copy */ + zmemcpy(p, q, n); + p += n; + q += n; + } + + /* update pointers */ + z->next_out = p; + s->read = q; + + /* done */ + return r; +} diff --git a/stepmania/src/smpackage/ZipArchive/zlib/infutil.h b/stepmania/src/smpackage/ZipArchive/zlib/infutil.h new file mode 100644 index 0000000000..99d1135d06 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/zlib/infutil.h @@ -0,0 +1,98 @@ +/* infutil.h -- types and macros common to blocks and codes + * Copyright (C) 1995-1998 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* WARNING: this file should *not* be used by applications. It is + part of the implementation of the compression library and is + subject to change. Applications should only use zlib.h. + */ + +#ifndef _INFUTIL_H +#define _INFUTIL_H + +typedef enum { + TYPE, /* get type bits (3, including end bit) */ + LENS, /* get lengths for stored */ + STORED, /* processing stored block */ + TABLE, /* get table lengths */ + BTREE, /* get bit lengths tree for a dynamic block */ + DTREE, /* get length, distance trees for a dynamic block */ + CODES, /* processing fixed or dynamic block */ + DRY, /* output remaining window bytes */ + DONE, /* finished last block, done */ + BAD} /* got a data error--stuck here */ +inflate_block_mode; + +/* inflate blocks semi-private state */ +struct inflate_blocks_state { + + /* mode */ + inflate_block_mode mode; /* current inflate_block mode */ + + /* mode dependent information */ + union { + uInt left; /* if STORED, bytes left to copy */ + struct { + uInt table; /* table lengths (14 bits) */ + uInt index; /* index into blens (or border) */ + uIntf *blens; /* bit lengths of codes */ + uInt bb; /* bit length tree depth */ + inflate_huft *tb; /* bit length decoding tree */ + } trees; /* if DTREE, decoding info for trees */ + struct { + inflate_codes_statef + *codes; + } decode; /* if CODES, current state */ + } sub; /* submode */ + uInt last; /* true if this block is the last block */ + + /* mode independent information */ + uInt bitk; /* bits in bit buffer */ + uLong bitb; /* bit buffer */ + inflate_huft *hufts; /* single malloc for tree space */ + Bytef *window; /* sliding window */ + Bytef *end; /* one byte after sliding window */ + Bytef *read; /* window read pointer */ + Bytef *write; /* window write pointer */ + check_func checkfn; /* check function */ + uLong check; /* check on output */ + +}; + + +/* defines for inflate input/output */ +/* update pointers and return */ +#define UPDBITS {s->bitb=b;s->bitk=k;} +#define UPDIN {z->avail_in=n;z->total_in+=p-z->next_in;z->next_in=p;} +#define UPDOUT {s->write=q;} +#define UPDATE {UPDBITS UPDIN UPDOUT} +#define LEAVE {UPDATE return inflate_flush(s,z,r);} +/* get bytes and bits */ +#define LOADIN {p=z->next_in;n=z->avail_in;b=s->bitb;k=s->bitk;} +#define NEEDBYTE {if(n)r=Z_OK;else LEAVE} +#define NEXTBYTE (n--,*p++) +#define NEEDBITS(j) {while(k<(j)){NEEDBYTE;b|=((uLong)NEXTBYTE)<>=(j);k-=(j);} +/* output bytes */ +#define WAVAIL (uInt)(qread?s->read-q-1:s->end-q) +#define LOADOUT {q=s->write;m=(uInt)WAVAIL;} +#define WRAP {if(q==s->end&&s->read!=s->window){q=s->window;m=(uInt)WAVAIL;}} +#define FLUSH {UPDOUT r=inflate_flush(s,z,r); LOADOUT} +#define NEEDOUT {if(m==0){WRAP if(m==0){FLUSH WRAP if(m==0) LEAVE}}r=Z_OK;} +#define OUTBYTE(a) {*q++=(Byte)(a);m--;} +/* load local pointers */ +#define LOAD {LOADIN LOADOUT} + +/* masks for lower bits (size given to avoid silly warnings with Visual C++) */ +extern uInt inflate_mask[17]; + +/* copy as much as possible from the sliding window to the output area */ +extern int inflate_flush OF(( + inflate_blocks_statef *, + z_streamp , + int)); + +struct internal_state {int dummy;}; /* for buggy compilers */ + +#endif diff --git a/stepmania/src/smpackage/ZipArchive/zlib/maketree.c b/stepmania/src/smpackage/ZipArchive/zlib/maketree.c new file mode 100644 index 0000000000..949d786418 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/zlib/maketree.c @@ -0,0 +1,85 @@ +/* maketree.c -- make inffixed.h table for decoding fixed codes + * Copyright (C) 1998 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* WARNING: this file should *not* be used by applications. It is + part of the implementation of the compression library and is + subject to change. Applications should only use zlib.h. + */ + +/* This program is included in the distribution for completeness. + You do not need to compile or run this program since inffixed.h + is already included in the distribution. To use this program + you need to compile zlib with BUILDFIXED defined and then compile + and link this program with the zlib library. Then the output of + this program can be piped to inffixed.h. */ + +#include +#include +#include "zutil.h" +#include "inftrees.h" + +/* simplify the use of the inflate_huft type with some defines */ +#define exop word.what.Exop +#define bits word.what.Bits + +/* generate initialization table for an inflate_huft structure array */ +void maketree(uInt b, inflate_huft *t) +{ + int i, e; + + i = 0; + while (1) + { + e = t[i].exop; + if (e && (e & (16+64)) == 0) /* table pointer */ + { + fprintf(stderr, "maketree: cannot initialize sub-tables!\n"); + exit(1); + } + if (i % 4 == 0) + printf("\n "); + printf(" {{{%u,%u}},%u}", t[i].exop, t[i].bits, t[i].base); + if (++i == (1< +#endif + +/* =========================================================================== + * Constants + */ + +#define MAX_BL_BITS 7 +/* Bit length codes must not exceed MAX_BL_BITS bits */ + +#define END_BLOCK 256 +/* end of block literal code */ + +#define REP_3_6 16 +/* repeat previous bit length 3-6 times (2 bits of repeat count) */ + +#define REPZ_3_10 17 +/* repeat a zero length 3-10 times (3 bits of repeat count) */ + +#define REPZ_11_138 18 +/* repeat a zero length 11-138 times (7 bits of repeat count) */ + +local const int extra_lbits[LENGTH_CODES] /* extra bits for each length code */ + = {0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0}; + +local const int extra_dbits[D_CODES] /* extra bits for each distance code */ + = {0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; + +local const int extra_blbits[BL_CODES]/* extra bits for each bit length code */ + = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7}; + +local const uch bl_order[BL_CODES] + = {16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15}; +/* The lengths of the bit length codes are sent in order of decreasing + * probability, to avoid transmitting the lengths for unused bit length codes. + */ + +#define Buf_size (8 * 2*sizeof(char)) +/* Number of bits used within bi_buf. (bi_buf might be implemented on + * more than 16 bits on some systems.) + */ + +/* =========================================================================== + * Local data. These are initialized only once. + */ + +#define DIST_CODE_LEN 512 /* see definition of array dist_code below */ + +#if defined(GEN_TREES_H) || !defined(STDC) +/* non ANSI compilers may not accept trees.h */ + +local ct_data static_ltree[L_CODES+2]; +/* The static literal tree. Since the bit lengths are imposed, there is no + * need for the L_CODES extra codes used during heap construction. However + * The codes 286 and 287 are needed to build a canonical tree (see _tr_init + * below). + */ + +local ct_data static_dtree[D_CODES]; +/* The static distance tree. (Actually a trivial tree since all codes use + * 5 bits.) + */ + +uch _dist_code[DIST_CODE_LEN]; +/* Distance codes. The first 256 values correspond to the distances + * 3 .. 258, the last 256 values correspond to the top 8 bits of + * the 15 bit distances. + */ + +uch _length_code[MAX_MATCH-MIN_MATCH+1]; +/* length code for each normalized match length (0 == MIN_MATCH) */ + +local int base_length[LENGTH_CODES]; +/* First normalized length for each code (0 = MIN_MATCH) */ + +local int base_dist[D_CODES]; +/* First normalized distance for each code (0 = distance of 1) */ + +#else +# include "trees.h" +#endif /* GEN_TREES_H */ + +struct static_tree_desc_s { + const ct_data *static_tree; /* static tree or NULL */ + const intf *extra_bits; /* extra bits for each code or NULL */ + int extra_base; /* base index for extra_bits */ + int elems; /* max number of elements in the tree */ + int max_length; /* max bit length for the codes */ +}; + +local static_tree_desc static_l_desc = +{static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS}; + +local static_tree_desc static_d_desc = +{static_dtree, extra_dbits, 0, D_CODES, MAX_BITS}; + +local static_tree_desc static_bl_desc = +{(const ct_data *)0, extra_blbits, 0, BL_CODES, MAX_BL_BITS}; + +/* =========================================================================== + * Local (static) routines in this file. + */ + +local void tr_static_init OF((void)); +local void init_block OF((deflate_state *s)); +local void pqdownheap OF((deflate_state *s, ct_data *tree, int k)); +local void gen_bitlen OF((deflate_state *s, tree_desc *desc)); +local void gen_codes OF((ct_data *tree, int max_code, ushf *bl_count)); +local void build_tree OF((deflate_state *s, tree_desc *desc)); +local void scan_tree OF((deflate_state *s, ct_data *tree, int max_code)); +local void send_tree OF((deflate_state *s, ct_data *tree, int max_code)); +local int build_bl_tree OF((deflate_state *s)); +local void send_all_trees OF((deflate_state *s, int lcodes, int dcodes, + int blcodes)); +local void compress_block OF((deflate_state *s, ct_data *ltree, + ct_data *dtree)); +local void set_data_type OF((deflate_state *s)); +local unsigned bi_reverse OF((unsigned value, int length)); +local void bi_windup OF((deflate_state *s)); +local void bi_flush OF((deflate_state *s)); +local void copy_block OF((deflate_state *s, charf *buf, unsigned len, + int header)); + +#ifdef GEN_TREES_H +local void gen_trees_header OF((void)); +#endif + +#ifndef DEBUG +# define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len) + /* Send a code of the given tree. c and tree must not have side effects */ + +#else /* DEBUG */ +# define send_code(s, c, tree) \ + { if (z_verbose>2) fprintf(stderr,"\ncd %3d ",(c)); \ + send_bits(s, tree[c].Code, tree[c].Len); } +#endif + +/* =========================================================================== + * Output a short LSB first on the stream. + * IN assertion: there is enough room in pendingBuf. + */ +#define put_short(s, w) { \ + put_byte(s, (uch)((w) & 0xff)); \ + put_byte(s, (uch)((ush)(w) >> 8)); \ +} + +/* =========================================================================== + * Send a value on a given number of bits. + * IN assertion: length <= 16 and value fits in length bits. + */ +#ifdef DEBUG +local void send_bits OF((deflate_state *s, int value, int length)); + +local void send_bits(s, value, length) + deflate_state *s; + int value; /* value to send */ + int length; /* number of bits */ +{ + Tracevv((stderr," l %2d v %4x ", length, value)); + Assert(length > 0 && length <= 15, "invalid length"); + s->bits_sent += (ulg)length; + + /* If not enough room in bi_buf, use (valid) bits from bi_buf and + * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid)) + * unused bits in value. + */ + if (s->bi_valid > (int)Buf_size - length) { + s->bi_buf |= (value << s->bi_valid); + put_short(s, s->bi_buf); + s->bi_buf = (ush)value >> (Buf_size - s->bi_valid); + s->bi_valid += length - Buf_size; + } else { + s->bi_buf |= value << s->bi_valid; + s->bi_valid += length; + } +} +#else /* !DEBUG */ + +#define send_bits(s, value, length) \ +{ int len = length;\ + if (s->bi_valid > (int)Buf_size - len) {\ + int val = value;\ + s->bi_buf |= (val << s->bi_valid);\ + put_short(s, s->bi_buf);\ + s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\ + s->bi_valid += len - Buf_size;\ + } else {\ + s->bi_buf |= (value) << s->bi_valid;\ + s->bi_valid += len;\ + }\ +} +#endif /* DEBUG */ + + +#define MAX(a,b) (a >= b ? a : b) +/* the arguments must not have side effects */ + +/* =========================================================================== + * Initialize the various 'constant' tables. + */ +local void tr_static_init() +{ +#if defined(GEN_TREES_H) || !defined(STDC) + static int static_init_done = 0; + int n; /* iterates over tree elements */ + int bits; /* bit counter */ + int length; /* length value */ + int code; /* code value */ + int dist; /* distance index */ + ush bl_count[MAX_BITS+1]; + /* number of codes at each bit length for an optimal tree */ + + if (static_init_done) return; + + /* For some embedded targets, global variables are not initialized: */ + static_l_desc.static_tree = static_ltree; + static_l_desc.extra_bits = extra_lbits; + static_d_desc.static_tree = static_dtree; + static_d_desc.extra_bits = extra_dbits; + static_bl_desc.extra_bits = extra_blbits; + + /* Initialize the mapping length (0..255) -> length code (0..28) */ + length = 0; + for (code = 0; code < LENGTH_CODES-1; code++) { + base_length[code] = length; + for (n = 0; n < (1< dist code (0..29) */ + dist = 0; + for (code = 0 ; code < 16; code++) { + base_dist[code] = dist; + for (n = 0; n < (1<>= 7; /* from now on, all distances are divided by 128 */ + for ( ; code < D_CODES; code++) { + base_dist[code] = dist << 7; + for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) { + _dist_code[256 + dist++] = (uch)code; + } + } + Assert (dist == 256, "tr_static_init: 256+dist != 512"); + + /* Construct the codes of the static literal tree */ + for (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0; + n = 0; + while (n <= 143) static_ltree[n++].Len = 8, bl_count[8]++; + while (n <= 255) static_ltree[n++].Len = 9, bl_count[9]++; + while (n <= 279) static_ltree[n++].Len = 7, bl_count[7]++; + while (n <= 287) static_ltree[n++].Len = 8, bl_count[8]++; + /* Codes 286 and 287 do not exist, but we must include them in the + * tree construction to get a canonical Huffman tree (longest code + * all ones) + */ + gen_codes((ct_data *)static_ltree, L_CODES+1, bl_count); + + /* The static distance tree is trivial: */ + for (n = 0; n < D_CODES; n++) { + static_dtree[n].Len = 5; + static_dtree[n].Code = bi_reverse((unsigned)n, 5); + } + static_init_done = 1; + +# ifdef GEN_TREES_H + gen_trees_header(); +# endif +#endif /* defined(GEN_TREES_H) || !defined(STDC) */ +} + +/* =========================================================================== + * Genererate the file trees.h describing the static trees. + */ +#ifdef GEN_TREES_H +# ifndef DEBUG +# include +# endif + +# define SEPARATOR(i, last, width) \ + ((i) == (last)? "\n};\n\n" : \ + ((i) % (width) == (width)-1 ? ",\n" : ", ")) + +void gen_trees_header() +{ + FILE *header = fopen("trees.h", "w"); + int i; + + Assert (header != NULL, "Can't open trees.h"); + fprintf(header, + "/* header created automatically with -DGEN_TREES_H */\n\n"); + + fprintf(header, "local const ct_data static_ltree[L_CODES+2] = {\n"); + for (i = 0; i < L_CODES+2; i++) { + fprintf(header, "{{%3u},{%3u}}%s", static_ltree[i].Code, + static_ltree[i].Len, SEPARATOR(i, L_CODES+1, 5)); + } + + fprintf(header, "local const ct_data static_dtree[D_CODES] = {\n"); + for (i = 0; i < D_CODES; i++) { + fprintf(header, "{{%2u},{%2u}}%s", static_dtree[i].Code, + static_dtree[i].Len, SEPARATOR(i, D_CODES-1, 5)); + } + + fprintf(header, "const uch _dist_code[DIST_CODE_LEN] = {\n"); + for (i = 0; i < DIST_CODE_LEN; i++) { + fprintf(header, "%2u%s", _dist_code[i], + SEPARATOR(i, DIST_CODE_LEN-1, 20)); + } + + fprintf(header, "const uch _length_code[MAX_MATCH-MIN_MATCH+1]= {\n"); + for (i = 0; i < MAX_MATCH-MIN_MATCH+1; i++) { + fprintf(header, "%2u%s", _length_code[i], + SEPARATOR(i, MAX_MATCH-MIN_MATCH, 20)); + } + + fprintf(header, "local const int base_length[LENGTH_CODES] = {\n"); + for (i = 0; i < LENGTH_CODES; i++) { + fprintf(header, "%1u%s", base_length[i], + SEPARATOR(i, LENGTH_CODES-1, 20)); + } + + fprintf(header, "local const int base_dist[D_CODES] = {\n"); + for (i = 0; i < D_CODES; i++) { + fprintf(header, "%5u%s", base_dist[i], + SEPARATOR(i, D_CODES-1, 10)); + } + + fclose(header); +} +#endif /* GEN_TREES_H */ + +/* =========================================================================== + * Initialize the tree data structures for a new zlib stream. + */ +void _tr_init(s) + deflate_state *s; +{ + tr_static_init(); + + s->l_desc.dyn_tree = s->dyn_ltree; + s->l_desc.stat_desc = &static_l_desc; + + s->d_desc.dyn_tree = s->dyn_dtree; + s->d_desc.stat_desc = &static_d_desc; + + s->bl_desc.dyn_tree = s->bl_tree; + s->bl_desc.stat_desc = &static_bl_desc; + + s->bi_buf = 0; + s->bi_valid = 0; + s->last_eob_len = 8; /* enough lookahead for inflate */ +#ifdef DEBUG + s->compressed_len = 0L; + s->bits_sent = 0L; +#endif + + /* Initialize the first block of the first file: */ + init_block(s); +} + +/* =========================================================================== + * Initialize a new block. + */ +local void init_block(s) + deflate_state *s; +{ + int n; /* iterates over tree elements */ + + /* Initialize the trees. */ + for (n = 0; n < L_CODES; n++) s->dyn_ltree[n].Freq = 0; + for (n = 0; n < D_CODES; n++) s->dyn_dtree[n].Freq = 0; + for (n = 0; n < BL_CODES; n++) s->bl_tree[n].Freq = 0; + + s->dyn_ltree[END_BLOCK].Freq = 1; + s->opt_len = s->static_len = 0L; + s->last_lit = s->matches = 0; +} + +#define SMALLEST 1 +/* Index within the heap array of least frequent node in the Huffman tree */ + + +/* =========================================================================== + * Remove the smallest element from the heap and recreate the heap with + * one less element. Updates heap and heap_len. + */ +#define pqremove(s, tree, top) \ +{\ + top = s->heap[SMALLEST]; \ + s->heap[SMALLEST] = s->heap[s->heap_len--]; \ + pqdownheap(s, tree, SMALLEST); \ +} + +/* =========================================================================== + * Compares to subtrees, using the tree depth as tie breaker when + * the subtrees have equal frequency. This minimizes the worst case length. + */ +#define smaller(tree, n, m, depth) \ + (tree[n].Freq < tree[m].Freq || \ + (tree[n].Freq == tree[m].Freq && depth[n] <= depth[m])) + +/* =========================================================================== + * Restore the heap property by moving down the tree starting at node k, + * exchanging a node with the smallest of its two sons if necessary, stopping + * when the heap property is re-established (each father smaller than its + * two sons). + */ +local void pqdownheap(s, tree, k) + deflate_state *s; + ct_data *tree; /* the tree to restore */ + int k; /* node to move down */ +{ + int v = s->heap[k]; + int j = k << 1; /* left son of k */ + while (j <= s->heap_len) { + /* Set j to the smallest of the two sons: */ + if (j < s->heap_len && + smaller(tree, s->heap[j+1], s->heap[j], s->depth)) { + j++; + } + /* Exit if v is smaller than both sons */ + if (smaller(tree, v, s->heap[j], s->depth)) break; + + /* Exchange v with the smallest son */ + s->heap[k] = s->heap[j]; k = j; + + /* And continue down the tree, setting j to the left son of k */ + j <<= 1; + } + s->heap[k] = v; +} + +/* =========================================================================== + * Compute the optimal bit lengths for a tree and update the total bit length + * for the current block. + * IN assertion: the fields freq and dad are set, heap[heap_max] and + * above are the tree nodes sorted by increasing frequency. + * OUT assertions: the field len is set to the optimal bit length, the + * array bl_count contains the frequencies for each bit length. + * The length opt_len is updated; static_len is also updated if stree is + * not null. + */ +local void gen_bitlen(s, desc) + deflate_state *s; + tree_desc *desc; /* the tree descriptor */ +{ + ct_data *tree = desc->dyn_tree; + int max_code = desc->max_code; + const ct_data *stree = desc->stat_desc->static_tree; + const intf *extra = desc->stat_desc->extra_bits; + int base = desc->stat_desc->extra_base; + int max_length = desc->stat_desc->max_length; + int h; /* heap index */ + int n, m; /* iterate over the tree elements */ + int bits; /* bit length */ + int xbits; /* extra bits */ + ush f; /* frequency */ + int overflow = 0; /* number of elements with bit length too large */ + + for (bits = 0; bits <= MAX_BITS; bits++) s->bl_count[bits] = 0; + + /* In a first pass, compute the optimal bit lengths (which may + * overflow in the case of the bit length tree). + */ + tree[s->heap[s->heap_max]].Len = 0; /* root of the heap */ + + for (h = s->heap_max+1; h < HEAP_SIZE; h++) { + n = s->heap[h]; + bits = tree[tree[n].Dad].Len + 1; + if (bits > max_length) bits = max_length, overflow++; + tree[n].Len = (ush)bits; + /* We overwrite tree[n].Dad which is no longer needed */ + + if (n > max_code) continue; /* not a leaf node */ + + s->bl_count[bits]++; + xbits = 0; + if (n >= base) xbits = extra[n-base]; + f = tree[n].Freq; + s->opt_len += (ulg)f * (bits + xbits); + if (stree) s->static_len += (ulg)f * (stree[n].Len + xbits); + } + if (overflow == 0) return; + + Trace((stderr,"\nbit length overflow\n")); + /* This happens for example on obj2 and pic of the Calgary corpus */ + + /* Find the first bit length which could increase: */ + do { + bits = max_length-1; + while (s->bl_count[bits] == 0) bits--; + s->bl_count[bits]--; /* move one leaf down the tree */ + s->bl_count[bits+1] += 2; /* move one overflow item as its brother */ + s->bl_count[max_length]--; + /* The brother of the overflow item also moves one step up, + * but this does not affect bl_count[max_length] + */ + overflow -= 2; + } while (overflow > 0); + + /* Now recompute all bit lengths, scanning in increasing frequency. + * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all + * lengths instead of fixing only the wrong ones. This idea is taken + * from 'ar' written by Haruhiko Okumura.) + */ + for (bits = max_length; bits != 0; bits--) { + n = s->bl_count[bits]; + while (n != 0) { + m = s->heap[--h]; + if (m > max_code) continue; + if (tree[m].Len != (unsigned) bits) { + Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits)); + s->opt_len += ((long)bits - (long)tree[m].Len) + *(long)tree[m].Freq; + tree[m].Len = (ush)bits; + } + n--; + } + } +} + +/* =========================================================================== + * Generate the codes for a given tree and bit counts (which need not be + * optimal). + * IN assertion: the array bl_count contains the bit length statistics for + * the given tree and the field len is set for all tree elements. + * OUT assertion: the field code is set for all tree elements of non + * zero code length. + */ +local void gen_codes (tree, max_code, bl_count) + ct_data *tree; /* the tree to decorate */ + int max_code; /* largest code with non zero frequency */ + ushf *bl_count; /* number of codes at each bit length */ +{ + ush next_code[MAX_BITS+1]; /* next code value for each bit length */ + ush code = 0; /* running code value */ + int bits; /* bit index */ + int n; /* code index */ + + /* The distribution counts are first used to generate the code values + * without bit reversal. + */ + for (bits = 1; bits <= MAX_BITS; bits++) { + next_code[bits] = code = (code + bl_count[bits-1]) << 1; + } + /* Check that the bit counts in bl_count are consistent. The last code + * must be all ones. + */ + Assert (code + bl_count[MAX_BITS]-1 == (1<dyn_tree; + const ct_data *stree = desc->stat_desc->static_tree; + int elems = desc->stat_desc->elems; + int n, m; /* iterate over heap elements */ + int max_code = -1; /* largest code with non zero frequency */ + int node; /* new node being created */ + + /* Construct the initial heap, with least frequent element in + * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1]. + * heap[0] is not used. + */ + s->heap_len = 0, s->heap_max = HEAP_SIZE; + + for (n = 0; n < elems; n++) { + if (tree[n].Freq != 0) { + s->heap[++(s->heap_len)] = max_code = n; + s->depth[n] = 0; + } else { + tree[n].Len = 0; + } + } + + /* The pkzip format requires that at least one distance code exists, + * and that at least one bit should be sent even if there is only one + * possible code. So to avoid special checks later on we force at least + * two codes of non zero frequency. + */ + while (s->heap_len < 2) { + node = s->heap[++(s->heap_len)] = (max_code < 2 ? ++max_code : 0); + tree[node].Freq = 1; + s->depth[node] = 0; + s->opt_len--; if (stree) s->static_len -= stree[node].Len; + /* node is 0 or 1 so it does not have extra bits */ + } + desc->max_code = max_code; + + /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree, + * establish sub-heaps of increasing lengths: + */ + for (n = s->heap_len/2; n >= 1; n--) pqdownheap(s, tree, n); + + /* Construct the Huffman tree by repeatedly combining the least two + * frequent nodes. + */ + node = elems; /* next internal node of the tree */ + do { + pqremove(s, tree, n); /* n = node of least frequency */ + m = s->heap[SMALLEST]; /* m = node of next least frequency */ + + s->heap[--(s->heap_max)] = n; /* keep the nodes sorted by frequency */ + s->heap[--(s->heap_max)] = m; + + /* Create a new node father of n and m */ + tree[node].Freq = tree[n].Freq + tree[m].Freq; + s->depth[node] = (uch) (MAX(s->depth[n], s->depth[m]) + 1); + tree[n].Dad = tree[m].Dad = (ush)node; +#ifdef DUMP_BL_TREE + if (tree == s->bl_tree) { + fprintf(stderr,"\nnode %d(%d), sons %d(%d) %d(%d)", + node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq); + } +#endif + /* and insert the new node in the heap */ + s->heap[SMALLEST] = node++; + pqdownheap(s, tree, SMALLEST); + + } while (s->heap_len >= 2); + + s->heap[--(s->heap_max)] = s->heap[SMALLEST]; + + /* At this point, the fields freq and dad are set. We can now + * generate the bit lengths. + */ + gen_bitlen(s, (tree_desc *)desc); + + /* The field len is now set, we can generate the bit codes */ + gen_codes ((ct_data *)tree, max_code, s->bl_count); +} + +/* =========================================================================== + * Scan a literal or distance tree to determine the frequencies of the codes + * in the bit length tree. + */ +local void scan_tree (s, tree, max_code) + deflate_state *s; + ct_data *tree; /* the tree to be scanned */ + int max_code; /* and its largest code of non zero frequency */ +{ + int n; /* iterates over all tree elements */ + int prevlen = -1; /* last emitted length */ + int curlen; /* length of current code */ + int nextlen = tree[0].Len; /* length of next code */ + int count = 0; /* repeat count of the current code */ + int max_count = 7; /* max repeat count */ + int min_count = 4; /* min repeat count */ + + if (nextlen == 0) max_count = 138, min_count = 3; + tree[max_code+1].Len = (ush)0xffff; /* guard */ + + for (n = 0; n <= max_code; n++) { + curlen = nextlen; nextlen = tree[n+1].Len; + if (++count < max_count && curlen == nextlen) { + continue; + } else if (count < min_count) { + s->bl_tree[curlen].Freq += count; + } else if (curlen != 0) { + if (curlen != prevlen) s->bl_tree[curlen].Freq++; + s->bl_tree[REP_3_6].Freq++; + } else if (count <= 10) { + s->bl_tree[REPZ_3_10].Freq++; + } else { + s->bl_tree[REPZ_11_138].Freq++; + } + count = 0; prevlen = curlen; + if (nextlen == 0) { + max_count = 138, min_count = 3; + } else if (curlen == nextlen) { + max_count = 6, min_count = 3; + } else { + max_count = 7, min_count = 4; + } + } +} + +/* =========================================================================== + * Send a literal or distance tree in compressed form, using the codes in + * bl_tree. + */ +local void send_tree (s, tree, max_code) + deflate_state *s; + ct_data *tree; /* the tree to be scanned */ + int max_code; /* and its largest code of non zero frequency */ +{ + int n; /* iterates over all tree elements */ + int prevlen = -1; /* last emitted length */ + int curlen; /* length of current code */ + int nextlen = tree[0].Len; /* length of next code */ + int count = 0; /* repeat count of the current code */ + int max_count = 7; /* max repeat count */ + int min_count = 4; /* min repeat count */ + + /* tree[max_code+1].Len = -1; */ /* guard already set */ + if (nextlen == 0) max_count = 138, min_count = 3; + + for (n = 0; n <= max_code; n++) { + curlen = nextlen; nextlen = tree[n+1].Len; + if (++count < max_count && curlen == nextlen) { + continue; + } else if (count < min_count) { + do { send_code(s, curlen, s->bl_tree); } while (--count != 0); + + } else if (curlen != 0) { + if (curlen != prevlen) { + send_code(s, curlen, s->bl_tree); count--; + } + Assert(count >= 3 && count <= 6, " 3_6?"); + send_code(s, REP_3_6, s->bl_tree); send_bits(s, count-3, 2); + + } else if (count <= 10) { + send_code(s, REPZ_3_10, s->bl_tree); send_bits(s, count-3, 3); + + } else { + send_code(s, REPZ_11_138, s->bl_tree); send_bits(s, count-11, 7); + } + count = 0; prevlen = curlen; + if (nextlen == 0) { + max_count = 138, min_count = 3; + } else if (curlen == nextlen) { + max_count = 6, min_count = 3; + } else { + max_count = 7, min_count = 4; + } + } +} + +/* =========================================================================== + * Construct the Huffman tree for the bit lengths and return the index in + * bl_order of the last bit length code to send. + */ +local int build_bl_tree(s) + deflate_state *s; +{ + int max_blindex; /* index of last bit length code of non zero freq */ + + /* Determine the bit length frequencies for literal and distance trees */ + scan_tree(s, (ct_data *)s->dyn_ltree, s->l_desc.max_code); + scan_tree(s, (ct_data *)s->dyn_dtree, s->d_desc.max_code); + + /* Build the bit length tree: */ + build_tree(s, (tree_desc *)(&(s->bl_desc))); + /* opt_len now includes the length of the tree representations, except + * the lengths of the bit lengths codes and the 5+5+4 bits for the counts. + */ + + /* Determine the number of bit length codes to send. The pkzip format + * requires that at least 4 bit length codes be sent. (appnote.txt says + * 3 but the actual value used is 4.) + */ + for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) { + if (s->bl_tree[bl_order[max_blindex]].Len != 0) break; + } + /* Update opt_len to include the bit length tree and counts */ + s->opt_len += 3*(max_blindex+1) + 5+5+4; + Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld", + s->opt_len, s->static_len)); + + return max_blindex; +} + +/* =========================================================================== + * Send the header for a block using dynamic Huffman trees: the counts, the + * lengths of the bit length codes, the literal tree and the distance tree. + * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4. + */ +local void send_all_trees(s, lcodes, dcodes, blcodes) + deflate_state *s; + int lcodes, dcodes, blcodes; /* number of codes for each tree */ +{ + int rank; /* index in bl_order */ + + Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes"); + Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES, + "too many codes"); + Tracev((stderr, "\nbl counts: ")); + send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */ + send_bits(s, dcodes-1, 5); + send_bits(s, blcodes-4, 4); /* not -3 as stated in appnote.txt */ + for (rank = 0; rank < blcodes; rank++) { + Tracev((stderr, "\nbl code %2d ", bl_order[rank])); + send_bits(s, s->bl_tree[bl_order[rank]].Len, 3); + } + Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent)); + + send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1); /* literal tree */ + Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent)); + + send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1); /* distance tree */ + Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent)); +} + +/* =========================================================================== + * Send a stored block + */ +void _tr_stored_block(s, buf, stored_len, eof) + deflate_state *s; + charf *buf; /* input block */ + ulg stored_len; /* length of input block */ + int eof; /* true if this is the last block for a file */ +{ + send_bits(s, (STORED_BLOCK<<1)+eof, 3); /* send block type */ +#ifdef DEBUG + s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L; + s->compressed_len += (stored_len + 4) << 3; +#endif + copy_block(s, buf, (unsigned)stored_len, 1); /* with header */ +} + +/* =========================================================================== + * Send one empty static block to give enough lookahead for inflate. + * This takes 10 bits, of which 7 may remain in the bit buffer. + * The current inflate code requires 9 bits of lookahead. If the + * last two codes for the previous block (real code plus EOB) were coded + * on 5 bits or less, inflate may have only 5+3 bits of lookahead to decode + * the last real code. In this case we send two empty static blocks instead + * of one. (There are no problems if the previous block is stored or fixed.) + * To simplify the code, we assume the worst case of last real code encoded + * on one bit only. + */ +void _tr_align(s) + deflate_state *s; +{ + send_bits(s, STATIC_TREES<<1, 3); + send_code(s, END_BLOCK, static_ltree); +#ifdef DEBUG + s->compressed_len += 10L; /* 3 for block type, 7 for EOB */ +#endif + bi_flush(s); + /* Of the 10 bits for the empty block, we have already sent + * (10 - bi_valid) bits. The lookahead for the last real code (before + * the EOB of the previous block) was thus at least one plus the length + * of the EOB plus what we have just sent of the empty static block. + */ + if (1 + s->last_eob_len + 10 - s->bi_valid < 9) { + send_bits(s, STATIC_TREES<<1, 3); + send_code(s, END_BLOCK, static_ltree); +#ifdef DEBUG + s->compressed_len += 10L; +#endif + bi_flush(s); + } + s->last_eob_len = 7; +} + +/* =========================================================================== + * Determine the best encoding for the current block: dynamic trees, static + * trees or store, and output the encoded block to the zip file. + */ +void _tr_flush_block(s, buf, stored_len, eof) + deflate_state *s; + charf *buf; /* input block, or NULL if too old */ + ulg stored_len; /* length of input block */ + int eof; /* true if this is the last block for a file */ +{ + ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */ + int max_blindex = 0; /* index of last bit length code of non zero freq */ + + /* Build the Huffman trees unless a stored block is forced */ + if (s->level > 0) { + + /* Check if the file is ascii or binary */ + if (s->data_type == Z_UNKNOWN) set_data_type(s); + + /* Construct the literal and distance trees */ + build_tree(s, (tree_desc *)(&(s->l_desc))); + Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len, + s->static_len)); + + build_tree(s, (tree_desc *)(&(s->d_desc))); + Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len, + s->static_len)); + /* At this point, opt_len and static_len are the total bit lengths of + * the compressed block data, excluding the tree representations. + */ + + /* Build the bit length tree for the above two trees, and get the index + * in bl_order of the last bit length code to send. + */ + max_blindex = build_bl_tree(s); + + /* Determine the best encoding. Compute first the block length in bytes*/ + opt_lenb = (s->opt_len+3+7)>>3; + static_lenb = (s->static_len+3+7)>>3; + + Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ", + opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len, + s->last_lit)); + + if (static_lenb <= opt_lenb) opt_lenb = static_lenb; + + } else { + Assert(buf != (char*)0, "lost buf"); + opt_lenb = static_lenb = stored_len + 5; /* force a stored block */ + } + +#ifdef FORCE_STORED + if (buf != (char*)0) { /* force stored block */ +#else + if (stored_len+4 <= opt_lenb && buf != (char*)0) { + /* 4: two words for the lengths */ +#endif + /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE. + * Otherwise we can't have processed more than WSIZE input bytes since + * the last block flush, because compression would have been + * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to + * transform a block into a stored block. + */ + _tr_stored_block(s, buf, stored_len, eof); + +#ifdef FORCE_STATIC + } else if (static_lenb >= 0) { /* force static trees */ +#else + } else if (static_lenb == opt_lenb) { +#endif + send_bits(s, (STATIC_TREES<<1)+eof, 3); + compress_block(s, (ct_data *)static_ltree, (ct_data *)static_dtree); +#ifdef DEBUG + s->compressed_len += 3 + s->static_len; +#endif + } else { + send_bits(s, (DYN_TREES<<1)+eof, 3); + send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1, + max_blindex+1); + compress_block(s, (ct_data *)s->dyn_ltree, (ct_data *)s->dyn_dtree); +#ifdef DEBUG + s->compressed_len += 3 + s->opt_len; +#endif + } + Assert (s->compressed_len == s->bits_sent, "bad compressed size"); + /* The above check is made mod 2^32, for files larger than 512 MB + * and uLong implemented on 32 bits. + */ + init_block(s); + + if (eof) { + bi_windup(s); +#ifdef DEBUG + s->compressed_len += 7; /* align on byte boundary */ +#endif + } + Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3, + s->compressed_len-7*eof)); +} + +/* =========================================================================== + * Save the match info and tally the frequency counts. Return true if + * the current block must be flushed. + */ +int _tr_tally (s, dist, lc) + deflate_state *s; + unsigned dist; /* distance of matched string */ + unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */ +{ + s->d_buf[s->last_lit] = (ush)dist; + s->l_buf[s->last_lit++] = (uch)lc; + if (dist == 0) { + /* lc is the unmatched char */ + s->dyn_ltree[lc].Freq++; + } else { + s->matches++; + /* Here, lc is the match length - MIN_MATCH */ + dist--; /* dist = match distance - 1 */ + Assert((ush)dist < (ush)MAX_DIST(s) && + (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) && + (ush)d_code(dist) < (ush)D_CODES, "_tr_tally: bad match"); + + s->dyn_ltree[_length_code[lc]+LITERALS+1].Freq++; + s->dyn_dtree[d_code(dist)].Freq++; + } + +#ifdef TRUNCATE_BLOCK + /* Try to guess if it is profitable to stop the current block here */ + if ((s->last_lit & 0x1fff) == 0 && s->level > 2) { + /* Compute an upper bound for the compressed length */ + ulg out_length = (ulg)s->last_lit*8L; + ulg in_length = (ulg)((long)s->strstart - s->block_start); + int dcode; + for (dcode = 0; dcode < D_CODES; dcode++) { + out_length += (ulg)s->dyn_dtree[dcode].Freq * + (5L+extra_dbits[dcode]); + } + out_length >>= 3; + Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ", + s->last_lit, in_length, out_length, + 100L - out_length*100L/in_length)); + if (s->matches < s->last_lit/2 && out_length < in_length/2) return 1; + } +#endif + return (s->last_lit == s->lit_bufsize-1); + /* We avoid equality with lit_bufsize because of wraparound at 64K + * on 16 bit machines and because stored blocks are restricted to + * 64K-1 bytes. + */ +} + +/* =========================================================================== + * Send the block data compressed using the given Huffman trees + */ +local void compress_block(s, ltree, dtree) + deflate_state *s; + ct_data *ltree; /* literal tree */ + ct_data *dtree; /* distance tree */ +{ + unsigned dist; /* distance of matched string */ + int lc; /* match length or unmatched char (if dist == 0) */ + unsigned lx = 0; /* running index in l_buf */ + unsigned code; /* the code to send */ + int extra; /* number of extra bits to send */ + + if (s->last_lit != 0) do { + dist = s->d_buf[lx]; + lc = s->l_buf[lx++]; + if (dist == 0) { + send_code(s, lc, ltree); /* send a literal byte */ + Tracecv(isgraph(lc), (stderr," '%c' ", lc)); + } else { + /* Here, lc is the match length - MIN_MATCH */ + code = _length_code[lc]; + send_code(s, code+LITERALS+1, ltree); /* send the length code */ + extra = extra_lbits[code]; + if (extra != 0) { + lc -= base_length[code]; + send_bits(s, lc, extra); /* send the extra length bits */ + } + dist--; /* dist is now the match distance - 1 */ + code = d_code(dist); + Assert (code < D_CODES, "bad d_code"); + + send_code(s, code, dtree); /* send the distance code */ + extra = extra_dbits[code]; + if (extra != 0) { + dist -= base_dist[code]; + send_bits(s, dist, extra); /* send the extra distance bits */ + } + } /* literal or match pair ? */ + + /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */ + Assert(s->pending < s->lit_bufsize + 2*lx, "pendingBuf overflow"); + + } while (lx < s->last_lit); + + send_code(s, END_BLOCK, ltree); + s->last_eob_len = ltree[END_BLOCK].Len; +} + +/* =========================================================================== + * Set the data type to ASCII or BINARY, using a crude approximation: + * binary if more than 20% of the bytes are <= 6 or >= 128, ascii otherwise. + * IN assertion: the fields freq of dyn_ltree are set and the total of all + * frequencies does not exceed 64K (to fit in an int on 16 bit machines). + */ +local void set_data_type(s) + deflate_state *s; +{ + int n = 0; + unsigned ascii_freq = 0; + unsigned bin_freq = 0; + while (n < 7) bin_freq += s->dyn_ltree[n++].Freq; + while (n < 128) ascii_freq += s->dyn_ltree[n++].Freq; + while (n < LITERALS) bin_freq += s->dyn_ltree[n++].Freq; + s->data_type = (Byte)(bin_freq > (ascii_freq >> 2) ? Z_BINARY : Z_ASCII); +} + +/* =========================================================================== + * Reverse the first len bits of a code, using straightforward code (a faster + * method would use a table) + * IN assertion: 1 <= len <= 15 + */ +local unsigned bi_reverse(code, len) + unsigned code; /* the value to invert */ + int len; /* its bit length */ +{ + register unsigned res = 0; + do { + res |= code & 1; + code >>= 1, res <<= 1; + } while (--len > 0); + return res >> 1; +} + +/* =========================================================================== + * Flush the bit buffer, keeping at most 7 bits in it. + */ +local void bi_flush(s) + deflate_state *s; +{ + if (s->bi_valid == 16) { + put_short(s, s->bi_buf); + s->bi_buf = 0; + s->bi_valid = 0; + } else if (s->bi_valid >= 8) { + put_byte(s, (Byte)s->bi_buf); + s->bi_buf >>= 8; + s->bi_valid -= 8; + } +} + +/* =========================================================================== + * Flush the bit buffer and align the output on a byte boundary + */ +local void bi_windup(s) + deflate_state *s; +{ + if (s->bi_valid > 8) { + put_short(s, s->bi_buf); + } else if (s->bi_valid > 0) { + put_byte(s, (Byte)s->bi_buf); + } + s->bi_buf = 0; + s->bi_valid = 0; +#ifdef DEBUG + s->bits_sent = (s->bits_sent+7) & ~7; +#endif +} + +/* =========================================================================== + * Copy a stored block, storing first the length and its + * one's complement if requested. + */ +local void copy_block(s, buf, len, header) + deflate_state *s; + charf *buf; /* the input data */ + unsigned len; /* its length */ + int header; /* true if block header must be written */ +{ + bi_windup(s); /* align on byte boundary */ + s->last_eob_len = 8; /* enough lookahead for inflate */ + + if (header) { + put_short(s, (ush)len); + put_short(s, (ush)~len); +#ifdef DEBUG + s->bits_sent += 2*16; +#endif + } +#ifdef DEBUG + s->bits_sent += (ulg)len<<3; +#endif + while (len--) { + put_byte(s, *buf++); + } +} diff --git a/stepmania/src/smpackage/ZipArchive/zlib/trees.h b/stepmania/src/smpackage/ZipArchive/zlib/trees.h new file mode 100644 index 0000000000..72facf900f --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/zlib/trees.h @@ -0,0 +1,128 @@ +/* header created automatically with -DGEN_TREES_H */ + +local const ct_data static_ltree[L_CODES+2] = { +{{ 12},{ 8}}, {{140},{ 8}}, {{ 76},{ 8}}, {{204},{ 8}}, {{ 44},{ 8}}, +{{172},{ 8}}, {{108},{ 8}}, {{236},{ 8}}, {{ 28},{ 8}}, {{156},{ 8}}, +{{ 92},{ 8}}, {{220},{ 8}}, {{ 60},{ 8}}, {{188},{ 8}}, {{124},{ 8}}, +{{252},{ 8}}, {{ 2},{ 8}}, {{130},{ 8}}, {{ 66},{ 8}}, {{194},{ 8}}, +{{ 34},{ 8}}, {{162},{ 8}}, {{ 98},{ 8}}, {{226},{ 8}}, {{ 18},{ 8}}, +{{146},{ 8}}, {{ 82},{ 8}}, {{210},{ 8}}, {{ 50},{ 8}}, {{178},{ 8}}, +{{114},{ 8}}, {{242},{ 8}}, {{ 10},{ 8}}, {{138},{ 8}}, {{ 74},{ 8}}, +{{202},{ 8}}, {{ 42},{ 8}}, {{170},{ 8}}, {{106},{ 8}}, {{234},{ 8}}, +{{ 26},{ 8}}, {{154},{ 8}}, {{ 90},{ 8}}, {{218},{ 8}}, {{ 58},{ 8}}, +{{186},{ 8}}, {{122},{ 8}}, {{250},{ 8}}, {{ 6},{ 8}}, {{134},{ 8}}, +{{ 70},{ 8}}, {{198},{ 8}}, {{ 38},{ 8}}, {{166},{ 8}}, {{102},{ 8}}, +{{230},{ 8}}, {{ 22},{ 8}}, {{150},{ 8}}, {{ 86},{ 8}}, {{214},{ 8}}, +{{ 54},{ 8}}, {{182},{ 8}}, {{118},{ 8}}, {{246},{ 8}}, {{ 14},{ 8}}, +{{142},{ 8}}, {{ 78},{ 8}}, {{206},{ 8}}, {{ 46},{ 8}}, {{174},{ 8}}, +{{110},{ 8}}, {{238},{ 8}}, {{ 30},{ 8}}, {{158},{ 8}}, {{ 94},{ 8}}, +{{222},{ 8}}, {{ 62},{ 8}}, {{190},{ 8}}, {{126},{ 8}}, {{254},{ 8}}, +{{ 1},{ 8}}, {{129},{ 8}}, {{ 65},{ 8}}, {{193},{ 8}}, {{ 33},{ 8}}, +{{161},{ 8}}, {{ 97},{ 8}}, {{225},{ 8}}, {{ 17},{ 8}}, {{145},{ 8}}, +{{ 81},{ 8}}, {{209},{ 8}}, {{ 49},{ 8}}, {{177},{ 8}}, {{113},{ 8}}, +{{241},{ 8}}, {{ 9},{ 8}}, {{137},{ 8}}, {{ 73},{ 8}}, {{201},{ 8}}, +{{ 41},{ 8}}, {{169},{ 8}}, {{105},{ 8}}, {{233},{ 8}}, {{ 25},{ 8}}, +{{153},{ 8}}, {{ 89},{ 8}}, {{217},{ 8}}, {{ 57},{ 8}}, {{185},{ 8}}, +{{121},{ 8}}, {{249},{ 8}}, {{ 5},{ 8}}, {{133},{ 8}}, {{ 69},{ 8}}, +{{197},{ 8}}, {{ 37},{ 8}}, {{165},{ 8}}, {{101},{ 8}}, {{229},{ 8}}, +{{ 21},{ 8}}, {{149},{ 8}}, {{ 85},{ 8}}, {{213},{ 8}}, {{ 53},{ 8}}, +{{181},{ 8}}, {{117},{ 8}}, {{245},{ 8}}, {{ 13},{ 8}}, {{141},{ 8}}, +{{ 77},{ 8}}, {{205},{ 8}}, {{ 45},{ 8}}, {{173},{ 8}}, {{109},{ 8}}, +{{237},{ 8}}, {{ 29},{ 8}}, {{157},{ 8}}, {{ 93},{ 8}}, {{221},{ 8}}, +{{ 61},{ 8}}, {{189},{ 8}}, {{125},{ 8}}, {{253},{ 8}}, {{ 19},{ 9}}, +{{275},{ 9}}, {{147},{ 9}}, {{403},{ 9}}, {{ 83},{ 9}}, {{339},{ 9}}, +{{211},{ 9}}, {{467},{ 9}}, {{ 51},{ 9}}, {{307},{ 9}}, {{179},{ 9}}, +{{435},{ 9}}, {{115},{ 9}}, {{371},{ 9}}, {{243},{ 9}}, {{499},{ 9}}, +{{ 11},{ 9}}, {{267},{ 9}}, {{139},{ 9}}, {{395},{ 9}}, {{ 75},{ 9}}, +{{331},{ 9}}, {{203},{ 9}}, {{459},{ 9}}, {{ 43},{ 9}}, {{299},{ 9}}, +{{171},{ 9}}, {{427},{ 9}}, {{107},{ 9}}, {{363},{ 9}}, {{235},{ 9}}, +{{491},{ 9}}, {{ 27},{ 9}}, {{283},{ 9}}, {{155},{ 9}}, {{411},{ 9}}, +{{ 91},{ 9}}, {{347},{ 9}}, {{219},{ 9}}, {{475},{ 9}}, {{ 59},{ 9}}, +{{315},{ 9}}, {{187},{ 9}}, {{443},{ 9}}, {{123},{ 9}}, {{379},{ 9}}, +{{251},{ 9}}, {{507},{ 9}}, {{ 7},{ 9}}, {{263},{ 9}}, {{135},{ 9}}, +{{391},{ 9}}, {{ 71},{ 9}}, {{327},{ 9}}, {{199},{ 9}}, {{455},{ 9}}, +{{ 39},{ 9}}, {{295},{ 9}}, {{167},{ 9}}, {{423},{ 9}}, {{103},{ 9}}, +{{359},{ 9}}, {{231},{ 9}}, {{487},{ 9}}, {{ 23},{ 9}}, {{279},{ 9}}, +{{151},{ 9}}, {{407},{ 9}}, {{ 87},{ 9}}, {{343},{ 9}}, {{215},{ 9}}, +{{471},{ 9}}, {{ 55},{ 9}}, {{311},{ 9}}, {{183},{ 9}}, {{439},{ 9}}, +{{119},{ 9}}, {{375},{ 9}}, {{247},{ 9}}, {{503},{ 9}}, {{ 15},{ 9}}, +{{271},{ 9}}, {{143},{ 9}}, {{399},{ 9}}, {{ 79},{ 9}}, {{335},{ 9}}, +{{207},{ 9}}, {{463},{ 9}}, {{ 47},{ 9}}, {{303},{ 9}}, {{175},{ 9}}, +{{431},{ 9}}, {{111},{ 9}}, {{367},{ 9}}, {{239},{ 9}}, {{495},{ 9}}, +{{ 31},{ 9}}, {{287},{ 9}}, {{159},{ 9}}, {{415},{ 9}}, {{ 95},{ 9}}, +{{351},{ 9}}, {{223},{ 9}}, {{479},{ 9}}, {{ 63},{ 9}}, {{319},{ 9}}, +{{191},{ 9}}, {{447},{ 9}}, {{127},{ 9}}, {{383},{ 9}}, {{255},{ 9}}, +{{511},{ 9}}, {{ 0},{ 7}}, {{ 64},{ 7}}, {{ 32},{ 7}}, {{ 96},{ 7}}, +{{ 16},{ 7}}, {{ 80},{ 7}}, {{ 48},{ 7}}, {{112},{ 7}}, {{ 8},{ 7}}, +{{ 72},{ 7}}, {{ 40},{ 7}}, {{104},{ 7}}, {{ 24},{ 7}}, {{ 88},{ 7}}, +{{ 56},{ 7}}, {{120},{ 7}}, {{ 4},{ 7}}, {{ 68},{ 7}}, {{ 36},{ 7}}, +{{100},{ 7}}, {{ 20},{ 7}}, {{ 84},{ 7}}, {{ 52},{ 7}}, {{116},{ 7}}, +{{ 3},{ 8}}, {{131},{ 8}}, {{ 67},{ 8}}, {{195},{ 8}}, {{ 35},{ 8}}, +{{163},{ 8}}, {{ 99},{ 8}}, {{227},{ 8}} +}; + +local const ct_data static_dtree[D_CODES] = { +{{ 0},{ 5}}, {{16},{ 5}}, {{ 8},{ 5}}, {{24},{ 5}}, {{ 4},{ 5}}, +{{20},{ 5}}, {{12},{ 5}}, {{28},{ 5}}, {{ 2},{ 5}}, {{18},{ 5}}, +{{10},{ 5}}, {{26},{ 5}}, {{ 6},{ 5}}, {{22},{ 5}}, {{14},{ 5}}, +{{30},{ 5}}, {{ 1},{ 5}}, {{17},{ 5}}, {{ 9},{ 5}}, {{25},{ 5}}, +{{ 5},{ 5}}, {{21},{ 5}}, {{13},{ 5}}, {{29},{ 5}}, {{ 3},{ 5}}, +{{19},{ 5}}, {{11},{ 5}}, {{27},{ 5}}, {{ 7},{ 5}}, {{23},{ 5}} +}; + +const uch _dist_code[DIST_CODE_LEN] = { + 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, + 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, +10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, +11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, +12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, +13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, +13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, +14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, +14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, +14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, +15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, +15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, +15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 16, 17, +18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, +23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, +27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, +28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, +28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, +28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, +29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, +29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, +29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29 +}; + +const uch _length_code[MAX_MATCH-MIN_MATCH+1]= { + 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12, 12, +13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, +17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, +19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, +21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, +22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, +23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, +25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28 +}; + +local const int base_length[LENGTH_CODES] = { +0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56, +64, 80, 96, 112, 128, 160, 192, 224, 0 +}; + +local const int base_dist[D_CODES] = { + 0, 1, 2, 3, 4, 6, 8, 12, 16, 24, + 32, 48, 64, 96, 128, 192, 256, 384, 512, 768, + 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576 +}; + diff --git a/stepmania/src/smpackage/ZipArchive/zlib/uncompr.c b/stepmania/src/smpackage/ZipArchive/zlib/uncompr.c new file mode 100644 index 0000000000..0de78128f4 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/zlib/uncompr.c @@ -0,0 +1,57 @@ +/* uncompr.c -- decompress a memory buffer + * Copyright (C) 1995-1998 Jean-loup Gailly. + * For conditions of distribution and use, see copyright notice in zlib.h + */ + + +#include "zlib.h" + +/* =========================================================================== + Decompresses the source buffer into the destination buffer. sourceLen is + the byte length of the source buffer. Upon entry, destLen is the total + size of the destination buffer, which must be large enough to hold the + entire uncompressed data. (The size of the uncompressed data must have + been saved previously by the compressor and transmitted to the decompressor + by some mechanism outside the scope of this compression library.) + Upon exit, destLen is the actual size of the compressed buffer. + This function can be used to decompress a whole file at once if the + input file is mmap'ed. + + uncompress returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_BUF_ERROR if there was not enough room in the output + buffer, or Z_DATA_ERROR if the input data was corrupted. +*/ +int ZEXPORT uncompress (dest, destLen, source, sourceLen) + Bytef *dest; + uLongf *destLen; + const Bytef *source; + uLong sourceLen; +{ + z_stream stream; + int err; + + stream.next_in = (Bytef*)source; + stream.avail_in = (uInt)sourceLen; + /* Check for source > 64K on 16-bit machine: */ + if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR; + + stream.next_out = dest; + stream.avail_out = (uInt)*destLen; + if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR; + + stream.zalloc = (alloc_func)0; + stream.zfree = (free_func)0; + + err = inflateInit(&stream); + if (err != Z_OK) return err; + + err = inflate(&stream, Z_FINISH); + if (err != Z_STREAM_END) { + inflateEnd(&stream); + return err == Z_OK ? Z_BUF_ERROR : err; + } + *destLen = stream.total_out; + + err = inflateEnd(&stream); + return err; +} diff --git a/stepmania/src/smpackage/ZipArchive/zlib/zconf.h b/stepmania/src/smpackage/ZipArchive/zlib/zconf.h new file mode 100644 index 0000000000..0029638f45 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/zlib/zconf.h @@ -0,0 +1,287 @@ +/* zconf.h -- configuration of the zlib compression library + * Copyright (C) 1995-1998 Jean-loup Gailly. + * For conditions of distribution and use, see copyright notice in zlib.h + */ + + +#ifndef _ZCONF_H +#define _ZCONF_H +#if _MSC_VER > 1000 + #pragma warning (disable : 4131) + #pragma warning (disable : 4115) + #pragma warning (disable : 4127) + #pragma warning (disable : 4100) + #pragma warning (disable : 4244) + #pragma warning (disable : 4702) + #pragma warning (disable : 4206) +#endif // _MSC_VER > 1000 + +/* + * If you *really* need a unique prefix for all types and library functions, + * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it. + */ +#ifdef Z_PREFIX +# define deflateInit_ z_deflateInit_ +# define deflate z_deflate +# define deflateEnd z_deflateEnd +# define inflateInit_ z_inflateInit_ +# define inflate z_inflate +# define inflateEnd z_inflateEnd +# define deflateInit2_ z_deflateInit2_ +# define deflateSetDictionary z_deflateSetDictionary +# define deflateCopy z_deflateCopy +# define deflateReset z_deflateReset +# define deflateParams z_deflateParams +# define inflateInit2_ z_inflateInit2_ +# define inflateSetDictionary z_inflateSetDictionary +# define inflateSync z_inflateSync +# define inflateSyncPoint z_inflateSyncPoint +# define inflateReset z_inflateReset +# define compress z_compress +# define compress2 z_compress2 +# define uncompress z_uncompress +# define adler32 z_adler32 +# define crc32 z_crc32 +# define get_crc_table z_get_crc_table + +# define Byte z_Byte +# define uInt z_uInt +# define uLong z_uLong +# define Bytef z_Bytef +# define charf z_charf +# define intf z_intf +# define uIntf z_uIntf +# define uLongf z_uLongf +# define voidpf z_voidpf +# define voidp z_voidp +#endif + +#if (defined(_WIN32) || defined(__WIN32__)) && !defined(WIN32) +# define WIN32 +#endif +#if defined(__GNUC__) || defined(WIN32) || defined(__386__) || defined(i386) +# ifndef __32BIT__ +# define __32BIT__ +# endif +#endif +#if defined(__MSDOS__) && !defined(MSDOS) +# define MSDOS +#endif + +/* + * Compile with -DMAXSEG_64K if the alloc function cannot allocate more + * than 64k bytes at a time (needed on systems with 16-bit int). + */ +#if defined(MSDOS) && !defined(__32BIT__) +# define MAXSEG_64K +#endif +#ifdef MSDOS +# define UNALIGNED_OK +#endif + +#if (defined(MSDOS) || defined(_WINDOWS) || defined(WIN32)) && !defined(STDC) +# define STDC +#endif +#if defined(__STDC__) || defined(__cplusplus) || defined(__OS2__) +# ifndef STDC +# define STDC +# endif +#endif + +#ifndef STDC +# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ +# define const +# endif +#endif + +/* Some Mac compilers merge all .h files incorrectly: */ +#if defined(__MWERKS__) || defined(applec) ||defined(THINK_C) ||defined(__SC__) +# define NO_DUMMY_DECL +#endif + +/* Old Borland C incorrectly complains about missing returns: */ +#if defined(__BORLANDC__) && (__BORLANDC__ < 0x500) +# define NEED_DUMMY_RETURN +#endif + + +/* Maximum value for memLevel in deflateInit2 */ +#ifndef MAX_MEM_LEVEL +# ifdef MAXSEG_64K +# define MAX_MEM_LEVEL 8 +# else +# define MAX_MEM_LEVEL 9 +# endif +#endif + +/* Maximum value for windowBits in deflateInit2 and inflateInit2. + * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files + * created by gzip. (Files created by minigzip can still be extracted by + * gzip.) + */ +#ifndef MAX_WBITS +# define MAX_WBITS 15 /* 32K LZ77 window */ +#endif + +/* The memory requirements for deflate are (in bytes): + (1 << (windowBits+2)) + (1 << (memLevel+9)) + that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) + plus a few kilobytes for small objects. For example, if you want to reduce + the default memory requirements from 256K to 128K, compile with + make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" + Of course this will generally degrade compression (there's no free lunch). + + The memory requirements for inflate are (in bytes) 1 << windowBits + that is, 32K for windowBits=15 (default value) plus a few kilobytes + for small objects. +*/ + + /* Type declarations */ + +#ifndef OF /* function prototypes */ +# ifdef STDC +# define OF(args) args +# else +# define OF(args) () +# endif +#endif + +/* The following definitions for FAR are needed only for MSDOS mixed + * model programming (small or medium model with some far allocations). + * This was tested only with MSC; for other MSDOS compilers you may have + * to define NO_MEMCPY in zutil.h. If you don't need the mixed model, + * just define FAR to be empty. + */ +#if (defined(M_I86SM) || defined(M_I86MM)) && !defined(__32BIT__) + /* MSC small or medium model */ +# define SMALL_MEDIUM +# ifdef _MSC_VER +# define FAR _far +# else +# define FAR far +# endif +#endif +#if defined(__BORLANDC__) && (defined(__SMALL__) || defined(__MEDIUM__)) +# ifndef __32BIT__ +# define SMALL_MEDIUM +# define FAR _far +# endif +#endif + +/* Compile with -DZLIB_DLL for Windows DLL support */ +#if defined(ZLIB_DLL) +# if defined(_WINDOWS) || defined(WINDOWS) +# ifdef FAR +# undef FAR +# endif +# include +# define ZEXPORT WINAPI +# ifdef WIN32 +# define ZEXPORTVA WINAPIV +# else +# define ZEXPORTVA FAR _cdecl _export +# endif +# endif +# if defined (__BORLANDC__) +# if (__BORLANDC__ >= 0x0500) && defined (WIN32) +# include +# define ZEXPORT __declspec(dllexport) WINAPI +# define ZEXPORTRVA __declspec(dllexport) WINAPIV +# else +# if defined (_Windows) && defined (__DLL__) +# define ZEXPORT _export +# define ZEXPORTVA _export +# endif +# endif +# endif +#endif + +#if defined (__BEOS__) +# if defined (ZLIB_DLL) +# define ZEXTERN extern __declspec(dllexport) +# else +# define ZEXTERN extern __declspec(dllimport) +# endif +#endif + +#ifndef ZEXPORT +# define ZEXPORT +#endif +#ifndef ZEXPORTVA +# define ZEXPORTVA +#endif +#ifndef ZEXTERN +# define ZEXTERN extern +#endif + +#ifndef FAR +# define FAR +#endif + +#if !defined(MACOS) && !defined(TARGET_OS_MAC) +typedef unsigned char Byte; /* 8 bits */ +#endif +typedef unsigned int uInt; /* 16 bits or more */ +typedef unsigned long uLong; /* 32 bits or more */ + +#ifdef SMALL_MEDIUM + /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ +# define Bytef Byte FAR +#else + typedef Byte FAR Bytef; +#endif +typedef char FAR charf; +typedef int FAR intf; +typedef uInt FAR uIntf; +typedef uLong FAR uLongf; + +#ifdef STDC + typedef void FAR *voidpf; + typedef void *voidp; +#else + typedef Byte FAR *voidpf; + typedef Byte *voidp; +#endif + +#ifdef HAVE_UNISTD_H +# include /* for off_t */ +# include /* for SEEK_* and off_t */ +# define z_off_t off_t +#endif +#ifndef SEEK_SET +# define SEEK_SET 0 /* Seek from beginning of file. */ +# define SEEK_CUR 1 /* Seek from current position. */ +# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ +#endif +#ifndef z_off_t +# define z_off_t long +#endif + +/* MVS linker does not support external names larger than 8 bytes */ +#if defined(__MVS__) +# pragma map(deflateInit_,"DEIN") +# pragma map(deflateInit2_,"DEIN2") +# pragma map(deflateEnd,"DEEND") +# pragma map(inflateInit_,"ININ") +# pragma map(inflateInit2_,"ININ2") +# pragma map(inflateEnd,"INEND") +# pragma map(inflateSync,"INSY") +# pragma map(inflateSetDictionary,"INSEDI") +# pragma map(inflate_blocks,"INBL") +# pragma map(inflate_blocks_new,"INBLNE") +# pragma map(inflate_blocks_free,"INBLFR") +# pragma map(inflate_blocks_reset,"INBLRE") +# pragma map(inflate_codes_free,"INCOFR") +# pragma map(inflate_codes,"INCO") +# pragma map(inflate_fast,"INFA") +# pragma map(inflate_flush,"INFLU") +# pragma map(inflate_mask,"INMA") +# pragma map(inflate_set_dictionary,"INSEDI2") +# pragma map(inflate_copyright,"INCOPY") +# pragma map(inflate_trees_bits,"INTRBI") +# pragma map(inflate_trees_dynamic,"INTRDY") +# pragma map(inflate_trees_fixed,"INTRFI") +# pragma map(inflate_trees_free,"INTRFR") +#endif + +#endif /* _ZCONF_H */ diff --git a/stepmania/src/smpackage/ZipArchive/zlib/zlib.h b/stepmania/src/smpackage/ZipArchive/zlib/zlib.h new file mode 100644 index 0000000000..49f56b43bc --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/zlib/zlib.h @@ -0,0 +1,893 @@ +/* zlib.h -- interface of the 'zlib' general purpose compression library + version 1.1.3, July 9th, 1998 + + Copyright (C) 1995-1998 Jean-loup Gailly and Mark Adler + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + Jean-loup Gailly Mark Adler + jloup@gzip.org madler@alumni.caltech.edu + + + The data format used by the zlib library is described by RFCs (Request for + Comments) 1950 to 1952 in the files ftp://ds.internic.net/rfc/rfc1950.txt + (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format). +*/ + +#ifndef _ZLIB_H +#define _ZLIB_H + +#include "zconf.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define ZLIB_VERSION "1.1.3" + +/* + The 'zlib' compression library provides in-memory compression and + decompression functions, including integrity checks of the uncompressed + data. This version of the library supports only one compression method + (deflation) but other algorithms will be added later and will have the same + stream interface. + + Compression can be done in a single step if the buffers are large + enough (for example if an input file is mmap'ed), or can be done by + repeated calls of the compression function. In the latter case, the + application must provide more input and/or consume the output + (providing more output space) before each call. + + The library also supports reading and writing files in gzip (.gz) format + with an interface similar to that of stdio. + + The library does not install any signal handler. The decoder checks + the consistency of the compressed data, so the library should never + crash even in case of corrupted input. +*/ + +typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); +typedef void (*free_func) OF((voidpf opaque, voidpf address)); + +struct internal_state; + +typedef struct z_stream_s { + Bytef *next_in; /* next input byte */ + uInt avail_in; /* number of bytes available at next_in */ + uLong total_in; /* total nb of input bytes read so far */ + + Bytef *next_out; /* next output byte should be put there */ + uInt avail_out; /* remaining free space at next_out */ + uLong total_out; /* total nb of bytes output so far */ + + char *msg; /* last error message, NULL if no error */ + struct internal_state FAR *state; /* not visible by applications */ + + alloc_func zalloc; /* used to allocate the internal state */ + free_func zfree; /* used to free the internal state */ + voidpf opaque; /* private data object passed to zalloc and zfree */ + + int data_type; /* best guess about the data type: ascii or binary */ + uLong adler; /* adler32 value of the uncompressed data */ + uLong reserved; /* reserved for future use */ +} z_stream; + +typedef z_stream FAR *z_streamp; + +/* + The application must update next_in and avail_in when avail_in has + dropped to zero. It must update next_out and avail_out when avail_out + has dropped to zero. The application must initialize zalloc, zfree and + opaque before calling the init function. All other fields are set by the + compression library and must not be updated by the application. + + The opaque value provided by the application will be passed as the first + parameter for calls of zalloc and zfree. This can be useful for custom + memory management. The compression library attaches no meaning to the + opaque value. + + zalloc must return Z_NULL if there is not enough memory for the object. + If zlib is used in a multi-threaded application, zalloc and zfree must be + thread safe. + + On 16-bit systems, the functions zalloc and zfree must be able to allocate + exactly 65536 bytes, but will not be required to allocate more than this + if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS, + pointers returned by zalloc for objects of exactly 65536 bytes *must* + have their offset normalized to zero. The default allocation function + provided by this library ensures this (see zutil.c). To reduce memory + requirements and avoid any allocation of 64K objects, at the expense of + compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h). + + The fields total_in and total_out can be used for statistics or + progress reports. After compression, total_in holds the total size of + the uncompressed data and may be saved for use in the decompressor + (particularly if the decompressor wants to decompress everything in + a single step). +*/ + + /* constants */ + +#define Z_NO_FLUSH 0 +#define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */ +#define Z_SYNC_FLUSH 2 +#define Z_FULL_FLUSH 3 +#define Z_FINISH 4 +/* Allowed flush values; see deflate() below for details */ + +#define Z_OK 0 +#define Z_STREAM_END 1 +#define Z_NEED_DICT 2 +#define Z_ERRNO (-1) +#define Z_STREAM_ERROR (-2) +#define Z_DATA_ERROR (-3) +#define Z_MEM_ERROR (-4) +#define Z_BUF_ERROR (-5) +#define Z_VERSION_ERROR (-6) +/* Return codes for the compression/decompression functions. Negative + * values are errors, positive values are used for special but normal events. + */ + +#define Z_NO_COMPRESSION 0 +#define Z_BEST_SPEED 1 +#define Z_BEST_COMPRESSION 9 +#define Z_DEFAULT_COMPRESSION (-1) +/* compression levels */ + +#define Z_FILTERED 1 +#define Z_HUFFMAN_ONLY 2 +#define Z_DEFAULT_STRATEGY 0 +/* compression strategy; see deflateInit2() below for details */ + +#define Z_BINARY 0 +#define Z_ASCII 1 +#define Z_UNKNOWN 2 +/* Possible values of the data_type field */ + +#define Z_DEFLATED 8 +/* The deflate compression method (the only one supported in this version) */ + +#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ + +#define zlib_version zlibVersion() +/* for compatibility with versions < 1.0.2 */ + + /* basic functions */ + +ZEXTERN const char * ZEXPORT zlibVersion OF((void)); +/* The application can compare zlibVersion and ZLIB_VERSION for consistency. + If the first character differs, the library code actually used is + not compatible with the zlib.h header file used by the application. + This check is automatically made by deflateInit and inflateInit. + */ + +/* +ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level)); + + Initializes the internal stream state for compression. The fields + zalloc, zfree and opaque must be initialized before by the caller. + If zalloc and zfree are set to Z_NULL, deflateInit updates them to + use default allocation functions. + + The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9: + 1 gives best speed, 9 gives best compression, 0 gives no compression at + all (the input data is simply copied a block at a time). + Z_DEFAULT_COMPRESSION requests a default compromise between speed and + compression (currently equivalent to level 6). + + deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_STREAM_ERROR if level is not a valid compression level, + Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible + with the version assumed by the caller (ZLIB_VERSION). + msg is set to null if there is no error message. deflateInit does not + perform any compression: this will be done by deflate(). +*/ + + +ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); +/* + deflate compresses as much data as possible, and stops when the input + buffer becomes empty or the output buffer becomes full. It may introduce some + output latency (reading input without producing any output) except when + forced to flush. + + The detailed semantics are as follows. deflate performs one or both of the + following actions: + + - Compress more input starting at next_in and update next_in and avail_in + accordingly. If not all input can be processed (because there is not + enough room in the output buffer), next_in and avail_in are updated and + processing will resume at this point for the next call of deflate(). + + - Provide more output starting at next_out and update next_out and avail_out + accordingly. This action is forced if the parameter flush is non zero. + Forcing flush frequently degrades the compression ratio, so this parameter + should be set only when necessary (in interactive applications). + Some output may be provided even if flush is not set. + + Before the call of deflate(), the application should ensure that at least + one of the actions is possible, by providing more input and/or consuming + more output, and updating avail_in or avail_out accordingly; avail_out + should never be zero before the call. The application can consume the + compressed output when it wants, for example when the output buffer is full + (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK + and with zero avail_out, it must be called again after making room in the + output buffer because there might be more output pending. + + If the parameter flush is set to Z_SYNC_FLUSH, all pending output is + flushed to the output buffer and the output is aligned on a byte boundary, so + that the decompressor can get all input data available so far. (In particular + avail_in is zero after the call if enough output space has been provided + before the call.) Flushing may degrade compression for some compression + algorithms and so it should be used only when necessary. + + If flush is set to Z_FULL_FLUSH, all output is flushed as with + Z_SYNC_FLUSH, and the compression state is reset so that decompression can + restart from this point if previous compressed data has been damaged or if + random access is desired. Using Z_FULL_FLUSH too often can seriously degrade + the compression. + + If deflate returns with avail_out == 0, this function must be called again + with the same value of the flush parameter and more output space (updated + avail_out), until the flush is complete (deflate returns with non-zero + avail_out). + + If the parameter flush is set to Z_FINISH, pending input is processed, + pending output is flushed and deflate returns with Z_STREAM_END if there + was enough output space; if deflate returns with Z_OK, this function must be + called again with Z_FINISH and more output space (updated avail_out) but no + more input data, until it returns with Z_STREAM_END or an error. After + deflate has returned Z_STREAM_END, the only possible operations on the + stream are deflateReset or deflateEnd. + + Z_FINISH can be used immediately after deflateInit if all the compression + is to be done in a single step. In this case, avail_out must be at least + 0.1% larger than avail_in plus 12 bytes. If deflate does not return + Z_STREAM_END, then it must be called again as described above. + + deflate() sets strm->adler to the adler32 checksum of all input read + so far (that is, total_in bytes). + + deflate() may update data_type if it can make a good guess about + the input data type (Z_ASCII or Z_BINARY). In doubt, the data is considered + binary. This field is only for information purposes and does not affect + the compression algorithm in any manner. + + deflate() returns Z_OK if some progress has been made (more input + processed or more output produced), Z_STREAM_END if all input has been + consumed and all output has been produced (only when flush is set to + Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example + if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible + (for example avail_in or avail_out was zero). +*/ + + +ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); +/* + All dynamically allocated data structures for this stream are freed. + This function discards any unprocessed input and does not flush any + pending output. + + deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the + stream state was inconsistent, Z_DATA_ERROR if the stream was freed + prematurely (some input or output was discarded). In the error case, + msg may be set but then points to a static string (which must not be + deallocated). +*/ + + +/* +ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); + + Initializes the internal stream state for decompression. The fields + next_in, avail_in, zalloc, zfree and opaque must be initialized before by + the caller. If next_in is not Z_NULL and avail_in is large enough (the exact + value depends on the compression method), inflateInit determines the + compression method from the zlib header and allocates all data structures + accordingly; otherwise the allocation will be deferred to the first call of + inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to + use default allocation functions. + + inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_VERSION_ERROR if the zlib library version is incompatible with the + version assumed by the caller. msg is set to null if there is no error + message. inflateInit does not perform any decompression apart from reading + the zlib header if present: this will be done by inflate(). (So next_in and + avail_in may be modified, but next_out and avail_out are unchanged.) +*/ + + +ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); +/* + inflate decompresses as much data as possible, and stops when the input + buffer becomes empty or the output buffer becomes full. It may some + introduce some output latency (reading input without producing any output) + except when forced to flush. + + The detailed semantics are as follows. inflate performs one or both of the + following actions: + + - Decompress more input starting at next_in and update next_in and avail_in + accordingly. If not all input can be processed (because there is not + enough room in the output buffer), next_in is updated and processing + will resume at this point for the next call of inflate(). + + - Provide more output starting at next_out and update next_out and avail_out + accordingly. inflate() provides as much output as possible, until there + is no more input data or no more space in the output buffer (see below + about the flush parameter). + + Before the call of inflate(), the application should ensure that at least + one of the actions is possible, by providing more input and/or consuming + more output, and updating the next_* and avail_* values accordingly. + The application can consume the uncompressed output when it wants, for + example when the output buffer is full (avail_out == 0), or after each + call of inflate(). If inflate returns Z_OK and with zero avail_out, it + must be called again after making room in the output buffer because there + might be more output pending. + + If the parameter flush is set to Z_SYNC_FLUSH, inflate flushes as much + output as possible to the output buffer. The flushing behavior of inflate is + not specified for values of the flush parameter other than Z_SYNC_FLUSH + and Z_FINISH, but the current implementation actually flushes as much output + as possible anyway. + + inflate() should normally be called until it returns Z_STREAM_END or an + error. However if all decompression is to be performed in a single step + (a single call of inflate), the parameter flush should be set to + Z_FINISH. In this case all pending input is processed and all pending + output is flushed; avail_out must be large enough to hold all the + uncompressed data. (The size of the uncompressed data may have been saved + by the compressor for this purpose.) The next operation on this stream must + be inflateEnd to deallocate the decompression state. The use of Z_FINISH + is never required, but can be used to inform inflate that a faster routine + may be used for the single inflate() call. + + If a preset dictionary is needed at this point (see inflateSetDictionary + below), inflate sets strm-adler to the adler32 checksum of the + dictionary chosen by the compressor and returns Z_NEED_DICT; otherwise + it sets strm->adler to the adler32 checksum of all output produced + so far (that is, total_out bytes) and returns Z_OK, Z_STREAM_END or + an error code as described below. At the end of the stream, inflate() + checks that its computed adler32 checksum is equal to that saved by the + compressor and returns Z_STREAM_END only if the checksum is correct. + + inflate() returns Z_OK if some progress has been made (more input processed + or more output produced), Z_STREAM_END if the end of the compressed data has + been reached and all uncompressed output has been produced, Z_NEED_DICT if a + preset dictionary is needed at this point, Z_DATA_ERROR if the input data was + corrupted (input stream not conforming to the zlib format or incorrect + adler32 checksum), Z_STREAM_ERROR if the stream structure was inconsistent + (for example if next_in or next_out was NULL), Z_MEM_ERROR if there was not + enough memory, Z_BUF_ERROR if no progress is possible or if there was not + enough room in the output buffer when Z_FINISH is used. In the Z_DATA_ERROR + case, the application may then call inflateSync to look for a good + compression block. +*/ + + +ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); +/* + All dynamically allocated data structures for this stream are freed. + This function discards any unprocessed input and does not flush any + pending output. + + inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state + was inconsistent. In the error case, msg may be set but then points to a + static string (which must not be deallocated). +*/ + + /* Advanced functions */ + +/* + The following functions are needed only in some special applications. +*/ + +/* +ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, + int level, + int method, + int windowBits, + int memLevel, + int strategy)); + + This is another version of deflateInit with more compression options. The + fields next_in, zalloc, zfree and opaque must be initialized before by + the caller. + + The method parameter is the compression method. It must be Z_DEFLATED in + this version of the library. + + The windowBits parameter is the base two logarithm of the window size + (the size of the history buffer). It should be in the range 8..15 for this + version of the library. Larger values of this parameter result in better + compression at the expense of memory usage. The default value is 15 if + deflateInit is used instead. + + The memLevel parameter specifies how much memory should be allocated + for the internal compression state. memLevel=1 uses minimum memory but + is slow and reduces compression ratio; memLevel=9 uses maximum memory + for optimal speed. The default value is 8. See zconf.h for total memory + usage as a function of windowBits and memLevel. + + The strategy parameter is used to tune the compression algorithm. Use the + value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a + filter (or predictor), or Z_HUFFMAN_ONLY to force Huffman encoding only (no + string match). Filtered data consists mostly of small values with a + somewhat random distribution. In this case, the compression algorithm is + tuned to compress them better. The effect of Z_FILTERED is to force more + Huffman coding and less string matching; it is somewhat intermediate + between Z_DEFAULT and Z_HUFFMAN_ONLY. The strategy parameter only affects + the compression ratio but not the correctness of the compressed output even + if it is not set appropriately. + + deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid + method). msg is set to null if there is no error message. deflateInit2 does + not perform any compression: this will be done by deflate(). +*/ + +ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, + const Bytef *dictionary, + uInt dictLength)); +/* + Initializes the compression dictionary from the given byte sequence + without producing any compressed output. This function must be called + immediately after deflateInit, deflateInit2 or deflateReset, before any + call of deflate. The compressor and decompressor must use exactly the same + dictionary (see inflateSetDictionary). + + The dictionary should consist of strings (byte sequences) that are likely + to be encountered later in the data to be compressed, with the most commonly + used strings preferably put towards the end of the dictionary. Using a + dictionary is most useful when the data to be compressed is short and can be + predicted with good accuracy; the data can then be compressed better than + with the default empty dictionary. + + Depending on the size of the compression data structures selected by + deflateInit or deflateInit2, a part of the dictionary may in effect be + discarded, for example if the dictionary is larger than the window size in + deflate or deflate2. Thus the strings most likely to be useful should be + put at the end of the dictionary, not at the front. + + Upon return of this function, strm->adler is set to the Adler32 value + of the dictionary; the decompressor may later use this value to determine + which dictionary has been used by the compressor. (The Adler32 value + applies to the whole dictionary even if only a subset of the dictionary is + actually used by the compressor.) + + deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a + parameter is invalid (such as NULL dictionary) or the stream state is + inconsistent (for example if deflate has already been called for this stream + or if the compression method is bsort). deflateSetDictionary does not + perform any compression: this will be done by deflate(). +*/ + +ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, + z_streamp source)); +/* + Sets the destination stream as a complete copy of the source stream. + + This function can be useful when several compression strategies will be + tried, for example when there are several ways of pre-processing the input + data with a filter. The streams that will be discarded should then be freed + by calling deflateEnd. Note that deflateCopy duplicates the internal + compression state which can be quite large, so this strategy is slow and + can consume lots of memory. + + deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_STREAM_ERROR if the source stream state was inconsistent + (such as zalloc being NULL). msg is left unchanged in both source and + destination. +*/ + +ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); +/* + This function is equivalent to deflateEnd followed by deflateInit, + but does not free and reallocate all the internal compression state. + The stream will keep the same compression level and any other attributes + that may have been set by deflateInit2. + + deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being NULL). +*/ + +ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, + int level, + int strategy)); +/* + Dynamically update the compression level and compression strategy. The + interpretation of level and strategy is as in deflateInit2. This can be + used to switch between compression and straight copy of the input data, or + to switch to a different kind of input data requiring a different + strategy. If the compression level is changed, the input available so far + is compressed with the old level (and may be flushed); the new level will + take effect only at the next call of deflate(). + + Before the call of deflateParams, the stream state must be set as for + a call of deflate(), since the currently available input may have to + be compressed and flushed. In particular, strm->avail_out must be non-zero. + + deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source + stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR + if strm->avail_out was zero. +*/ + +/* +ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, + int windowBits)); + + This is another version of inflateInit with an extra parameter. The + fields next_in, avail_in, zalloc, zfree and opaque must be initialized + before by the caller. + + The windowBits parameter is the base two logarithm of the maximum window + size (the size of the history buffer). It should be in the range 8..15 for + this version of the library. The default value is 15 if inflateInit is used + instead. If a compressed stream with a larger window size is given as + input, inflate() will return with the error code Z_DATA_ERROR instead of + trying to allocate a larger window. + + inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_STREAM_ERROR if a parameter is invalid (such as a negative + memLevel). msg is set to null if there is no error message. inflateInit2 + does not perform any decompression apart from reading the zlib header if + present: this will be done by inflate(). (So next_in and avail_in may be + modified, but next_out and avail_out are unchanged.) +*/ + +ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, + const Bytef *dictionary, + uInt dictLength)); +/* + Initializes the decompression dictionary from the given uncompressed byte + sequence. This function must be called immediately after a call of inflate + if this call returned Z_NEED_DICT. The dictionary chosen by the compressor + can be determined from the Adler32 value returned by this call of + inflate. The compressor and decompressor must use exactly the same + dictionary (see deflateSetDictionary). + + inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a + parameter is invalid (such as NULL dictionary) or the stream state is + inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the + expected one (incorrect Adler32 value). inflateSetDictionary does not + perform any decompression: this will be done by subsequent calls of + inflate(). +*/ + +ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); +/* + Skips invalid compressed data until a full flush point (see above the + description of deflate with Z_FULL_FLUSH) can be found, or until all + available input is skipped. No output is provided. + + inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR + if no more input was provided, Z_DATA_ERROR if no flush point has been found, + or Z_STREAM_ERROR if the stream structure was inconsistent. In the success + case, the application may save the current current value of total_in which + indicates where valid compressed data was found. In the error case, the + application may repeatedly call inflateSync, providing more input each time, + until success or end of the input data. +*/ + +ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm)); +/* + This function is equivalent to inflateEnd followed by inflateInit, + but does not free and reallocate all the internal decompression state. + The stream will keep attributes that may have been set by inflateInit2. + + inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being NULL). +*/ + + + /* utility functions */ + +/* + The following utility functions are implemented on top of the + basic stream-oriented functions. To simplify the interface, some + default options are assumed (compression level and memory usage, + standard memory allocation functions). The source code of these + utility functions can easily be modified if you need special options. +*/ + +ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen)); +/* + Compresses the source buffer into the destination buffer. sourceLen is + the byte length of the source buffer. Upon entry, destLen is the total + size of the destination buffer, which must be at least 0.1% larger than + sourceLen plus 12 bytes. Upon exit, destLen is the actual size of the + compressed buffer. + This function can be used to compress a whole file at once if the + input file is mmap'ed. + compress returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_BUF_ERROR if there was not enough room in the output + buffer. +*/ + +ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen, + int level)); +/* + Compresses the source buffer into the destination buffer. The level + parameter has the same meaning as in deflateInit. sourceLen is the byte + length of the source buffer. Upon entry, destLen is the total size of the + destination buffer, which must be at least 0.1% larger than sourceLen plus + 12 bytes. Upon exit, destLen is the actual size of the compressed buffer. + + compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_BUF_ERROR if there was not enough room in the output buffer, + Z_STREAM_ERROR if the level parameter is invalid. +*/ + +ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen)); +/* + Decompresses the source buffer into the destination buffer. sourceLen is + the byte length of the source buffer. Upon entry, destLen is the total + size of the destination buffer, which must be large enough to hold the + entire uncompressed data. (The size of the uncompressed data must have + been saved previously by the compressor and transmitted to the decompressor + by some mechanism outside the scope of this compression library.) + Upon exit, destLen is the actual size of the compressed buffer. + This function can be used to decompress a whole file at once if the + input file is mmap'ed. + + uncompress returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_BUF_ERROR if there was not enough room in the output + buffer, or Z_DATA_ERROR if the input data was corrupted. +*/ + + +typedef voidp gzFile; + +ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); +/* + Opens a gzip (.gz) file for reading or writing. The mode parameter + is as in fopen ("rb" or "wb") but can also include a compression level + ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for + Huffman only compression as in "wb1h". (See the description + of deflateInit2 for more information about the strategy parameter.) + + gzopen can be used to read a file which is not in gzip format; in this + case gzread will directly read from the file without decompression. + + gzopen returns NULL if the file could not be opened or if there was + insufficient memory to allocate the (de)compression state; errno + can be checked to distinguish the two cases (if errno is zero, the + zlib error is Z_MEM_ERROR). */ + +ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); +/* + gzdopen() associates a gzFile with the file descriptor fd. File + descriptors are obtained from calls like open, dup, creat, pipe or + fileno (in the file has been previously opened with fopen). + The mode parameter is as in gzopen. + The next call of gzclose on the returned gzFile will also close the + file descriptor fd, just like fclose(fdopen(fd), mode) closes the file + descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode). + gzdopen returns NULL if there was insufficient memory to allocate + the (de)compression state. +*/ + +ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); +/* + Dynamically update the compression level or strategy. See the description + of deflateInit2 for the meaning of these parameters. + gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not + opened for writing. +*/ + +ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); +/* + Reads the given number of uncompressed bytes from the compressed file. + If the input file was not in gzip format, gzread copies the given number + of bytes into the buffer. + gzread returns the number of uncompressed bytes actually read (0 for + end of file, -1 for error). */ + +ZEXTERN int ZEXPORT gzwrite OF((gzFile file, + const voidp buf, unsigned len)); +/* + Writes the given number of uncompressed bytes into the compressed file. + gzwrite returns the number of uncompressed bytes actually written + (0 in case of error). +*/ + +ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...)); +/* + Converts, formats, and writes the args to the compressed file under + control of the format string, as in fprintf. gzprintf returns the number of + uncompressed bytes actually written (0 in case of error). +*/ + +ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); +/* + Writes the given null-terminated string to the compressed file, excluding + the terminating null character. + gzputs returns the number of characters written, or -1 in case of error. +*/ + +ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); +/* + Reads bytes from the compressed file until len-1 characters are read, or + a newline character is read and transferred to buf, or an end-of-file + condition is encountered. The string is then terminated with a null + character. + gzgets returns buf, or Z_NULL in case of error. +*/ + +ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); +/* + Writes c, converted to an unsigned char, into the compressed file. + gzputc returns the value that was written, or -1 in case of error. +*/ + +ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); +/* + Reads one byte from the compressed file. gzgetc returns this byte + or -1 in case of end of file or error. +*/ + +ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); +/* + Flushes all pending output into the compressed file. The parameter + flush is as in the deflate() function. The return value is the zlib + error number (see function gzerror below). gzflush returns Z_OK if + the flush parameter is Z_FINISH and all output could be flushed. + gzflush should be called only when strictly necessary because it can + degrade compression. +*/ + +ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, + z_off_t offset, int whence)); +/* + Sets the starting position for the next gzread or gzwrite on the + given compressed file. The offset represents a number of bytes in the + uncompressed data stream. The whence parameter is defined as in lseek(2); + the value SEEK_END is not supported. + If the file is opened for reading, this function is emulated but can be + extremely slow. If the file is opened for writing, only forward seeks are + supported; gzseek then compresses a sequence of zeroes up to the new + starting position. + + gzseek returns the resulting offset location as measured in bytes from + the beginning of the uncompressed stream, or -1 in case of error, in + particular if the file is opened for writing and the new starting position + would be before the current position. +*/ + +ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); +/* + Rewinds the given file. This function is supported only for reading. + + gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET) +*/ + +ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); +/* + Returns the starting position for the next gzread or gzwrite on the + given compressed file. This position represents a number of bytes in the + uncompressed data stream. + + gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR) +*/ + +ZEXTERN int ZEXPORT gzeof OF((gzFile file)); +/* + Returns 1 when EOF has previously been detected reading the given + input stream, otherwise zero. +*/ + +ZEXTERN int ZEXPORT gzclose OF((gzFile file)); +/* + Flushes all pending output if necessary, closes the compressed file + and deallocates all the (de)compression state. The return value is the zlib + error number (see function gzerror below). +*/ + +ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); +/* + Returns the error message for the last error which occurred on the + given compressed file. errnum is set to zlib error number. If an + error occurred in the file system and not in the compression library, + errnum is set to Z_ERRNO and the application may consult errno + to get the exact error code. +*/ + + /* checksum functions */ + +/* + These functions are not related to compression but are exported + anyway because they might be useful in applications using the + compression library. +*/ + +ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); + +/* + Update a running Adler-32 checksum with the bytes buf[0..len-1] and + return the updated checksum. If buf is NULL, this function returns + the required initial value for the checksum. + An Adler-32 checksum is almost as reliable as a CRC32 but can be computed + much faster. Usage example: + + uLong adler = adler32(0L, Z_NULL, 0); + + while (read_buffer(buffer, length) != EOF) { + adler = adler32(adler, buffer, length); + } + if (adler != original_adler) error(); +*/ + +ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); +/* + Update a running crc with the bytes buf[0..len-1] and return the updated + crc. If buf is NULL, this function returns the required initial value + for the crc. Pre- and post-conditioning (one's complement) is performed + within this function so it shouldn't be done by the application. + Usage example: + + uLong crc = crc32(0L, Z_NULL, 0); + + while (read_buffer(buffer, length) != EOF) { + crc = crc32(crc, buffer, length); + } + if (crc != original_crc) error(); +*/ + + + /* various hacks, don't look :) */ + +/* deflateInit and inflateInit are macros to allow checking the zlib version + * and the compiler's view of z_stream: + */ +ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, + int windowBits, int memLevel, + int strategy, const char *version, + int stream_size)); +ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, + const char *version, int stream_size)); +#define deflateInit(strm, level) \ + deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream)) +#define inflateInit(strm) \ + inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream)) +#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ + deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ + (strategy), ZLIB_VERSION, sizeof(z_stream)) +#define inflateInit2(strm, windowBits) \ + inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream)) + + +#if !defined(_Z_UTIL_H) && !defined(NO_DUMMY_DECL) + struct internal_state {int dummy;}; /* hack for buggy compilers */ +#endif + +ZEXTERN const char * ZEXPORT zError OF((int err)); +ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp z)); +ZEXTERN const uLongf * ZEXPORT get_crc_table OF((void)); + +#ifdef __cplusplus +} +#endif + +#endif /* _ZLIB_H */ diff --git a/stepmania/src/smpackage/ZipArchive/zlib/zutil.c b/stepmania/src/smpackage/ZipArchive/zlib/zutil.c new file mode 100644 index 0000000000..5a62bd392c --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/zlib/zutil.c @@ -0,0 +1,224 @@ +/* zutil.c -- target dependent utility functions for the compression library + * Copyright (C) 1995-1998 Jean-loup Gailly. + * For conditions of distribution and use, see copyright notice in zlib.h + */ + + +#include "zutil.h" + +struct internal_state {int dummy;}; /* for buggy compilers */ + +#ifndef STDC +extern void exit OF((int)); +#endif + +const char *z_errmsg[10] = { +"need dictionary", /* Z_NEED_DICT 2 */ +"stream end", /* Z_STREAM_END 1 */ +"", /* Z_OK 0 */ +"file error", /* Z_ERRNO (-1) */ +"stream error", /* Z_STREAM_ERROR (-2) */ +"data error", /* Z_DATA_ERROR (-3) */ +"insufficient memory", /* Z_MEM_ERROR (-4) */ +"buffer error", /* Z_BUF_ERROR (-5) */ +"incompatible version",/* Z_VERSION_ERROR (-6) */ +""}; + + +const char * ZEXPORT zlibVersion() +{ + return ZLIB_VERSION; +} + +#ifdef DEBUG + +# ifndef verbose +# define verbose 0 +# endif +int z_verbose = verbose; + +void z_error (m) + char *m; +{ + fprintf(stderr, "%s\n", m); + exit(1); +} +#endif + +/* exported to allow conversion of error code to string for compress() and + * uncompress() + */ +const char * ZEXPORT zError(err) + int err; +{ + return ERR_MSG(err); +} + + +#ifndef HAVE_MEMCPY + +void zmemcpy(dest, source, len) + Bytef* dest; + const Bytef* source; + uInt len; +{ + if (len == 0) return; + do { + *dest++ = *source++; /* ??? to be unrolled */ + } while (--len != 0); +} + +int zmemcmp(s1, s2, len) + const Bytef* s1; + const Bytef* s2; + uInt len; +{ + uInt j; + + for (j = 0; j < len; j++) { + if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1; + } + return 0; +} + +void zmemzero(dest, len) + Bytef* dest; + uInt len; +{ + if (len == 0) return; + do { + *dest++ = 0; /* ??? to be unrolled */ + } while (--len != 0); +} +#endif + +#ifdef __TURBOC__ +#if (defined( __BORLANDC__) || !defined(SMALL_MEDIUM)) && !defined(__32BIT__) +/* Small and medium model in Turbo C are for now limited to near allocation + * with reduced MAX_WBITS and MAX_MEM_LEVEL + */ +# define MY_ZCALLOC + +/* Turbo C malloc() does not allow dynamic allocation of 64K bytes + * and farmalloc(64K) returns a pointer with an offset of 8, so we + * must fix the pointer. Warning: the pointer must be put back to its + * original form in order to free it, use zcfree(). + */ + +#define MAX_PTR 10 +/* 10*64K = 640K */ + +local int next_ptr = 0; + +typedef struct ptr_table_s { + voidpf org_ptr; + voidpf new_ptr; +} ptr_table; + +local ptr_table table[MAX_PTR]; +/* This table is used to remember the original form of pointers + * to large buffers (64K). Such pointers are normalized with a zero offset. + * Since MSDOS is not a preemptive multitasking OS, this table is not + * protected from concurrent access. This hack doesn't work anyway on + * a protected system like OS/2. Use Microsoft C instead. + */ + +voidpf zcalloc (voidpf opaque, unsigned items, unsigned size) +{ + voidpf buf = opaque; /* just to make some compilers happy */ + ulg bsize = (ulg)items*size; + + /* If we allocate less than 65520 bytes, we assume that farmalloc + * will return a usable pointer which doesn't have to be normalized. + */ + if (bsize < 65520L) { + buf = farmalloc(bsize); + if (*(ush*)&buf != 0) return buf; + } else { + buf = farmalloc(bsize + 16L); + } + if (buf == NULL || next_ptr >= MAX_PTR) return NULL; + table[next_ptr].org_ptr = buf; + + /* Normalize the pointer to seg:0 */ + *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4; + *(ush*)&buf = 0; + table[next_ptr++].new_ptr = buf; + return buf; +} + +void zcfree (voidpf opaque, voidpf ptr) +{ + int n; + if (*(ush*)&ptr != 0) { /* object < 64K */ + farfree(ptr); + return; + } + /* Find the original pointer */ + for (n = 0; n < next_ptr; n++) { + if (ptr != table[n].new_ptr) continue; + + farfree(table[n].org_ptr); + while (++n < next_ptr) { + table[n-1] = table[n]; + } + next_ptr--; + return; + } + ptr = opaque; /* just to make some compilers happy */ + Assert(0, "zcfree: ptr not found"); +} +#endif +#endif /* __TURBOC__ */ + + +#if defined(M_I86) && !defined(__32BIT__) +/* Microsoft C in 16-bit mode */ + +# define MY_ZCALLOC + +#if (!defined(_MSC_VER) || (_MSC_VER <= 600)) +# define _halloc halloc +# define _hfree hfree +#endif + +voidpf zcalloc (voidpf opaque, unsigned items, unsigned size) +{ + if (opaque) opaque = 0; /* to make compiler happy */ + return _halloc((long)items, size); +} + +void zcfree (voidpf opaque, voidpf ptr) +{ + if (opaque) opaque = 0; /* to make compiler happy */ + _hfree(ptr); +} + +#endif /* MSC */ + + +#ifndef MY_ZCALLOC /* Any system without a special alloc function */ + +#ifndef STDC +extern voidp calloc OF((uInt items, uInt size)); +extern void free OF((voidpf ptr)); +#endif + +voidpf zcalloc (opaque, items, size) + voidpf opaque; + unsigned items; + unsigned size; +{ + if (opaque) items += size - size; /* make compiler happy */ + return (voidpf)calloc(items, size); +} + +void zcfree (opaque, ptr) + voidpf opaque; + voidpf ptr; +{ + free(ptr); + if (opaque) return; /* make compiler happy */ +} + +#endif /* MY_ZCALLOC */ diff --git a/stepmania/src/smpackage/ZipArchive/zlib/zutil.h b/stepmania/src/smpackage/ZipArchive/zlib/zutil.h new file mode 100644 index 0000000000..e367cf2460 --- /dev/null +++ b/stepmania/src/smpackage/ZipArchive/zlib/zutil.h @@ -0,0 +1,219 @@ +/* zutil.h -- internal interface and configuration of the compression library + * Copyright (C) 1995-1998 Jean-loup Gailly. + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* WARNING: this file should *not* be used by applications. It is + part of the implementation of the compression library and is + subject to change. Applications should only use zlib.h. + */ + + +#ifndef _Z_UTIL_H +#define _Z_UTIL_H + +#include "zlib.h" + +#ifdef STDC +# include +# include +# include +#endif +#ifdef NO_ERRNO_H + extern int errno; +#else +# include +#endif + +#ifndef local +# define local static +#endif +/* compile with -Dlocal if your debugger can't find static symbols */ + +typedef unsigned char uch; +typedef uch FAR uchf; +typedef unsigned short ush; +typedef ush FAR ushf; +typedef unsigned long ulg; + +extern const char *z_errmsg[10]; /* indexed by 2-zlib_error */ +/* (size given to avoid silly warnings with Visual C++) */ + +#define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)] + +#define ERR_RETURN(strm,err) \ + return (strm->msg = (char*)ERR_MSG(err), (err)) +/* To be used only when the state is known to be valid */ + + /* common constants */ + +#ifndef DEF_WBITS +# define DEF_WBITS MAX_WBITS +#endif +/* default windowBits for decompression. MAX_WBITS is for compression only */ + +#if MAX_MEM_LEVEL >= 8 +# define DEF_MEM_LEVEL 8 +#else +# define DEF_MEM_LEVEL MAX_MEM_LEVEL +#endif +/* default memLevel */ + +#define STORED_BLOCK 0 +#define STATIC_TREES 1 +#define DYN_TREES 2 +/* The three kinds of block type */ + +#define MIN_MATCH 3 +#define MAX_MATCH 258 +/* The minimum and maximum match lengths */ + +#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */ + + /* target dependencies */ + +#ifdef MSDOS +# define OS_CODE 0x00 +# if defined(__TURBOC__) || defined(__BORLANDC__) +# if(__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__)) + /* Allow compilation with ANSI keywords only enabled */ + void _Cdecl farfree( void *block ); + void *_Cdecl farmalloc( unsigned long nbytes ); +# else +# include +# endif +# else /* MSC or DJGPP */ +# include +# endif +#endif + +#ifdef OS2 +# define OS_CODE 0x06 +#endif + +#ifdef WIN32 /* Window 95 & Windows NT */ +# define OS_CODE 0x0b +#endif + +#if defined(VAXC) || defined(VMS) +# define OS_CODE 0x02 +# define F_OPEN(name, mode) \ + fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512") +#endif + +#ifdef AMIGA +# define OS_CODE 0x01 +#endif + +#if defined(ATARI) || defined(atarist) +# define OS_CODE 0x05 +#endif + +#if defined(MACOS) || defined(TARGET_OS_MAC) +# define OS_CODE 0x07 +# if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os +# include /* for fdopen */ +# else +# ifndef fdopen +# define fdopen(fd,mode) NULL /* No fdopen() */ +# endif +# endif +#endif + +#ifdef __50SERIES /* Prime/PRIMOS */ +# define OS_CODE 0x0F +#endif + +#ifdef TOPS20 +# define OS_CODE 0x0a +#endif + +#if defined(_BEOS_) || defined(RISCOS) +# define fdopen(fd,mode) NULL /* No fdopen() */ +#endif + +#if (defined(_MSC_VER) && (_MSC_VER > 600)) +# define fdopen(fd,type) _fdopen(fd,type) +#endif + + + /* Common defaults */ + +#ifndef OS_CODE +# define OS_CODE 0x03 /* assume Unix */ +#endif + +#ifndef F_OPEN +# define F_OPEN(name, mode) fopen((name), (mode)) +#endif + + /* functions */ + +#ifdef HAVE_STRERROR + extern char *strerror OF((int)); +# define zstrerror(errnum) strerror(errnum) +#else +# define zstrerror(errnum) "" +#endif + +#if defined(pyr) +# define NO_MEMCPY +#endif +#if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__) + /* Use our own functions for small and medium model with MSC <= 5.0. + * You may have to use the same strategy for Borland C (untested). + * The __SC__ check is for Symantec. + */ +# define NO_MEMCPY +#endif +#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY) +# define HAVE_MEMCPY +#endif +#ifdef HAVE_MEMCPY +# ifdef SMALL_MEDIUM /* MSDOS small or medium model */ +# define zmemcpy _fmemcpy +# define zmemcmp _fmemcmp +# define zmemzero(dest, len) _fmemset(dest, 0, len) +# else +# define zmemcpy memcpy +# define zmemcmp memcmp +# define zmemzero(dest, len) memset(dest, 0, len) +# endif +#else + extern void zmemcpy OF((Bytef* dest, const Bytef* source, uInt len)); + extern int zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len)); + extern void zmemzero OF((Bytef* dest, uInt len)); +#endif + +/* Diagnostic functions */ +#ifdef DEBUG +# include + extern int z_verbose; + extern void z_error OF((char *m)); +# define Assert(cond,msg) {if(!(cond)) z_error(msg);} +# define Trace(x) {if (z_verbose>=0) fprintf x ;} +# define Tracev(x) {if (z_verbose>0) fprintf x ;} +# define Tracevv(x) {if (z_verbose>1) fprintf x ;} +# define Tracec(c,x) {if (z_verbose>0 && (c)) fprintf x ;} +# define Tracecv(c,x) {if (z_verbose>1 && (c)) fprintf x ;} +#else +# define Assert(cond,msg) +# define Trace(x) +# define Tracev(x) +# define Tracevv(x) +# define Tracec(c,x) +# define Tracecv(c,x) +#endif + + +typedef uLong (ZEXPORT *check_func) OF((uLong check, const Bytef *buf, + uInt len)); +voidpf zcalloc OF((voidpf opaque, unsigned items, unsigned size)); +void zcfree OF((voidpf opaque, voidpf ptr)); + +#define ZALLOC(strm, items, size) \ + (*((strm)->zalloc))((strm)->opaque, (items), (size)) +#define ZFREE(strm, addr) (*((strm)->zfree))((strm)->opaque, (voidpf)(addr)) +#define TRY_FREE(s, p) {if (p) ZFREE(s, p);} + +#endif /* _Z_UTIL_H */ diff --git a/stepmania/src/smpackage/resource.h b/stepmania/src/smpackage/resource.h index f0ab839235..d1100a07b6 100644 --- a/stepmania/src/smpackage/resource.h +++ b/stepmania/src/smpackage/resource.h @@ -12,7 +12,9 @@ #define IDC_BUTTON_PLAY 1001 #define IDC_BUTTON_EXPORT 1002 #define IDC_BUTTON_BACK 1003 -#define IDC_EDIT_MESSAGE 1005 +#define IDC_EDIT_MESSAGE1 1005 +#define IDC_EDIT_MESSAGE3 1006 +#define IDC_EDIT_MESSAGE2 1007 // Next default values for new objects // diff --git a/stepmania/src/smpackage/smpackage.clw b/stepmania/src/smpackage/smpackage.clw index 4a1650ca8a..bcea9e3272 100644 --- a/stepmania/src/smpackage/smpackage.clw +++ b/stepmania/src/smpackage/smpackage.clw @@ -48,12 +48,14 @@ Control5=IDC_STATIC,static,1342177294 [DLG:IDD_INSTALL] Type=1 Class=CSMPackageInstallDlg -ControlCount=5 -Control1=IDC_EDIT_MESSAGE,edit,1342179460 +ControlCount=7 +Control1=IDC_EDIT_MESSAGE1,edit,1342179460 Control2=IDOK,button,1342242817 Control3=IDCANCEL,button,1342242816 Control4=IDC_BUTTON_BACK,button,1476460544 Control5=IDC_STATIC,static,1342177294 +Control6=IDC_EDIT_MESSAGE3,edit,1342179460 +Control7=IDC_EDIT_MESSAGE2,edit,1352665220 [CLS:CSMPackageInstallDlg] Type=0 diff --git a/stepmania/src/smpackage/smpackage.dsp b/stepmania/src/smpackage/smpackage.dsp index 2a0788dc53..8b146cd61a 100644 --- a/stepmania/src/smpackage/smpackage.dsp +++ b/stepmania/src/smpackage/smpackage.dsp @@ -65,6 +65,7 @@ LINK32=link.exe # PROP Use_Debug_Libraries 1 # PROP Output_Dir "../../" # PROP Intermediate_Dir "Debug" +# PROP Ignore_Export_Lib 0 # PROP Target_Dir "" # ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /Yu"stdafx.h" /FD /GZ /c # ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_AFXDLL" /Yu"stdafx.h" /FD /GZ /c @@ -77,7 +78,7 @@ BSC32=bscmake.exe # ADD BSC32 /nologo LINK32=link.exe # ADD BASE LINK32 /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept -# ADD LINK32 /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept +# ADD LINK32 /nologo /subsystem:windows /debug /machine:I386 /out:"../../smpackage-debug.exe" /pdbtype:sept !ENDIF diff --git a/stepmania/src/smpackage/smpackage.rc b/stepmania/src/smpackage/smpackage.rc index e673150f13..fa9f3e7a17 100644 --- a/stepmania/src/smpackage/smpackage.rc +++ b/stepmania/src/smpackage/smpackage.rc @@ -93,13 +93,19 @@ STYLE DS_MODALFRAME | DS_CENTER | WS_POPUP | WS_CAPTION CAPTION "Stepmania Package Manager" FONT 8, "MS Sans Serif" BEGIN - EDITTEXT IDC_EDIT_MESSAGE,5,45,320,160,ES_MULTILINE | + EDITTEXT IDC_EDIT_MESSAGE1,5,45,320,45,ES_MULTILINE | ES_AUTOHSCROLL | ES_READONLY | NOT WS_BORDER | NOT WS_TABSTOP DEFPUSHBUTTON "Finish >",IDOK,200,215,55,15 PUSHBUTTON "Cancel",IDCANCEL,275,215,50,15 PUSHBUTTON "< Back",IDC_BUTTON_BACK,145,215,55,15,WS_DISABLED CONTROL 133,IDC_STATIC,"Static",SS_BITMAP,0,0,258,37 + EDITTEXT IDC_EDIT_MESSAGE3,5,180,320,30,ES_MULTILINE | + ES_AUTOHSCROLL | ES_READONLY | NOT WS_BORDER | NOT + WS_TABSTOP + EDITTEXT IDC_EDIT_MESSAGE2,5,90,320,87,ES_MULTILINE | + ES_AUTOHSCROLL | ES_READONLY | WS_VSCROLL | NOT + WS_TABSTOP END diff --git a/stepmania/src/smpackage/smpackageDlg.cpp b/stepmania/src/smpackage/smpackageDlg.cpp index 26bc793772..6fb7910378 100644 --- a/stepmania/src/smpackage/smpackageDlg.cpp +++ b/stepmania/src/smpackage/smpackageDlg.cpp @@ -6,6 +6,7 @@ #include "smpackageDlg.h" #include "../RageUtil.h" + #ifdef _DEBUG #define new DEBUG_NEW #undef THIS_FILE @@ -190,7 +191,7 @@ void CSmpackageDlg::OnButtonExport() //MessageBox( ssprintf("sZipFilePath is '%s'", sZipFilePath), "", MB_OK ); try { - m_zip.Open( sZipFilePath, CZipArchive::create ); + m_zip.Open( sZipFilePath, CZipArchive::zipCreate ); } catch( CException* e ) {