ZipEngine 1.0 for BlitzMax

Rem
	ZipDemo
	Written by Thomas Mayer
	
	Notes:
	Demonstration of the zipping files up into an archive and then getting them back
	using zipEngine
End Rem

Import pub.zipengine

Main() 'Call our entry point

Function Main()
	' Create our zipwriter object (creates zips)
	Local zwObject:ZipWriter = New ZipWriter
	' Create our zipreader object (extracts from zips)
	Local zrObject:ZipReader = New ZipReader
	
	' Example 1
	' Open the zip up for creation.  We pass
	' false in to tell the ZipWriter that we do
	' not wish to append
	If ( zwObject.OpenZip("data.zip", False) ) Then
		zwObject.AddFile("testdata.txt")
		zwObject.AddFile("zipdemo.bmx")
		zwObject.CloseZip()
	End If

	' Example 2
	' Open the zip file we just created and extract
	' a file
	If ( zrObject.OpenZip("data.zip") ) Then
		zrObject.ExtractFileToDisk("testdata.txt", "extracted_testdata.txt")
		zrObject.ExtractFileToDisk("zipdemo.bmx", "extracted_zipdemo.bmx")
		zrObject.CloseZip()
	End If
	
	' Example 3
	Local fileBuffer:TRamStream = Null
	' Open the zip file we just created and extract
	' a file to ram
	If ( zrObject.OpenZip("data.zip") ) Then
		fileBuffer = zrObject.ExtractFile("testdata.txt")
		zrObject.CloseZip()
	End If
	
End Function

Import Pub.ZLib
Import brl.basic
Import BRL.Stream
Import "zip.c"
Import "unzip.c"
Import "ioapi.c"
Import "bmxsupport.c"

Rem
bbdoc: Append Modes
End Rem
Const APPEND_STATUS_CREATE			= 0
Const APPEND_STATUS_CREATEAFTER		= 1
Const APPEND_STATUS_ADDINZIP		= 2

Rem
bbdoc: Compression methods
End Rem
Const Z_DEFLATED					= 8

Rem
bbdoc: Compression levels
End Rem
Const Z_NO_COMPRESSION				= 0
Const Z_BEST_SPEED				= 1
Const Z_BEST_COMPRESSION			= 9
Const Z_DEFAULT_COMPRESSION		= -1

Rem
bbdoc: Compare modes
End Rem
Const UNZ_CASE_CHECK				= 1
Const UNZ_NO_CASE_CHECK			= 2

Rem
bbdoc: Result Codes
End Rem
Const UNZ_OK						= 0
Const UNZ_END_OF_LIST_OF_FILE		= -100
Const UNZ_EOF						= 0
Const UNZ_PARAMERROR				= -102
Const UNZ_BADZIPFILE				= -103
Const UNZ_INTERNALERROR			= -104
Const UNZ_CRCERROR				= -105

Extern

Rem
bbdoc: Open new zip file (returns zipFile pointer)
End Rem
Function zipOpen:Byte Ptr( fileName:Byte Ptr, append:Int )

Rem
bbdoc: Closes an open zip file
End Rem
Function zipClose( zipFilePtr:Byte Ptr, archiveName:Byte Ptr )

Rem
bbdoc: Open a file inside the zip file
End Rem
Function zipOpenNewFileInZip( zipFilePtr:Byte Ptr, fileName:Byte Ptr, zipfi, ..
							extrafield_local, size_extrafield_local, ..
							extrafield_global, size_extrafield_global, ..
							comment:Byte Ptr, compressionMethod:Int, ..
							level:Int )
							
Rem
bbdoc: Write into a zip file
End Rem
Function zipWriteInFileInZip( zipFilePtr:Byte Ptr, buffer:Byte Ptr, bufferLength:Int )

Rem
bbdoc: Open a zip file for unzip
End Rem
Function unzOpen:Byte Ptr( zipFileName:Byte Ptr )

Rem
bbdoc: Return status of desired file and sets the unzipped focus to it
End Rem
Function unzLocateFile:Int( zipFilePtr:Byte Ptr, fileName:Byte Ptr, caseCheck:Int )

Rem
bbdoc: Opens the currently focused file
End Rem
Function unzOpenCurrentFile:Int( zipFilePtr:Byte Ptr )

Rem
bbdoc: Gets info about the current file
End Rem
Function unzGetCurrentFileSize:Int( zipFilePtr:Byte Ptr )

Rem
bbdoc: Read current file, returns number of bytes
End Rem
Function unzReadCurrentFile:Int( zipFilePtr:Byte Ptr, buffer:Byte Ptr, size:Int )

Rem
bbdoc: Close current file
End Rem
Function unzCloseCurrentFile( zipFilePtr:Byte Ptr )

Rem
bbdoc: Close unzip zip file
End Rem
Function unzClose( zipFilePtr:Byte Ptr )

EndExtern

Strict
Framework BRL.Blitz
Import BRL.FileSystem
Import BRL.LinkedList
Import BRL.StandardIO

Public

' ----------------------------------------------------------------
' example on using the classes
' ----------------------------------------------------------------

' open the zip to read
Local test:TStream=ReadFile("D:/develop/ggtray.zip")

If test Then
	' read in the file headers
	Local reader:TZipReader=TZipReader.create(test,False,False)
	' we are done with the file
	CloseStream(test)

	Print("-------------------------------")
	Print(reader.getFileCount()+" files in the zip")
	
	' show the files in the zip
	Local temp:SZipFileEntry
	For temp=EachIn reader.FileList
		Print(temp.zipFileName)		
	Next
EndIf

' ----------------------------------------------------------------
' the supporting cast
' ----------------------------------------------------------------

' the fields crc-32, compressed size
' And uncompressed size are set To zero in the Local
' header
Const ZIP_INFO_IN_DATA_DESCRIPTOR:Short = $0008  
									    																
Type SZIPFileDataDescriptor Extends PACK_STRUCT
	Const size:Int=12
	
	Field CRC32:Int
	Field CompressedSize:Int
	Field UncompressedSize:Int
	
	Method fillFromBank(databank:TBank,offset:Int=0)
		CRC32=PeekInt(databank,offset)
		CompressedSize=PeekInt(databank,offset+4)
		UncompressedSize=PeekInt(databank,offset+8)
	EndMethod
EndType

Type SZIPFileHeader Extends PACK_STRUCT
	Const size:Int=30

	Field Sig:Int
	Field VersionToExtract:Short
	Field GeneralBitFlag:Short
	Field CompressionMethod:Short
	Field LastModFileTime:Short
	Field LastModFileDate:Short
	Field DataDescriptor:SZIPFileDataDescriptor
	Field FilenameLength:Short
	Field ExtraFieldLength:Short
	
	Method New()
		DataDescriptor=New SZIPFileDataDescriptor
	EndMethod
	
	Method fillFromBank(databank:TBank,offset:Int=0)
		Sig=PeekInt(databank,offset)
		VersionToExtract=PeekShort(databank,offset+4)
		GeneralBitFlag=PeekShort(databank,offset+6)
		CompressionMethod=PeekShort(databank,offset+8)
		LastModFileTime=PeekShort(databank,offset+10)
		LastModFileDate=PeekShort(databank,offset+12)
		DataDescriptor.CRC32=PeekInt(databank,offset+14)
		DataDescriptor.CompressedSize=PeekInt(databank,offset+18)
		DataDescriptor.UncompressedSize=PeekInt(databank,offset+22)
		FilenameLength=PeekShort(databank,offset+26)
		ExtraFieldLength=PeekShort(databank,offset+28)
	EndMethod		
EndType

Type SZipFileEntry
	Field zipFileName:String
	Field simpleFileName:String
	Field path:String
	Field fileDataPosition:Int  ' position of compressed data in file
	Field header:SZIPFileHeader

	Function create:SZipFileEntry()
		Return New SZipFileEntry
	EndFunction

	Method New()
		header=New SZipFileHeader
	EndMethod

	Method Less:Int(other:SZipFileEntry)
		Return simpleFileName.Compare(other.simpleFileName)<0
	EndMethod

	Method EqEq:Int(other:SZipFileEntry)
		Return simpleFileName.Compare(other.simpleFileName)=0
	EndMethod
	
	Method Compare(other:Object)
		If SZipFileEntry(other) Return simpleFileName.Compare(SZipFileEntry(other).simpleFileName) Else Return -1
	EndMethod
EndType

Type TZipReader

	Field zipFile:TStream
	Field FileList:TList ' core::array<SZipFileEntry>
	Field IgnoreCase:Int
	Field IgnorePaths:Int

	Method New()
		FileList=New TList
	EndMethod

	Function create:TZipReader(file:TStream,bIgnoreCase:Int,bIgnorePaths:Int)
		If Not file Then Return Null
		
		Local retval:TZipReader=New TZipReader
		retval.zipFile=file
		retval.IgnoreCase=bIgnoreCase
		retval.IgnorePaths=bIgnorePaths

		' scan Local headers
		While retval.scanLocalHeader() Wend

		' prepare file index For binary search
		retval.FileList.sort()
		Return retval		
	EndFunction
	
	' returns count of files in archive
	Method getFileCount:Int()
		Return FileList.Count()
	EndMethod

	' returns data of file
	Method getFileInfo:SZipFileEntry(index:Int)
		If index<0 Or index>=FileList.Count() Then Throw "TZipReader.getFileInfo(): Invalid index "+index
		Return SZipFileEntry(FileList.ValueAtIndex(index))
	EndMethod

	' returns SZipFileEntry
	Method findFile:SZipFileEntry(simpleFilename:String)
		Local retval:SZipFileEntry=Null
		
		Local entry:SZipFileEntry=SZipFileEntry.create()
		entry.simpleFileName = simpleFilename
	
		If (IgnoreCase) Then entry.simpleFileName=entry.simpleFileName.ToLower()
	
		If (IgnorePaths) Then deletePathFromFilename(Varptr(entry.simpleFileName))

		Local link:TLink=FileList.FindLink(entry)
		
		If link
			retval=SZipFileEntry(link.Value())
		Else
			?Debug
			For Local i:Int=0 To FileList.Count()-1
				If (getFileInfo(i).simpleFileName = entry.simpleFileName)
					DebugLog("File "+entry.simpleFileName+" in archive but Not found.")
					Exit
				EndIf
			Next
			?
		EndIf
		
		Return retval
	EndMethod

	' scans For a Local header, returns False If there is no more Local file header.
	Method scanLocalHeader:Int()

		Local tempbank:TBank
	
		Local entry:SZipFileEntry=SZipFileEntry.create()
		entry.fileDataPosition = 0

		' populate the header with what was read		
		If Not entry.header.fillFromReader(zipFile,SZIPFileHeader.size,0,0) Then Throw "TZipReader.scanLocalHeader(): unable to read from file"
		
		DebugLog(entry.header.CompressionMethod)
				
		If entry.header.Sig <> $04034b50 Then Return False ' Local file headers End here.
	
		' read filename
		entry.zipFileName=ReadString(zipFile,entry.header.FilenameLength)

		extractFilename(entry)
	
		' move forward length of extra field.
		If (entry.header.ExtraFieldLength)	
			SeekStream(zipFile,StreamPos(zipFile)+entry.header.ExtraFieldLength)
		EndIf
	
		' If bit 3 was set, read DataDescriptor, following after the compressed data
		If (entry.header.GeneralBitFlag & ZIP_INFO_IN_DATA_DESCRIPTOR)
			' read data descriptor
			entry.header.DataDescriptor.fillFromReader(zipFile,SZIPFileDataDescriptor.size,0,0)
		EndIf
	
		' store position in file
		entry.fileDataPosition = StreamPos(zipFile)
	
		' move forward length of data
		SeekStream(zipFile,StreamPos(zipFile)+entry.header.DataDescriptor.CompressedSize)

		?Debug
		DebugLog("added file "+entry.simpleFileName+" from archive")
		?
	
		FileList.AddLast(entry)
	
		Return True
	EndMethod

	' splits filename from zip file into useful filenames And paths
	Method extractFilename(entry:SZipFileEntry)

		' check length of filename
		If Not entry.header.FilenameLength Then Return
	
		' change the case if ignore is on
		If (IgnoreCase) Then entry.zipFileName=entry.zipFileName.ToLower()
	
		' make sure there is a path
		Local thereIsAPath:Int=(ExtractDir(entry.zipFileName)<>"<bad_dir>")
	
		' store just the filename
		entry.simpleFileName = StripDir(entry.zipFileName)
		
		' store an empty path
		If (thereIsAPath) Then entry.path = ExtractDir(entry.zipFileName) Else entry.path=""
	
		' simpleFileName must be zipFileName if not to ignore paths
		If Not IgnorePaths
			entry.simpleFileName = entry.zipFileName  ' thanks To Pr3t3nd3r For this fix
		EndIf
	EndMethod

	' deletes the path from a filename
	Method deletePathFromFilename(filename:String Ptr)
		filename[0]=StripDir(filename[0])
	EndMethod

EndType

' generic type for reading in PACK_STRUCT structures from files
Type PACK_STRUCT
	Global size:Int=0
			
	Method fillFromBank(bank:TBank,start:Int)
	EndMethod

	' returns true if successful
	Method fillFromReader:Int(fileToRead:TStream,tbsize:Int,readeroffset:Int=0,bankoffset:Int=0)
		If Not fileToRead Then Return False
		
		' create the bank
		Local structbank:TBank=CreateBank(tbsize)
		
		' read from the file
		structbank.Read(fileToRead,readeroffset,tbsize)
		
		' populate the STRUCT with what was read
		fillFromBank(structbank,bankoffset)
		
		' clear out the bank
		structbank=Null
		
		Return True
	EndMethod
	
	Method getBank:TBank()
		Return Null
	EndMethod	
EndType