Mark Adler
14 years ago
parent
086e982175
commit
4b5a43a219
152 changed files with 14538 additions and 12586 deletions
@ -0,0 +1,153 @@ |
||||
---------------------------------------------------------------- |
||||
-- ZLib for Ada thick binding. -- |
||||
-- -- |
||||
-- Copyright (C) 2002-2003 Dmitriy Anisimkov -- |
||||
-- -- |
||||
-- Open source license information is in the zlib.ads file. -- |
||||
---------------------------------------------------------------- |
||||
-- Continuous test for ZLib multithreading. If the test is fail |
||||
-- Wou should provide thread safe allocation routines for the Z_Stream. |
||||
-- |
||||
-- $Id: mtest.adb,v 1.2 2003/08/12 12:11:05 vagul Exp $ |
||||
|
||||
with ZLib; |
||||
with Ada.Streams; |
||||
with Ada.Numerics.Discrete_Random; |
||||
with Ada.Text_IO; |
||||
with Ada.Exceptions; |
||||
with Ada.Task_Identification; |
||||
|
||||
procedure MTest is |
||||
use Ada.Streams; |
||||
use ZLib; |
||||
|
||||
Stop : Boolean := False; |
||||
|
||||
pragma Atomic (Stop); |
||||
|
||||
subtype Visible_Symbols is Stream_Element range 16#20# .. 16#7E#; |
||||
|
||||
package Random_Elements is |
||||
new Ada.Numerics.Discrete_Random (Visible_Symbols); |
||||
|
||||
task type Test_Task; |
||||
|
||||
task body Test_Task is |
||||
Buffer : Stream_Element_Array (1 .. 100_000); |
||||
Gen : Random_Elements.Generator; |
||||
|
||||
Buffer_First : Stream_Element_Offset; |
||||
Compare_First : Stream_Element_Offset; |
||||
|
||||
Deflate : Filter_Type; |
||||
Inflate : Filter_Type; |
||||
|
||||
procedure Further (Item : in Stream_Element_Array); |
||||
|
||||
procedure Read_Buffer |
||||
(Item : out Ada.Streams.Stream_Element_Array; |
||||
Last : out Ada.Streams.Stream_Element_Offset); |
||||
|
||||
------------- |
||||
-- Further -- |
||||
------------- |
||||
|
||||
procedure Further (Item : in Stream_Element_Array) is |
||||
|
||||
procedure Compare (Item : in Stream_Element_Array); |
||||
|
||||
------------- |
||||
-- Compare -- |
||||
------------- |
||||
|
||||
procedure Compare (Item : in Stream_Element_Array) is |
||||
Next_First : Stream_Element_Offset := Compare_First + Item'Length; |
||||
begin |
||||
if Buffer (Compare_First .. Next_First - 1) /= Item then |
||||
raise Program_Error; |
||||
end if; |
||||
|
||||
Compare_First := Next_First; |
||||
end Compare; |
||||
|
||||
procedure Compare_Write is new ZLib.Write (Write => Compare); |
||||
begin |
||||
Compare_Write (Inflate, Item, No_Flush); |
||||
end Further; |
||||
|
||||
----------------- |
||||
-- Read_Buffer -- |
||||
----------------- |
||||
|
||||
procedure Read_Buffer |
||||
(Item : out Ada.Streams.Stream_Element_Array; |
||||
Last : out Ada.Streams.Stream_Element_Offset) |
||||
is |
||||
Buff_Diff : Stream_Element_Offset := Buffer'Last - Buffer_First; |
||||
Next_First : Stream_Element_Offset; |
||||
begin |
||||
if Item'Length <= Buff_Diff then |
||||
Last := Item'Last; |
||||
|
||||
Next_First := Buffer_First + Item'Length; |
||||
|
||||
Item := Buffer (Buffer_First .. Next_First - 1); |
||||
|
||||
Buffer_First := Next_First; |
||||
else |
||||
Last := Item'First + Buff_Diff; |
||||
Item (Item'First .. Last) := Buffer (Buffer_First .. Buffer'Last); |
||||
Buffer_First := Buffer'Last + 1; |
||||
end if; |
||||
end Read_Buffer; |
||||
|
||||
procedure Translate is new Generic_Translate |
||||
(Data_In => Read_Buffer, |
||||
Data_Out => Further); |
||||
|
||||
begin |
||||
Random_Elements.Reset (Gen); |
||||
|
||||
Buffer := (others => 20); |
||||
|
||||
Main : loop |
||||
for J in Buffer'Range loop |
||||
Buffer (J) := Random_Elements.Random (Gen); |
||||
|
||||
Deflate_Init (Deflate); |
||||
Inflate_Init (Inflate); |
||||
|
||||
Buffer_First := Buffer'First; |
||||
Compare_First := Buffer'First; |
||||
|
||||
Translate (Deflate); |
||||
|
||||
if Compare_First /= Buffer'Last + 1 then |
||||
raise Program_Error; |
||||
end if; |
||||
|
||||
Ada.Text_IO.Put_Line |
||||
(Ada.Task_Identification.Image |
||||
(Ada.Task_Identification.Current_Task) |
||||
& Stream_Element_Offset'Image (J) |
||||
& ZLib.Count'Image (Total_Out (Deflate))); |
||||
|
||||
Close (Deflate); |
||||
Close (Inflate); |
||||
|
||||
exit Main when Stop; |
||||
end loop; |
||||
end loop Main; |
||||
exception |
||||
when E : others => |
||||
Ada.Text_IO.Put_Line (Ada.Exceptions.Exception_Information (E)); |
||||
Stop := True; |
||||
end Test_Task; |
||||
|
||||
Test : array (1 .. 4) of Test_Task; |
||||
|
||||
pragma Unreferenced (Test); |
||||
|
||||
begin |
||||
null; |
||||
end MTest; |
||||
@ -0,0 +1,151 @@ |
||||
---------------------------------------------------------------- |
||||
-- ZLib for Ada thick binding. -- |
||||
-- -- |
||||
-- Copyright (C) 2002-2003 Dmitriy Anisimkov -- |
||||
-- -- |
||||
-- Open source license information is in the zlib.ads file. -- |
||||
---------------------------------------------------------------- |
||||
|
||||
-- $Id: read.adb,v 1.7 2003/08/12 12:12:35 vagul Exp $ |
||||
|
||||
-- Test/demo program for the generic read interface. |
||||
|
||||
with Ada.Numerics.Discrete_Random; |
||||
with Ada.Streams; |
||||
with Ada.Text_IO; |
||||
|
||||
with ZLib; |
||||
|
||||
procedure Read is |
||||
|
||||
use Ada.Streams; |
||||
|
||||
------------------------------------ |
||||
-- Test configuration parameters -- |
||||
------------------------------------ |
||||
|
||||
File_Size : Stream_Element_Offset := 100_000; |
||||
|
||||
Continuous : constant Boolean := False; |
||||
-- If this constant is True, the test would be repeated again and again, |
||||
-- with increment File_Size for every iteration. |
||||
|
||||
Header : constant ZLib.Header_Type := ZLib.Default; |
||||
-- Do not use Header other than Default in ZLib versions 1.1.4 and older. |
||||
|
||||
Init_Random : constant := 8; |
||||
-- We are using the same random sequence, in case of we catch bug, |
||||
-- so we would be able to reproduce it. |
||||
|
||||
-- End -- |
||||
|
||||
Pack_Size : Stream_Element_Offset; |
||||
Offset : Stream_Element_Offset; |
||||
|
||||
Filter : ZLib.Filter_Type; |
||||
|
||||
subtype Visible_Symbols |
||||
is Stream_Element range 16#20# .. 16#7E#; |
||||
|
||||
package Random_Elements is new |
||||
Ada.Numerics.Discrete_Random (Visible_Symbols); |
||||
|
||||
Gen : Random_Elements.Generator; |
||||
Period : constant Stream_Element_Offset := 200; |
||||
-- Period constant variable for random generator not to be very random. |
||||
-- Bigger period, harder random. |
||||
|
||||
Read_Buffer : Stream_Element_Array (1 .. 2048); |
||||
Read_First : Stream_Element_Offset; |
||||
Read_Last : Stream_Element_Offset; |
||||
|
||||
procedure Reset; |
||||
|
||||
procedure Read |
||||
(Item : out Stream_Element_Array; |
||||
Last : out Stream_Element_Offset); |
||||
-- this procedure is for generic instantiation of |
||||
-- ZLib.Read |
||||
-- reading data from the File_In. |
||||
|
||||
procedure Read is new ZLib.Read (Read, Read_Buffer, Read_First, Read_Last); |
||||
|
||||
---------- |
||||
-- Read -- |
||||
---------- |
||||
|
||||
procedure Read |
||||
(Item : out Stream_Element_Array; |
||||
Last : out Stream_Element_Offset) is |
||||
begin |
||||
Last := Stream_Element_Offset'Min |
||||
(Item'Last, |
||||
Item'First + File_Size - Offset); |
||||
|
||||
for J in Item'First .. Last loop |
||||
if J < Item'First + Period then |
||||
Item (J) := Random_Elements.Random (Gen); |
||||
else |
||||
Item (J) := Item (J - Period); |
||||
end if; |
||||
|
||||
Offset := Offset + 1; |
||||
end loop; |
||||
end Read; |
||||
|
||||
----------- |
||||
-- Reset -- |
||||
----------- |
||||
|
||||
procedure Reset is |
||||
begin |
||||
Random_Elements.Reset (Gen, Init_Random); |
||||
Pack_Size := 0; |
||||
Offset := 1; |
||||
Read_First := Read_Buffer'Last + 1; |
||||
end Reset; |
||||
|
||||
begin |
||||
Ada.Text_IO.Put_Line ("ZLib " & ZLib.Version); |
||||
|
||||
loop |
||||
for Level in ZLib.Compression_Level'Range loop |
||||
|
||||
Ada.Text_IO.Put ("Level =" |
||||
& ZLib.Compression_Level'Image (Level)); |
||||
|
||||
-- Deflate using generic instantiation. |
||||
|
||||
ZLib.Deflate_Init |
||||
(Filter, |
||||
Level, |
||||
Header => Header); |
||||
|
||||
Reset; |
||||
|
||||
Ada.Text_IO.Put |
||||
(Stream_Element_Offset'Image (File_Size) & " ->"); |
||||
|
||||
loop |
||||
declare |
||||
Buffer : Stream_Element_Array (1 .. 1024); |
||||
Last : Stream_Element_Offset; |
||||
begin |
||||
Read (Filter, Buffer, Last); |
||||
|
||||
Pack_Size := Pack_Size + Last - Buffer'First + 1; |
||||
|
||||
exit when Last < Buffer'Last; |
||||
end; |
||||
end loop; |
||||
|
||||
Ada.Text_IO.Put_Line (Stream_Element_Offset'Image (Pack_Size)); |
||||
|
||||
ZLib.Close (Filter); |
||||
end loop; |
||||
|
||||
exit when not Continuous; |
||||
|
||||
File_Size := File_Size + 1; |
||||
end loop; |
||||
end Read; |
||||
@ -0,0 +1,52 @@ |
||||
|
||||
ZLib for Ada thick binding (ZLib.Ada) |
||||
Release 1.2 |
||||
|
||||
ZLib.Ada is a thick binding interface to the popular ZLib data |
||||
compression library, available at http://www.gzip.org/zlib/. |
||||
It provides Ada-style access to the ZLib C library. |
||||
|
||||
|
||||
Here are the main changes since ZLib.Ada 1.1: |
||||
|
||||
- The default header type has a name "Default" now. Auto is used only for |
||||
automatic GZip/ZLib header detection. |
||||
|
||||
- Added test for multitasking mtest.adb. |
||||
|
||||
- Added GNAT project file zlib.gpr. |
||||
|
||||
|
||||
How to build ZLib.Ada under GNAT |
||||
|
||||
You should have the ZLib library already build on your computer, before |
||||
building ZLib.Ada. Make the directory of ZLib.Ada sources current and |
||||
issue the command: |
||||
|
||||
gnatmake test -largs -L<directory where libz.a is> -lz |
||||
|
||||
Or use the GNAT project file build for GNAT 3.15 or later: |
||||
|
||||
gnatmake -Pzlib.gpr -L<directory where libz.a is> |
||||
|
||||
|
||||
How to build ZLib.Ada under Aonix ObjectAda for Win32 7.2.2 |
||||
|
||||
1. Make a project with all *.ads and *.adb files from the distribution. |
||||
2. Build the libz.a library from the ZLib C sources. |
||||
3. Rename libz.a to z.lib. |
||||
4. Add the library z.lib to the project. |
||||
5. Add the libc.lib library from the ObjectAda distribution to the project. |
||||
6. Build the executable using test.adb as a main procedure. |
||||
|
||||
|
||||
How to use ZLib.Ada |
||||
|
||||
The source files test.adb and read.adb are small demo programs that show |
||||
the main functionality of ZLib.Ada. |
||||
|
||||
The routines from the package specifications are commented. |
||||
|
||||
|
||||
Homepage: http://zlib-ada.sourceforge.net/ |
||||
Author: Dmitriy Anisimkov <anisimkov@yahoo.com> |
||||
@ -0,0 +1,463 @@ |
||||
---------------------------------------------------------------- |
||||
-- ZLib for Ada thick binding. -- |
||||
-- -- |
||||
-- Copyright (C) 2002-2003 Dmitriy Anisimkov -- |
||||
-- -- |
||||
-- Open source license information is in the zlib.ads file. -- |
||||
---------------------------------------------------------------- |
||||
|
||||
-- $Id: test.adb,v 1.17 2003/08/12 12:13:30 vagul Exp $ |
||||
|
||||
-- The program has a few aims. |
||||
-- 1. Test ZLib.Ada95 thick binding functionality. |
||||
-- 2. Show the example of use main functionality of the ZLib.Ada95 binding. |
||||
-- 3. Build this program automatically compile all ZLib.Ada95 packages under |
||||
-- GNAT Ada95 compiler. |
||||
|
||||
with ZLib.Streams; |
||||
with Ada.Streams.Stream_IO; |
||||
with Ada.Numerics.Discrete_Random; |
||||
|
||||
with Ada.Text_IO; |
||||
|
||||
with Ada.Calendar; |
||||
|
||||
procedure Test is |
||||
|
||||
use Ada.Streams; |
||||
use Stream_IO; |
||||
|
||||
------------------------------------ |
||||
-- Test configuration parameters -- |
||||
------------------------------------ |
||||
|
||||
File_Size : Count := 100_000; |
||||
Continuous : constant Boolean := False; |
||||
|
||||
Header : constant ZLib.Header_Type := ZLib.Default; |
||||
-- ZLib.None; |
||||
-- ZLib.Auto; |
||||
-- ZLib.GZip; |
||||
-- Do not use Header other then Default in ZLib versions 1.1.4 |
||||
-- and older. |
||||
|
||||
Strategy : constant ZLib.Strategy_Type := ZLib.Default_Strategy; |
||||
Init_Random : constant := 10; |
||||
|
||||
-- End -- |
||||
|
||||
In_File_Name : constant String := "testzlib.in"; |
||||
-- Name of the input file |
||||
|
||||
Z_File_Name : constant String := "testzlib.zlb"; |
||||
-- Name of the compressed file. |
||||
|
||||
Out_File_Name : constant String := "testzlib.out"; |
||||
-- Name of the decompressed file. |
||||
|
||||
File_In : File_Type; |
||||
File_Out : File_Type; |
||||
File_Back : File_Type; |
||||
File_Z : ZLib.Streams.Stream_Type; |
||||
|
||||
Filter : ZLib.Filter_Type; |
||||
|
||||
Time_Stamp : Ada.Calendar.Time; |
||||
|
||||
procedure Generate_File; |
||||
-- Generate file of spetsified size with some random data. |
||||
-- The random data is repeatable, for the good compression. |
||||
|
||||
procedure Compare_Streams |
||||
(Left, Right : in out Root_Stream_Type'Class); |
||||
-- The procedure compearing data in 2 streams. |
||||
-- It is for compare data before and after compression/decompression. |
||||
|
||||
procedure Compare_Files (Left, Right : String); |
||||
-- Compare files. Based on the Compare_Streams. |
||||
|
||||
procedure Copy_Streams |
||||
(Source, Target : in out Root_Stream_Type'Class; |
||||
Buffer_Size : in Stream_Element_Offset := 1024); |
||||
-- Copying data from one stream to another. It is for test stream |
||||
-- interface of the library. |
||||
|
||||
procedure Data_In |
||||
(Item : out Stream_Element_Array; |
||||
Last : out Stream_Element_Offset); |
||||
-- this procedure is for generic instantiation of |
||||
-- ZLib.Generic_Translate. |
||||
-- reading data from the File_In. |
||||
|
||||
procedure Data_Out (Item : in Stream_Element_Array); |
||||
-- this procedure is for generic instantiation of |
||||
-- ZLib.Generic_Translate. |
||||
-- writing data to the File_Out. |
||||
|
||||
procedure Stamp; |
||||
-- Store the timestamp to the local variable. |
||||
|
||||
procedure Print_Statistic (Msg : String; Data_Size : ZLib.Count); |
||||
-- Print the time statistic with the message. |
||||
|
||||
procedure Translate is new ZLib.Generic_Translate |
||||
(Data_In => Data_In, |
||||
Data_Out => Data_Out); |
||||
-- This procedure is moving data from File_In to File_Out |
||||
-- with compression or decompression, depend on initialization of |
||||
-- Filter parameter. |
||||
|
||||
------------------- |
||||
-- Compare_Files -- |
||||
------------------- |
||||
|
||||
procedure Compare_Files (Left, Right : String) is |
||||
Left_File, Right_File : File_Type; |
||||
begin |
||||
Open (Left_File, In_File, Left); |
||||
Open (Right_File, In_File, Right); |
||||
Compare_Streams (Stream (Left_File).all, Stream (Right_File).all); |
||||
Close (Left_File); |
||||
Close (Right_File); |
||||
end Compare_Files; |
||||
|
||||
--------------------- |
||||
-- Compare_Streams -- |
||||
--------------------- |
||||
|
||||
procedure Compare_Streams |
||||
(Left, Right : in out Ada.Streams.Root_Stream_Type'Class) |
||||
is |
||||
Left_Buffer, Right_Buffer : Stream_Element_Array (0 .. 16#FFF#); |
||||
Left_Last, Right_Last : Stream_Element_Offset; |
||||
begin |
||||
loop |
||||
Read (Left, Left_Buffer, Left_Last); |
||||
Read (Right, Right_Buffer, Right_Last); |
||||
|
||||
if Left_Last /= Right_Last then |
||||
Ada.Text_IO.Put_Line ("Compare error :" |
||||
& Stream_Element_Offset'Image (Left_Last) |
||||
& " /= " |
||||
& Stream_Element_Offset'Image (Right_Last)); |
||||
|
||||
raise Constraint_Error; |
||||
|
||||
elsif Left_Buffer (0 .. Left_Last) |
||||
/= Right_Buffer (0 .. Right_Last) |
||||
then |
||||
Ada.Text_IO.Put_Line ("ERROR: IN and OUT files is not equal."); |
||||
raise Constraint_Error; |
||||
|
||||
end if; |
||||
|
||||
exit when Left_Last < Left_Buffer'Last; |
||||
end loop; |
||||
end Compare_Streams; |
||||
|
||||
------------------ |
||||
-- Copy_Streams -- |
||||
------------------ |
||||
|
||||
procedure Copy_Streams |
||||
(Source, Target : in out Ada.Streams.Root_Stream_Type'Class; |
||||
Buffer_Size : in Stream_Element_Offset := 1024) |
||||
is |
||||
Buffer : Stream_Element_Array (1 .. Buffer_Size); |
||||
Last : Stream_Element_Offset; |
||||
begin |
||||
loop |
||||
Read (Source, Buffer, Last); |
||||
Write (Target, Buffer (1 .. Last)); |
||||
|
||||
exit when Last < Buffer'Last; |
||||
end loop; |
||||
end Copy_Streams; |
||||
|
||||
------------- |
||||
-- Data_In -- |
||||
------------- |
||||
|
||||
procedure Data_In |
||||
(Item : out Stream_Element_Array; |
||||
Last : out Stream_Element_Offset) is |
||||
begin |
||||
Read (File_In, Item, Last); |
||||
end Data_In; |
||||
|
||||
-------------- |
||||
-- Data_Out -- |
||||
-------------- |
||||
|
||||
procedure Data_Out (Item : in Stream_Element_Array) is |
||||
begin |
||||
Write (File_Out, Item); |
||||
end Data_Out; |
||||
|
||||
------------------- |
||||
-- Generate_File -- |
||||
------------------- |
||||
|
||||
procedure Generate_File is |
||||
subtype Visible_Symbols is Stream_Element range 16#20# .. 16#7E#; |
||||
|
||||
package Random_Elements is |
||||
new Ada.Numerics.Discrete_Random (Visible_Symbols); |
||||
|
||||
Gen : Random_Elements.Generator; |
||||
Buffer : Stream_Element_Array := (1 .. 77 => 16#20#) & 10; |
||||
|
||||
Buffer_Count : constant Count := File_Size / Buffer'Length; |
||||
-- Number of same buffers in the packet. |
||||
|
||||
Density : constant Count := 30; -- from 0 to Buffer'Length - 2; |
||||
|
||||
procedure Fill_Buffer (J, D : in Count); |
||||
-- Change the part of the buffer. |
||||
|
||||
----------------- |
||||
-- Fill_Buffer -- |
||||
----------------- |
||||
|
||||
procedure Fill_Buffer (J, D : in Count) is |
||||
begin |
||||
for K in 0 .. D loop |
||||
Buffer |
||||
(Stream_Element_Offset ((J + K) mod (Buffer'Length - 1) + 1)) |
||||
:= Random_Elements.Random (Gen); |
||||
|
||||
end loop; |
||||
end Fill_Buffer; |
||||
|
||||
begin |
||||
Random_Elements.Reset (Gen, Init_Random); |
||||
|
||||
Create (File_In, Out_File, In_File_Name); |
||||
|
||||
Fill_Buffer (1, Buffer'Length - 2); |
||||
|
||||
for J in 1 .. Buffer_Count loop |
||||
Write (File_In, Buffer); |
||||
|
||||
Fill_Buffer (J, Density); |
||||
end loop; |
||||
|
||||
-- fill remain size. |
||||
|
||||
Write |
||||
(File_In, |
||||
Buffer |
||||
(1 .. Stream_Element_Offset |
||||
(File_Size - Buffer'Length * Buffer_Count))); |
||||
|
||||
Flush (File_In); |
||||
Close (File_In); |
||||
end Generate_File; |
||||
|
||||
--------------------- |
||||
-- Print_Statistic -- |
||||
--------------------- |
||||
|
||||
procedure Print_Statistic (Msg : String; Data_Size : ZLib.Count) is |
||||
use Ada.Calendar; |
||||
use Ada.Text_IO; |
||||
|
||||
package Count_IO is new Integer_IO (ZLib.Count); |
||||
|
||||
Curr_Dur : Duration := Clock - Time_Stamp; |
||||
begin |
||||
Put (Msg); |
||||
|
||||
Set_Col (20); |
||||
Ada.Text_IO.Put ("size ="); |
||||
|
||||
Count_IO.Put |
||||
(Data_Size, |
||||
Width => Stream_IO.Count'Image (File_Size)'Length); |
||||
|
||||
Put_Line (" duration =" & Duration'Image (Curr_Dur)); |
||||
end Print_Statistic; |
||||
|
||||
----------- |
||||
-- Stamp -- |
||||
----------- |
||||
|
||||
procedure Stamp is |
||||
begin |
||||
Time_Stamp := Ada.Calendar.Clock; |
||||
end Stamp; |
||||
|
||||
begin |
||||
Ada.Text_IO.Put_Line ("ZLib " & ZLib.Version); |
||||
|
||||
loop |
||||
Generate_File; |
||||
|
||||
for Level in ZLib.Compression_Level'Range loop |
||||
|
||||
Ada.Text_IO.Put_Line ("Level =" |
||||
& ZLib.Compression_Level'Image (Level)); |
||||
|
||||
-- Test generic interface. |
||||
Open (File_In, In_File, In_File_Name); |
||||
Create (File_Out, Out_File, Z_File_Name); |
||||
|
||||
Stamp; |
||||
|
||||
-- Deflate using generic instantiation. |
||||
|
||||
ZLib.Deflate_Init |
||||
(Filter => Filter, |
||||
Level => Level, |
||||
Strategy => Strategy, |
||||
Header => Header); |
||||
|
||||
Translate (Filter); |
||||
Print_Statistic ("Generic compress", ZLib.Total_Out (Filter)); |
||||
ZLib.Close (Filter); |
||||
|
||||
Close (File_In); |
||||
Close (File_Out); |
||||
|
||||
Open (File_In, In_File, Z_File_Name); |
||||
Create (File_Out, Out_File, Out_File_Name); |
||||
|
||||
Stamp; |
||||
|
||||
-- Inflate using generic instantiation. |
||||
|
||||
ZLib.Inflate_Init (Filter, Header => Header); |
||||
|
||||
Translate (Filter); |
||||
Print_Statistic ("Generic decompress", ZLib.Total_Out (Filter)); |
||||
|
||||
ZLib.Close (Filter); |
||||
|
||||
Close (File_In); |
||||
Close (File_Out); |
||||
|
||||
Compare_Files (In_File_Name, Out_File_Name); |
||||
|
||||
-- Test stream interface. |
||||
|
||||
-- Compress to the back stream. |
||||
|
||||
Open (File_In, In_File, In_File_Name); |
||||
Create (File_Back, Out_File, Z_File_Name); |
||||
|
||||
Stamp; |
||||
|
||||
ZLib.Streams.Create |
||||
(Stream => File_Z, |
||||
Mode => ZLib.Streams.Out_Stream, |
||||
Back => ZLib.Streams.Stream_Access |
||||
(Stream (File_Back)), |
||||
Back_Compressed => True, |
||||
Level => Level, |
||||
Strategy => Strategy, |
||||
Header => Header); |
||||
|
||||
Copy_Streams |
||||
(Source => Stream (File_In).all, |
||||
Target => File_Z); |
||||
|
||||
-- Flushing internal buffers to the back stream. |
||||
|
||||
ZLib.Streams.Flush (File_Z, ZLib.Finish); |
||||
|
||||
Print_Statistic ("Write compress", |
||||
ZLib.Streams.Write_Total_Out (File_Z)); |
||||
|
||||
ZLib.Streams.Close (File_Z); |
||||
|
||||
Close (File_In); |
||||
Close (File_Back); |
||||
|
||||
-- Compare reading from original file and from |
||||
-- decompression stream. |
||||
|
||||
Open (File_In, In_File, In_File_Name); |
||||
Open (File_Back, In_File, Z_File_Name); |
||||
|
||||
ZLib.Streams.Create |
||||
(Stream => File_Z, |
||||
Mode => ZLib.Streams.In_Stream, |
||||
Back => ZLib.Streams.Stream_Access |
||||
(Stream (File_Back)), |
||||
Back_Compressed => True, |
||||
Header => Header); |
||||
|
||||
Stamp; |
||||
Compare_Streams (Stream (File_In).all, File_Z); |
||||
|
||||
Print_Statistic ("Read decompress", |
||||
ZLib.Streams.Read_Total_Out (File_Z)); |
||||
|
||||
ZLib.Streams.Close (File_Z); |
||||
Close (File_In); |
||||
Close (File_Back); |
||||
|
||||
-- Compress by reading from compression stream. |
||||
|
||||
Open (File_Back, In_File, In_File_Name); |
||||
Create (File_Out, Out_File, Z_File_Name); |
||||
|
||||
ZLib.Streams.Create |
||||
(Stream => File_Z, |
||||
Mode => ZLib.Streams.In_Stream, |
||||
Back => ZLib.Streams.Stream_Access |
||||
(Stream (File_Back)), |
||||
Back_Compressed => False, |
||||
Level => Level, |
||||
Strategy => Strategy, |
||||
Header => Header); |
||||
|
||||
Stamp; |
||||
Copy_Streams |
||||
(Source => File_Z, |
||||
Target => Stream (File_Out).all); |
||||
|
||||
Print_Statistic ("Read compress", |
||||
ZLib.Streams.Read_Total_Out (File_Z)); |
||||
|
||||
ZLib.Streams.Close (File_Z); |
||||
|
||||
Close (File_Out); |
||||
Close (File_Back); |
||||
|
||||
-- Decompress to decompression stream. |
||||
|
||||
Open (File_In, In_File, Z_File_Name); |
||||
Create (File_Back, Out_File, Out_File_Name); |
||||
|
||||
ZLib.Streams.Create |
||||
(Stream => File_Z, |
||||
Mode => ZLib.Streams.Out_Stream, |
||||
Back => ZLib.Streams.Stream_Access |
||||
(Stream (File_Back)), |
||||
Back_Compressed => False, |
||||
Header => Header); |
||||
|
||||
Stamp; |
||||
|
||||
Copy_Streams |
||||
(Source => Stream (File_In).all, |
||||
Target => File_Z); |
||||
|
||||
Print_Statistic ("Write decompress", |
||||
ZLib.Streams.Write_Total_Out (File_Z)); |
||||
|
||||
ZLib.Streams.Close (File_Z); |
||||
Close (File_In); |
||||
Close (File_Back); |
||||
|
||||
Compare_Files (In_File_Name, Out_File_Name); |
||||
end loop; |
||||
|
||||
Ada.Text_IO.Put_Line (Count'Image (File_Size) & " Ok."); |
||||
|
||||
exit when not Continuous; |
||||
|
||||
File_Size := File_Size + 1; |
||||
end loop; |
||||
end Test; |
||||
@ -0,0 +1,215 @@ |
||||
---------------------------------------------------------------- |
||||
-- ZLib for Ada thick binding. -- |
||||
-- -- |
||||
-- Copyright (C) 2002-2003 Dmitriy Anisimkov -- |
||||
-- -- |
||||
-- Open source license information is in the zlib.ads file. -- |
||||
---------------------------------------------------------------- |
||||
|
||||
-- $Id: zlib-streams.adb,v 1.9 2003/08/12 13:15:31 vagul Exp $ |
||||
|
||||
with Ada.Unchecked_Deallocation; |
||||
|
||||
package body ZLib.Streams is |
||||
|
||||
----------- |
||||
-- Close -- |
||||
----------- |
||||
|
||||
procedure Close (Stream : in out Stream_Type) is |
||||
procedure Free is new Ada.Unchecked_Deallocation |
||||
(Stream_Element_Array, Buffer_Access); |
||||
begin |
||||
if Stream.Mode = Out_Stream or Stream.Mode = Duplex then |
||||
-- We should flush the data written by the writer. |
||||
|
||||
Flush (Stream, Finish); |
||||
|
||||
Close (Stream.Writer); |
||||
end if; |
||||
|
||||
if Stream.Mode = In_Stream or Stream.Mode = Duplex then |
||||
Close (Stream.Reader); |
||||
Free (Stream.Buffer); |
||||
end if; |
||||
end Close; |
||||
|
||||
------------ |
||||
-- Create -- |
||||
------------ |
||||
|
||||
procedure Create |
||||
(Stream : out Stream_Type; |
||||
Mode : in Stream_Mode; |
||||
Back : in Stream_Access; |
||||
Back_Compressed : in Boolean; |
||||
Level : in Compression_Level := Default_Compression; |
||||
Strategy : in Strategy_Type := Default_Strategy; |
||||
Header : in Header_Type := Default; |
||||
Read_Buffer_Size : in Ada.Streams.Stream_Element_Offset |
||||
:= Default_Buffer_Size; |
||||
Write_Buffer_Size : in Ada.Streams.Stream_Element_Offset |
||||
:= Default_Buffer_Size) |
||||
is |
||||
|
||||
subtype Buffer_Subtype is Stream_Element_Array (1 .. Read_Buffer_Size); |
||||
|
||||
procedure Init_Filter |
||||
(Filter : in out Filter_Type; |
||||
Compress : in Boolean); |
||||
|
||||
----------------- |
||||
-- Init_Filter -- |
||||
----------------- |
||||
|
||||
procedure Init_Filter |
||||
(Filter : in out Filter_Type; |
||||
Compress : in Boolean) is |
||||
begin |
||||
if Compress then |
||||
Deflate_Init |
||||
(Filter, Level, Strategy, Header => Header); |
||||
else |
||||
Inflate_Init (Filter, Header => Header); |
||||
end if; |
||||
end Init_Filter; |
||||
|
||||
begin |
||||
Stream.Back := Back; |
||||
Stream.Mode := Mode; |
||||
|
||||
if Mode = Out_Stream or Mode = Duplex then |
||||
Init_Filter (Stream.Writer, Back_Compressed); |
||||
Stream.Buffer_Size := Write_Buffer_Size; |
||||
else |
||||
Stream.Buffer_Size := 0; |
||||
end if; |
||||
|
||||
if Mode = In_Stream or Mode = Duplex then |
||||
Init_Filter (Stream.Reader, not Back_Compressed); |
||||
|
||||
Stream.Buffer := new Buffer_Subtype; |
||||
Stream.Rest_First := Stream.Buffer'Last + 1; |
||||
end if; |
||||
end Create; |
||||
|
||||
----------- |
||||
-- Flush -- |
||||
----------- |
||||
|
||||
procedure Flush |
||||
(Stream : in out Stream_Type; |
||||
Mode : in Flush_Mode := Sync_Flush) |
||||
is |
||||
Buffer : Stream_Element_Array (1 .. Stream.Buffer_Size); |
||||
Last : Stream_Element_Offset; |
||||
begin |
||||
loop |
||||
Flush (Stream.Writer, Buffer, Last, Mode); |
||||
|
||||
Ada.Streams.Write (Stream.Back.all, Buffer (1 .. Last)); |
||||
|
||||
exit when Last < Buffer'Last; |
||||
end loop; |
||||
end Flush; |
||||
|
||||
---------- |
||||
-- Read -- |
||||
---------- |
||||
|
||||
procedure Read |
||||
(Stream : in out Stream_Type; |
||||
Item : out Stream_Element_Array; |
||||
Last : out Stream_Element_Offset) |
||||
is |
||||
|
||||
procedure Read |
||||
(Item : out Stream_Element_Array; |
||||
Last : out Stream_Element_Offset); |
||||
|
||||
---------- |
||||
-- Read -- |
||||
---------- |
||||
|
||||
procedure Read |
||||
(Item : out Stream_Element_Array; |
||||
Last : out Stream_Element_Offset) is |
||||
begin |
||||
Ada.Streams.Read (Stream.Back.all, Item, Last); |
||||
end Read; |
||||
|
||||
procedure Read is new ZLib.Read |
||||
(Read => Read, |
||||
Buffer => Stream.Buffer.all, |
||||
Rest_First => Stream.Rest_First, |
||||
Rest_Last => Stream.Rest_Last); |
||||
|
||||
begin |
||||
Read (Stream.Reader, Item, Last); |
||||
end Read; |
||||
|
||||
------------------- |
||||
-- Read_Total_In -- |
||||
------------------- |
||||
|
||||
function Read_Total_In (Stream : in Stream_Type) return Count is |
||||
begin |
||||
return Total_In (Stream.Reader); |
||||
end Read_Total_In; |
||||
|
||||
-------------------- |
||||
-- Read_Total_Out -- |
||||
-------------------- |
||||
|
||||
function Read_Total_Out (Stream : in Stream_Type) return Count is |
||||
begin |
||||
return Total_Out (Stream.Reader); |
||||
end Read_Total_Out; |
||||
|
||||
----------- |
||||
-- Write -- |
||||
----------- |
||||
|
||||
procedure Write |
||||
(Stream : in out Stream_Type; |
||||
Item : in Stream_Element_Array) |
||||
is |
||||
|
||||
procedure Write (Item : in Stream_Element_Array); |
||||
|
||||
----------- |
||||
-- Write -- |
||||
----------- |
||||
|
||||
procedure Write (Item : in Stream_Element_Array) is |
||||
begin |
||||
Ada.Streams.Write (Stream.Back.all, Item); |
||||
end Write; |
||||
|
||||
procedure Write is new ZLib.Write |
||||
(Write => Write, |
||||
Buffer_Size => Stream.Buffer_Size); |
||||
|
||||
begin |
||||
Write (Stream.Writer, Item, No_Flush); |
||||
end Write; |
||||
|
||||
-------------------- |
||||
-- Write_Total_In -- |
||||
-------------------- |
||||
|
||||
function Write_Total_In (Stream : in Stream_Type) return Count is |
||||
begin |
||||
return Total_In (Stream.Writer); |
||||
end Write_Total_In; |
||||
|
||||
--------------------- |
||||
-- Write_Total_Out -- |
||||
--------------------- |
||||
|
||||
function Write_Total_Out (Stream : in Stream_Type) return Count is |
||||
begin |
||||
return Total_Out (Stream.Writer); |
||||
end Write_Total_Out; |
||||
|
||||
end ZLib.Streams; |
||||
@ -0,0 +1,112 @@ |
||||
---------------------------------------------------------------- |
||||
-- ZLib for Ada thick binding. -- |
||||
-- -- |
||||
-- Copyright (C) 2002-2003 Dmitriy Anisimkov -- |
||||
-- -- |
||||
-- Open source license information is in the zlib.ads file. -- |
||||
---------------------------------------------------------------- |
||||
|
||||
-- $Id: zlib-streams.ads,v 1.11 2003/08/12 13:15:31 vagul Exp $ |
||||
|
||||
package ZLib.Streams is |
||||
|
||||
type Stream_Mode is (In_Stream, Out_Stream, Duplex); |
||||
|
||||
type Stream_Access is access all Ada.Streams.Root_Stream_Type'Class; |
||||
|
||||
type Stream_Type is |
||||
new Ada.Streams.Root_Stream_Type with private; |
||||
|
||||
procedure Read |
||||
(Stream : in out Stream_Type; |
||||
Item : out Ada.Streams.Stream_Element_Array; |
||||
Last : out Ada.Streams.Stream_Element_Offset); |
||||
|
||||
procedure Write |
||||
(Stream : in out Stream_Type; |
||||
Item : in Ada.Streams.Stream_Element_Array); |
||||
|
||||
procedure Flush |
||||
(Stream : in out Stream_Type; |
||||
Mode : in Flush_Mode := Sync_Flush); |
||||
-- Flush the written data to the back stream, |
||||
-- all data placed to the compressor is flushing to the Back stream. |
||||
-- Should not be used untill necessary, becouse it is decreasing |
||||
-- compression. |
||||
|
||||
function Read_Total_In (Stream : in Stream_Type) return Count; |
||||
pragma Inline (Read_Total_In); |
||||
-- Return total number of bytes read from back stream so far. |
||||
|
||||
function Read_Total_Out (Stream : in Stream_Type) return Count; |
||||
pragma Inline (Read_Total_Out); |
||||
-- Return total number of bytes read so far. |
||||
|
||||
function Write_Total_In (Stream : in Stream_Type) return Count; |
||||
pragma Inline (Write_Total_In); |
||||
-- Return total number of bytes written so far. |
||||
|
||||
function Write_Total_Out (Stream : in Stream_Type) return Count; |
||||
pragma Inline (Write_Total_Out); |
||||
-- Return total number of bytes written to the back stream. |
||||
|
||||
procedure Create |
||||
(Stream : out Stream_Type; |
||||
Mode : in Stream_Mode; |
||||
Back : in Stream_Access; |
||||
Back_Compressed : in Boolean; |
||||
Level : in Compression_Level := Default_Compression; |
||||
Strategy : in Strategy_Type := Default_Strategy; |
||||
Header : in Header_Type := Default; |
||||
Read_Buffer_Size : in Ada.Streams.Stream_Element_Offset |
||||
:= Default_Buffer_Size; |
||||
Write_Buffer_Size : in Ada.Streams.Stream_Element_Offset |
||||
:= Default_Buffer_Size); |
||||
-- Create the Comression/Decompression stream. |
||||
-- If mode is In_Stream then Write operation is disabled. |
||||
-- If mode is Out_Stream then Read operation is disabled. |
||||
|
||||
-- If Back_Compressed is true then |
||||
-- Data written to the Stream is compressing to the Back stream |
||||
-- and data read from the Stream is decompressed data from the Back stream. |
||||
|
||||
-- If Back_Compressed is false then |
||||
-- Data written to the Stream is decompressing to the Back stream |
||||
-- and data read from the Stream is compressed data from the Back stream. |
||||
|
||||
-- !!! When the Need_Header is False ZLib-Ada is using undocumented |
||||
-- ZLib 1.1.4 functionality to do not create/wait for ZLib headers. |
||||
|
||||
procedure Close (Stream : in out Stream_Type); |
||||
|
||||
private |
||||
|
||||
use Ada.Streams; |
||||
|
||||
type Buffer_Access is access all Stream_Element_Array; |
||||
|
||||
type Stream_Type |
||||
is new Root_Stream_Type with |
||||
record |
||||
Mode : Stream_Mode; |
||||
|
||||
Buffer : Buffer_Access; |
||||
Rest_First : Stream_Element_Offset; |
||||
Rest_Last : Stream_Element_Offset; |
||||
-- Buffer for Read operation. |
||||
-- We need to have this buffer in the record |
||||
-- becouse not all read data from back stream |
||||
-- could be processed during the read operation. |
||||
|
||||
Buffer_Size : Stream_Element_Offset; |
||||
-- Buffer size for write operation. |
||||
-- We do not need to have this buffer |
||||
-- in the record becouse all data could be |
||||
-- processed in the write operation. |
||||
|
||||
Back : Stream_Access; |
||||
Reader : Filter_Type; |
||||
Writer : Filter_Type; |
||||
end record; |
||||
|
||||
end ZLib.Streams; |
||||
@ -0,0 +1,185 @@ |
||||
---------------------------------------------------------------- |
||||
-- ZLib for Ada thick binding. -- |
||||
-- -- |
||||
-- Copyright (C) 2002-2003 Dmitriy Anisimkov -- |
||||
-- -- |
||||
-- Open source license information is in the zlib.ads file. -- |
||||
---------------------------------------------------------------- |
||||
|
||||
-- $Id: zlib-thin.adb,v 1.6 2003/01/21 15:26:37 vagul Exp $ |
||||
|
||||
package body ZLib.Thin is |
||||
|
||||
ZLIB_VERSION : constant Chars_Ptr := |
||||
Interfaces.C.Strings.New_String ("1.1.4"); |
||||
|
||||
Z_Stream_Size : constant Int := Z_Stream'Size / System.Storage_Unit; |
||||
|
||||
-------------- |
||||
-- Avail_In -- |
||||
-------------- |
||||
|
||||
function Avail_In (Strm : in Z_Stream) return UInt is |
||||
begin |
||||
return Strm.Avail_In; |
||||
end Avail_In; |
||||
|
||||
--------------- |
||||
-- Avail_Out -- |
||||
--------------- |
||||
|
||||
function Avail_Out (Strm : in Z_Stream) return UInt is |
||||
begin |
||||
return Strm.Avail_Out; |
||||
end Avail_Out; |
||||
|
||||
------------------ |
||||
-- Deflate_Init -- |
||||
------------------ |
||||
|
||||
function Deflate_Init |
||||
(strm : in Z_Streamp; |
||||
level : in Int := Z_DEFAULT_COMPRESSION) |
||||
return Int is |
||||
begin |
||||
return deflateInit (strm, level, ZLIB_VERSION, Z_Stream_Size); |
||||
end Deflate_Init; |
||||
|
||||
function Deflate_Init |
||||
(strm : Z_Streamp; |
||||
level : Int; |
||||
method : Int; |
||||
windowBits : Int; |
||||
memLevel : Int; |
||||
strategy : Int) |
||||
return Int is |
||||
begin |
||||
return deflateInit2 |
||||
(strm, |
||||
level, |
||||
method, |
||||
windowBits, |
||||
memLevel, |
||||
strategy, |
||||
ZLIB_VERSION, |
||||
Z_Stream_Size); |
||||
end Deflate_Init; |
||||
|
||||
------------------ |
||||
-- Inflate_Init -- |
||||
------------------ |
||||
|
||||
function Inflate_Init (strm : Z_Streamp) return Int is |
||||
begin |
||||
return inflateInit (strm, ZLIB_VERSION, Z_Stream_Size); |
||||
end Inflate_Init; |
||||
|
||||
function Inflate_Init (strm : Z_Streamp; windowBits : Int) return Int is |
||||
begin |
||||
return inflateInit2 (strm, windowBits, ZLIB_VERSION, Z_Stream_Size); |
||||
end Inflate_Init; |
||||
|
||||
function Last_Error_Message (Strm : in Z_Stream) return String is |
||||
use Interfaces.C.Strings; |
||||
begin |
||||
if Strm.msg = Null_Ptr then |
||||
return ""; |
||||
else |
||||
return Value (Strm.msg); |
||||
end if; |
||||
end Last_Error_Message; |
||||
|
||||
------------- |
||||
-- Need_In -- |
||||
------------- |
||||
|
||||
function Need_In (strm : Z_Stream) return Boolean is |
||||
begin |
||||
return strm.Avail_In = 0; |
||||
end Need_In; |
||||
|
||||
-------------- |
||||
-- Need_Out -- |
||||
-------------- |
||||
|
||||
function Need_Out (strm : Z_Stream) return Boolean is |
||||
begin |
||||
return strm.Avail_Out = 0; |
||||
end Need_Out; |
||||
|
||||
------------ |
||||
-- Set_In -- |
||||
------------ |
||||
|
||||
procedure Set_In |
||||
(Strm : in out Z_Stream; |
||||
Buffer : in Byte_Access; |
||||
Size : in UInt) is |
||||
begin |
||||
Strm.Next_In := Buffer; |
||||
Strm.Avail_In := Size; |
||||
end Set_In; |
||||
|
||||
procedure Set_In |
||||
(Strm : in out Z_Stream; |
||||
Buffer : in Voidp; |
||||
Size : in UInt) is |
||||
begin |
||||
Set_In (Strm, Bytes.To_Pointer (Buffer), Size); |
||||
end Set_In; |
||||
|
||||
------------------ |
||||
-- Set_Mem_Func -- |
||||
------------------ |
||||
|
||||
procedure Set_Mem_Func |
||||
(Strm : in out Z_Stream; |
||||
Opaque : in Voidp; |
||||
Alloc : in alloc_func; |
||||
Free : in free_func) is |
||||
begin |
||||
Strm.opaque := Opaque; |
||||
Strm.zalloc := Alloc; |
||||
Strm.zfree := Free; |
||||
end Set_Mem_Func; |
||||
|
||||
------------- |
||||
-- Set_Out -- |
||||
------------- |
||||
|
||||
procedure Set_Out |
||||
(Strm : in out Z_Stream; |
||||
Buffer : in Byte_Access; |
||||
Size : in UInt) is |
||||
begin |
||||
Strm.Next_Out := Buffer; |
||||
Strm.Avail_Out := Size; |
||||
end Set_Out; |
||||
|
||||
procedure Set_Out |
||||
(Strm : in out Z_Stream; |
||||
Buffer : in Voidp; |
||||
Size : in UInt) is |
||||
begin |
||||
Set_Out (Strm, Bytes.To_Pointer (Buffer), Size); |
||||
end Set_Out; |
||||
|
||||
-------------- |
||||
-- Total_In -- |
||||
-------------- |
||||
|
||||
function Total_In (Strm : in Z_Stream) return ULong is |
||||
begin |
||||
return Strm.Total_In; |
||||
end Total_In; |
||||
|
||||
--------------- |
||||
-- Total_Out -- |
||||
--------------- |
||||
|
||||
function Total_Out (Strm : in Z_Stream) return ULong is |
||||
begin |
||||
return Strm.Total_Out; |
||||
end Total_Out; |
||||
|
||||
end ZLib.Thin; |
||||
@ -0,0 +1,478 @@ |
||||
---------------------------------------------------------------- |
||||
-- ZLib for Ada thick binding. -- |
||||
-- -- |
||||
-- Copyright (C) 2002-2003 Dmitriy Anisimkov -- |
||||
-- -- |
||||
-- Open source license information is in the zlib.ads file. -- |
||||
---------------------------------------------------------------- |
||||
|
||||
-- $Id: zlib-thin.ads,v 1.8 2003/08/12 13:16:51 vagul Exp $ |
||||
|
||||
with Interfaces.C.Strings; |
||||
with System.Address_To_Access_Conversions; |
||||
|
||||
private package ZLib.Thin is |
||||
|
||||
-- From zconf.h |
||||
|
||||
MAX_MEM_LEVEL : constant := 9; -- zconf.h:105 |
||||
-- zconf.h:105 |
||||
MAX_WBITS : constant := 15; -- zconf.h:115 |
||||
-- 32K LZ77 window |
||||
-- zconf.h:115 |
||||
SEEK_SET : constant := 8#0000#; -- zconf.h:244 |
||||
-- Seek from beginning of file. |
||||
-- zconf.h:244 |
||||
SEEK_CUR : constant := 1; -- zconf.h:245 |
||||
-- Seek from current position. |
||||
-- zconf.h:245 |
||||
SEEK_END : constant := 2; -- zconf.h:246 |
||||
-- Set file pointer to EOF plus "offset" |
||||
-- zconf.h:246 |
||||
|
||||
type Byte is new Interfaces.C.unsigned_char; -- 8 bits |
||||
-- zconf.h:214 |
||||
type UInt is new Interfaces.C.unsigned; -- 16 bits or more |
||||
-- zconf.h:216 |
||||
type Int is new Interfaces.C.int; |
||||
|
||||
type ULong is new Interfaces.C.unsigned; -- 32 bits or more |
||||
-- zconf.h:217 |
||||
subtype Chars_Ptr is Interfaces.C.Strings.chars_ptr; |
||||
|
||||
type ULong_Access is access ULong; |
||||
type Int_Access is access Int; |
||||
subtype Voidp is System.Address; -- zconf.h:232 |
||||
|
||||
package Bytes is new System.Address_To_Access_Conversions (Byte); |
||||
|
||||
subtype Byte_Access is Bytes.Object_Pointer; |
||||
|
||||
-- end from zconf |
||||
|
||||
Z_NO_FLUSH : constant := 8#0000#; -- zlib.h:125 |
||||
-- zlib.h:125 |
||||
Z_PARTIAL_FLUSH : constant := 1; -- zlib.h:126 |
||||
-- will be removed, use |
||||
-- Z_SYNC_FLUSH instead |
||||
-- zlib.h:126 |
||||
Z_SYNC_FLUSH : constant := 2; -- zlib.h:127 |
||||
-- zlib.h:127 |
||||
Z_FULL_FLUSH : constant := 3; -- zlib.h:128 |
||||
-- zlib.h:128 |
||||
Z_FINISH : constant := 4; -- zlib.h:129 |
||||
-- zlib.h:129 |
||||
Z_OK : constant := 8#0000#; -- zlib.h:132 |
||||
-- zlib.h:132 |
||||
Z_STREAM_END : constant := 1; -- zlib.h:133 |
||||
-- zlib.h:133 |
||||
Z_NEED_DICT : constant := 2; -- zlib.h:134 |
||||
-- zlib.h:134 |
||||
Z_ERRNO : constant := -1; -- zlib.h:135 |
||||
-- zlib.h:135 |
||||
Z_STREAM_ERROR : constant := -2; -- zlib.h:136 |
||||
-- zlib.h:136 |
||||
Z_DATA_ERROR : constant := -3; -- zlib.h:137 |
||||
-- zlib.h:137 |
||||
Z_MEM_ERROR : constant := -4; -- zlib.h:138 |
||||
-- zlib.h:138 |
||||
Z_BUF_ERROR : constant := -5; -- zlib.h:139 |
||||
-- zlib.h:139 |
||||
Z_VERSION_ERROR : constant := -6; -- zlib.h:140 |
||||
-- zlib.h:140 |
||||
Z_NO_COMPRESSION : constant := 8#0000#; -- zlib.h:145 |
||||
-- zlib.h:145 |
||||
Z_BEST_SPEED : constant := 1; -- zlib.h:146 |
||||
-- zlib.h:146 |
||||
Z_BEST_COMPRESSION : constant := 9; -- zlib.h:147 |
||||
-- zlib.h:147 |
||||
Z_DEFAULT_COMPRESSION : constant := -1; -- zlib.h:148 |
||||
-- zlib.h:148 |
||||
Z_FILTERED : constant := 1; -- zlib.h:151 |
||||
-- zlib.h:151 |
||||
Z_HUFFMAN_ONLY : constant := 2; -- zlib.h:152 |
||||
-- zlib.h:152 |
||||
Z_DEFAULT_STRATEGY : constant := 8#0000#; -- zlib.h:153 |
||||
-- zlib.h:153 |
||||
Z_BINARY : constant := 8#0000#; -- zlib.h:156 |
||||
-- zlib.h:156 |
||||
Z_ASCII : constant := 1; -- zlib.h:157 |
||||
-- zlib.h:157 |
||||
Z_UNKNOWN : constant := 2; -- zlib.h:158 |
||||
-- zlib.h:158 |
||||
Z_DEFLATED : constant := 8; -- zlib.h:161 |
||||
-- zlib.h:161 |
||||
Z_NULL : constant := 8#0000#; -- zlib.h:164 |
||||
-- for initializing zalloc, zfree, opaque |
||||
-- zlib.h:164 |
||||
type gzFile is new Voidp; -- zlib.h:646 |
||||
|
||||
type Z_Stream is private; |
||||
|
||||
type Z_Streamp is access all Z_Stream; -- zlib.h:89 |
||||
|
||||
type alloc_func is access function |
||||
(Opaque : Voidp; |
||||
Items : UInt; |
||||
Size : UInt) |
||||
return Voidp; -- zlib.h:63 |
||||
|
||||
type free_func is access procedure (opaque : Voidp; address : Voidp); |
||||
|
||||
function zlibVersion return Chars_Ptr; |
||||
|
||||
function Deflate (strm : Z_Streamp; flush : Int) return Int; |
||||
|
||||
function DeflateEnd (strm : Z_Streamp) return Int; |
||||
|
||||
function Inflate (strm : Z_Streamp; flush : Int) return Int; |
||||
|
||||
function InflateEnd (strm : Z_Streamp) return Int; |
||||
|
||||
function deflateSetDictionary |
||||
(strm : Z_Streamp; |
||||
dictionary : Byte_Access; |
||||
dictLength : UInt) |
||||
return Int; |
||||
|
||||
function deflateCopy (dest : Z_Streamp; source : Z_Streamp) return Int; |
||||
-- zlib.h:478 |
||||
|
||||
function deflateReset (strm : Z_Streamp) return Int; -- zlib.h:495 |
||||
|
||||
function deflateParams |
||||
(strm : Z_Streamp; |
||||
level : Int; |
||||
strategy : Int) |
||||
return Int; -- zlib.h:506 |
||||
|
||||
function inflateSetDictionary |
||||
(strm : Z_Streamp; |
||||
dictionary : Byte_Access; |
||||
dictLength : UInt) |
||||
return Int; -- zlib.h:548 |
||||
|
||||
function inflateSync (strm : Z_Streamp) return Int; -- zlib.h:565 |
||||
|
||||
function inflateReset (strm : Z_Streamp) return Int; -- zlib.h:580 |
||||
|
||||
function compress |
||||
(dest : Byte_Access; |
||||
destLen : ULong_Access; |
||||
source : Byte_Access; |
||||
sourceLen : ULong) |
||||
return Int; -- zlib.h:601 |
||||
|
||||
function compress2 |
||||
(dest : Byte_Access; |
||||
destLen : ULong_Access; |
||||
source : Byte_Access; |
||||
sourceLen : ULong; |
||||
level : Int) |
||||
return Int; -- zlib.h:615 |
||||
|
||||
function uncompress |
||||
(dest : Byte_Access; |
||||
destLen : ULong_Access; |
||||
source : Byte_Access; |
||||
sourceLen : ULong) |
||||
return Int; |
||||
|
||||
function gzopen (path : Chars_Ptr; mode : Chars_Ptr) return gzFile; |
||||
|
||||
function gzdopen (fd : Int; mode : Chars_Ptr) return gzFile; |
||||
|
||||
function gzsetparams |
||||
(file : gzFile; |
||||
level : Int; |
||||
strategy : Int) |
||||
return Int; |
||||
|
||||
function gzread |
||||
(file : gzFile; |
||||
buf : Voidp; |
||||
len : UInt) |
||||
return Int; |
||||
|
||||
function gzwrite |
||||
(file : in gzFile; |
||||
buf : in Voidp; |
||||
len : in UInt) |
||||
return Int; |
||||
|
||||
function gzprintf (file : in gzFile; format : in Chars_Ptr) return Int; |
||||
|
||||
function gzputs (file : in gzFile; s : in Chars_Ptr) return Int; |
||||
|
||||
function gzgets |
||||
(file : gzFile; |
||||
buf : Chars_Ptr; |
||||
len : Int) |
||||
return Chars_Ptr; |
||||
|
||||
function gzputc (file : gzFile; char : Int) return Int; |
||||
|
||||
function gzgetc (file : gzFile) return Int; |
||||
|
||||
function gzflush (file : gzFile; flush : Int) return Int; |
||||
|
||||
function gzseek |
||||
(file : gzFile; |
||||
offset : Int; |
||||
whence : Int) |
||||
return Int; |
||||
|
||||
function gzrewind (file : gzFile) return Int; |
||||
|
||||
function gztell (file : gzFile) return Int; |
||||
|
||||
function gzeof (file : gzFile) return Int; |
||||
|
||||
function gzclose (file : gzFile) return Int; |
||||
|
||||
function gzerror (file : gzFile; errnum : Int_Access) return Chars_Ptr; |
||||
|
||||
function adler32 |
||||
(adler : ULong; |
||||
buf : Byte_Access; |
||||
len : UInt) |
||||
return ULong; |
||||
|
||||
function crc32 |
||||
(crc : ULong; |
||||
buf : Byte_Access; |
||||
len : UInt) |
||||
return ULong; |
||||
|
||||
function deflateInit |
||||
(strm : Z_Streamp; |
||||
level : Int; |
||||
version : Chars_Ptr; |
||||
stream_size : Int) |
||||
return Int; |
||||
|
||||
function Deflate_Init |
||||
(strm : in Z_Streamp; |
||||
level : in Int := Z_DEFAULT_COMPRESSION) |
||||
return Int; |
||||
pragma Inline (Deflate_Init); |
||||
|
||||
function deflateInit2 |
||||
(strm : Z_Streamp; |
||||
level : Int; |
||||
method : Int; |
||||
windowBits : Int; |
||||
memLevel : Int; |
||||
strategy : Int; |
||||
version : Chars_Ptr; |
||||
stream_size : Int) |
||||
return Int; |
||||
|
||||
function Deflate_Init |
||||
(strm : Z_Streamp; |
||||
level : Int; |
||||
method : Int; |
||||
windowBits : Int; |
||||
memLevel : Int; |
||||
strategy : Int) |
||||
return Int; |
||||
pragma Inline (Deflate_Init); |
||||
|
||||
function inflateInit |
||||
(strm : Z_Streamp; |
||||
version : Chars_Ptr; |
||||
stream_size : Int) |
||||
return Int; |
||||
|
||||
function Inflate_Init (strm : Z_Streamp) return Int; |
||||
pragma Inline (Inflate_Init); |
||||
|
||||
function inflateInit2 |
||||
(strm : in Z_Streamp; |
||||
windowBits : in Int; |
||||
version : in Chars_Ptr; |
||||
stream_size : in Int) |
||||
return Int; |
||||
|
||||
function inflateBackInit |
||||
(strm : in Z_Streamp; |
||||
windowBits : in Int; |
||||
window : in Byte_Access; |
||||
version : in Chars_Ptr; |
||||
stream_size : in Int) |
||||
return Int; |
||||
-- Size of window have to be 2**windowBits. |
||||
|
||||
function Inflate_Init (strm : Z_Streamp; windowBits : Int) return Int; |
||||
pragma Inline (Inflate_Init); |
||||
|
||||
function zError (err : Int) return Chars_Ptr; |
||||
|
||||
function inflateSyncPoint (z : Z_Streamp) return Int; |
||||
|
||||
function get_crc_table return ULong_Access; |
||||
|
||||
-- Interface to the available fields of the z_stream structure. |
||||
-- 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. |
||||
|
||||
function Need_In (strm : in Z_Stream) return Boolean; |
||||
-- return true when we do not need to setup Next_In and Avail_In fields. |
||||
pragma Inline (Need_In); |
||||
|
||||
function Need_Out (strm : in Z_Stream) return Boolean; |
||||
-- return true when we do not need to setup Next_Out and Avail_Out field. |
||||
pragma Inline (Need_Out); |
||||
|
||||
procedure Set_In |
||||
(Strm : in out Z_Stream; |
||||
Buffer : in Byte_Access; |
||||
Size : in UInt); |
||||
pragma Inline (Set_In); |
||||
|
||||
procedure Set_In |
||||
(Strm : in out Z_Stream; |
||||
Buffer : in Voidp; |
||||
Size : in UInt); |
||||
pragma Inline (Set_In); |
||||
|
||||
procedure Set_Out |
||||
(Strm : in out Z_Stream; |
||||
Buffer : in Byte_Access; |
||||
Size : in UInt); |
||||
pragma Inline (Set_Out); |
||||
|
||||
procedure Set_Out |
||||
(Strm : in out Z_Stream; |
||||
Buffer : in Voidp; |
||||
Size : in UInt); |
||||
pragma Inline (Set_Out); |
||||
|
||||
procedure Set_Mem_Func |
||||
(Strm : in out Z_Stream; |
||||
Opaque : in Voidp; |
||||
Alloc : in alloc_func; |
||||
Free : in free_func); |
||||
pragma Inline (Set_Mem_Func); |
||||
|
||||
function Last_Error_Message (Strm : in Z_Stream) return String; |
||||
pragma Inline (Last_Error_Message); |
||||
|
||||
function Avail_Out (Strm : in Z_Stream) return UInt; |
||||
pragma Inline (Avail_Out); |
||||
|
||||
function Avail_In (Strm : in Z_Stream) return UInt; |
||||
pragma Inline (Avail_In); |
||||
|
||||
function Total_In (Strm : in Z_Stream) return ULong; |
||||
pragma Inline (Total_In); |
||||
|
||||
function Total_Out (Strm : in Z_Stream) return ULong; |
||||
pragma Inline (Total_Out); |
||||
|
||||
function inflateCopy |
||||
(dest : in Z_Streamp; |
||||
Source : in Z_Streamp) |
||||
return Int; |
||||
|
||||
function compressBound (Source_Len : in ULong) return ULong; |
||||
|
||||
function deflateBound |
||||
(Strm : in Z_Streamp; |
||||
Source_Len : in ULong) |
||||
return ULong; |
||||
|
||||
function gzungetc (C : in Int; File : in gzFile) return Int; |
||||
|
||||
function zlibCompileFlags return ULong; |
||||
|
||||
private |
||||
|
||||
type Z_Stream is record -- zlib.h:68 |
||||
Next_In : Byte_Access; -- next input byte |
||||
Avail_In : UInt := 0; -- number of bytes available at next_in |
||||
Total_In : ULong := 0; -- total nb of input bytes read so far |
||||
Next_Out : Byte_Access; -- next output byte should be put there |
||||
Avail_Out : UInt := 0; -- remaining free space at next_out |
||||
Total_Out : ULong := 0; -- total nb of bytes output so far |
||||
msg : Chars_Ptr; -- last error message, NULL if no error |
||||
state : Voidp; -- not visible by applications |
||||
zalloc : alloc_func := null; -- used to allocate the internal state |
||||
zfree : free_func := null; -- used to free the internal state |
||||
opaque : Voidp; -- private data object passed to |
||||
-- zalloc and zfree |
||||
data_type : Int; -- best guess about the data type: |
||||
-- ascii or binary |
||||
adler : ULong; -- adler32 value of the uncompressed |
||||
-- data |
||||
reserved : ULong; -- reserved for future use |
||||
end record; |
||||
|
||||
pragma Convention (C, Z_Stream); |
||||
|
||||
pragma Import (C, zlibVersion, "zlibVersion"); |
||||
pragma Import (C, Deflate, "deflate"); |
||||
pragma Import (C, DeflateEnd, "deflateEnd"); |
||||
pragma Import (C, Inflate, "inflate"); |
||||
pragma Import (C, InflateEnd, "inflateEnd"); |
||||
pragma Import (C, deflateSetDictionary, "deflateSetDictionary"); |
||||
pragma Import (C, deflateCopy, "deflateCopy"); |
||||
pragma Import (C, deflateReset, "deflateReset"); |
||||
pragma Import (C, deflateParams, "deflateParams"); |
||||
pragma Import (C, inflateSetDictionary, "inflateSetDictionary"); |
||||
pragma Import (C, inflateSync, "inflateSync"); |
||||
pragma Import (C, inflateReset, "inflateReset"); |
||||
pragma Import (C, compress, "compress"); |
||||
pragma Import (C, compress2, "compress2"); |
||||
pragma Import (C, uncompress, "uncompress"); |
||||
pragma Import (C, gzopen, "gzopen"); |
||||
pragma Import (C, gzdopen, "gzdopen"); |
||||
pragma Import (C, gzsetparams, "gzsetparams"); |
||||
pragma Import (C, gzread, "gzread"); |
||||
pragma Import (C, gzwrite, "gzwrite"); |
||||
pragma Import (C, gzprintf, "gzprintf"); |
||||
pragma Import (C, gzputs, "gzputs"); |
||||
pragma Import (C, gzgets, "gzgets"); |
||||
pragma Import (C, gzputc, "gzputc"); |
||||
pragma Import (C, gzgetc, "gzgetc"); |
||||
pragma Import (C, gzflush, "gzflush"); |
||||
pragma Import (C, gzseek, "gzseek"); |
||||
pragma Import (C, gzrewind, "gzrewind"); |
||||
pragma Import (C, gztell, "gztell"); |
||||
pragma Import (C, gzeof, "gzeof"); |
||||
pragma Import (C, gzclose, "gzclose"); |
||||
pragma Import (C, gzerror, "gzerror"); |
||||
pragma Import (C, adler32, "adler32"); |
||||
pragma Import (C, crc32, "crc32"); |
||||
pragma Import (C, deflateInit, "deflateInit_"); |
||||
pragma Import (C, inflateInit, "inflateInit_"); |
||||
pragma Import (C, deflateInit2, "deflateInit2_"); |
||||
pragma Import (C, inflateInit2, "inflateInit2_"); |
||||
pragma Import (C, zError, "zError"); |
||||
pragma Import (C, inflateSyncPoint, "inflateSyncPoint"); |
||||
pragma Import (C, get_crc_table, "get_crc_table"); |
||||
|
||||
-- since zlib 1.2.0: |
||||
|
||||
pragma Import (C, inflateCopy, "inflateCopy"); |
||||
pragma Import (C, compressBound, "compressBound"); |
||||
pragma Import (C, deflateBound, "deflateBound"); |
||||
pragma Import (C, gzungetc, "gzungetc"); |
||||
pragma Import (C, zlibCompileFlags, "zlibCompileFlags"); |
||||
|
||||
pragma Import (C, inflateBackInit, "inflateBackInit_"); |
||||
|
||||
-- I stopped binding the inflateBack routines, becouse realize that |
||||
-- it does not support zlib and gzip headers for now, and have no |
||||
-- symmetric deflateBack routines. |
||||
-- ZLib-Ada is symmetric regarding deflate/inflate data transformation |
||||
-- and has a similar generic callback interface for the |
||||
-- deflate/inflate transformation based on the regular Deflate/Inflate |
||||
-- routines. |
||||
|
||||
-- pragma Import (C, inflateBack, "inflateBack"); |
||||
-- pragma Import (C, inflateBackEnd, "inflateBackEnd"); |
||||
|
||||
end ZLib.Thin; |
||||
@ -0,0 +1,674 @@ |
||||
---------------------------------------------------------------- |
||||
-- ZLib for Ada thick binding. -- |
||||
-- -- |
||||
-- Copyright (C) 2002-2003 Dmitriy Anisimkov -- |
||||
-- -- |
||||
-- Open source license information is in the zlib.ads file. -- |
||||
---------------------------------------------------------------- |
||||
|
||||
-- $Id: zlib.adb,v 1.19 2003/07/13 16:02:19 vagul Exp $ |
||||
|
||||
with Ada.Exceptions; |
||||
with Ada.Unchecked_Conversion; |
||||
with Ada.Unchecked_Deallocation; |
||||
|
||||
with Interfaces.C.Strings; |
||||
|
||||
with ZLib.Thin; |
||||
|
||||
package body ZLib is |
||||
|
||||
use type Thin.Int; |
||||
|
||||
type Z_Stream is new Thin.Z_Stream; |
||||
|
||||
type Return_Code_Enum is |
||||
(OK, |
||||
STREAM_END, |
||||
NEED_DICT, |
||||
ERRNO, |
||||
STREAM_ERROR, |
||||
DATA_ERROR, |
||||
MEM_ERROR, |
||||
BUF_ERROR, |
||||
VERSION_ERROR); |
||||
|
||||
type Flate_Step_Function is access |
||||
function (Strm : Thin.Z_Streamp; flush : Thin.Int) return Thin.Int; |
||||
pragma Convention (C, Flate_Step_Function); |
||||
|
||||
type Flate_End_Function is access |
||||
function (Ctrm : in Thin.Z_Streamp) return Thin.Int; |
||||
pragma Convention (C, Flate_End_Function); |
||||
|
||||
type Flate_Type is record |
||||
Step : Flate_Step_Function; |
||||
Done : Flate_End_Function; |
||||
end record; |
||||
|
||||
subtype Footer_Array is Stream_Element_Array (1 .. 8); |
||||
|
||||
Simple_GZip_Header : constant Stream_Element_Array (1 .. 10) |
||||
:= (16#1f#, 16#8b#, -- Magic header |
||||
16#08#, -- Z_DEFLATED |
||||
16#00#, -- Flags |
||||
16#00#, 16#00#, 16#00#, 16#00#, -- Time |
||||
16#00#, -- XFlags |
||||
16#03# -- OS code |
||||
); |
||||
-- The simplest gzip header is not for informational, but just for |
||||
-- gzip format compatibility. |
||||
-- Note that some code below is using assumption |
||||
-- Simple_GZip_Header'Last > Footer_Array'Last, so do not make |
||||
-- Simple_GZip_Header'Last <= Footer_Array'Last. |
||||
|
||||
Return_Code : constant array (Thin.Int range <>) of Return_Code_Enum |
||||
:= (0 => OK, |
||||
1 => STREAM_END, |
||||
2 => NEED_DICT, |
||||
-1 => ERRNO, |
||||
-2 => STREAM_ERROR, |
||||
-3 => DATA_ERROR, |
||||
-4 => MEM_ERROR, |
||||
-5 => BUF_ERROR, |
||||
-6 => VERSION_ERROR); |
||||
|
||||
Flate : constant array (Boolean) of Flate_Type |
||||
:= (True => (Step => Thin.Deflate'Access, |
||||
Done => Thin.DeflateEnd'Access), |
||||
False => (Step => Thin.Inflate'Access, |
||||
Done => Thin.InflateEnd'Access)); |
||||
|
||||
Flush_Finish : constant array (Boolean) of Flush_Mode |
||||
:= (True => Finish, False => No_Flush); |
||||
|
||||
procedure Raise_Error (Stream : Z_Stream); |
||||
pragma Inline (Raise_Error); |
||||
|
||||
procedure Raise_Error (Message : String); |
||||
pragma Inline (Raise_Error); |
||||
|
||||
procedure Check_Error (Stream : Z_Stream; Code : Thin.Int); |
||||
|
||||
procedure Free is new Ada.Unchecked_Deallocation |
||||
(Z_Stream, Z_Stream_Access); |
||||
|
||||
function To_Thin_Access is new Ada.Unchecked_Conversion |
||||
(Z_Stream_Access, Thin.Z_Streamp); |
||||
|
||||
procedure Translate_GZip |
||||
(Filter : in out Filter_Type; |
||||
In_Data : in Ada.Streams.Stream_Element_Array; |
||||
In_Last : out Ada.Streams.Stream_Element_Offset; |
||||
Out_Data : out Ada.Streams.Stream_Element_Array; |
||||
Out_Last : out Ada.Streams.Stream_Element_Offset; |
||||
Flush : in Flush_Mode); |
||||
-- Separate translate routine for make gzip header. |
||||
|
||||
procedure Translate_Auto |
||||
(Filter : in out Filter_Type; |
||||
In_Data : in Ada.Streams.Stream_Element_Array; |
||||
In_Last : out Ada.Streams.Stream_Element_Offset; |
||||
Out_Data : out Ada.Streams.Stream_Element_Array; |
||||
Out_Last : out Ada.Streams.Stream_Element_Offset; |
||||
Flush : in Flush_Mode); |
||||
-- translate routine without additional headers. |
||||
|
||||
----------------- |
||||
-- Check_Error -- |
||||
----------------- |
||||
|
||||
procedure Check_Error (Stream : Z_Stream; Code : Thin.Int) is |
||||
use type Thin.Int; |
||||
begin |
||||
if Code /= Thin.Z_OK then |
||||
Raise_Error |
||||
(Return_Code_Enum'Image (Return_Code (Code)) |
||||
& ": " & Last_Error_Message (Stream)); |
||||
end if; |
||||
end Check_Error; |
||||
|
||||
----------- |
||||
-- Close -- |
||||
----------- |
||||
|
||||
procedure Close |
||||
(Filter : in out Filter_Type; |
||||
Ignore_Error : in Boolean := False) |
||||
is |
||||
Code : Thin.Int; |
||||
begin |
||||
Code := Flate (Filter.Compression).Done |
||||
(To_Thin_Access (Filter.Strm)); |
||||
|
||||
Filter.Opened := False; |
||||
|
||||
if Ignore_Error or else Code = Thin.Z_OK then |
||||
Free (Filter.Strm); |
||||
else |
||||
declare |
||||
Error_Message : constant String |
||||
:= Last_Error_Message (Filter.Strm.all); |
||||
begin |
||||
Free (Filter.Strm); |
||||
Ada.Exceptions.Raise_Exception |
||||
(ZLib_Error'Identity, |
||||
Return_Code_Enum'Image (Return_Code (Code)) |
||||
& ": " & Error_Message); |
||||
end; |
||||
end if; |
||||
end Close; |
||||
|
||||
----------- |
||||
-- CRC32 -- |
||||
----------- |
||||
|
||||
function CRC32 |
||||
(CRC : in Unsigned_32; |
||||
Data : in Ada.Streams.Stream_Element_Array) |
||||
return Unsigned_32 |
||||
is |
||||
use Thin; |
||||
begin |
||||
return Unsigned_32 (crc32 |
||||
(ULong (CRC), |
||||
Bytes.To_Pointer (Data'Address), |
||||
Data'Length)); |
||||
end CRC32; |
||||
|
||||
procedure CRC32 |
||||
(CRC : in out Unsigned_32; |
||||
Data : in Ada.Streams.Stream_Element_Array) is |
||||
begin |
||||
CRC := CRC32 (CRC, Data); |
||||
end CRC32; |
||||
|
||||
------------------ |
||||
-- Deflate_Init -- |
||||
------------------ |
||||
|
||||
procedure Deflate_Init |
||||
(Filter : in out Filter_Type; |
||||
Level : in Compression_Level := Default_Compression; |
||||
Strategy : in Strategy_Type := Default_Strategy; |
||||
Method : in Compression_Method := Deflated; |
||||
Window_Bits : in Window_Bits_Type := 15; |
||||
Memory_Level : in Memory_Level_Type := 8; |
||||
Header : in Header_Type := Default) |
||||
is |
||||
use type Thin.Int; |
||||
Win_Bits : Thin.Int := Thin.Int (Window_Bits); |
||||
begin |
||||
-- We allow ZLib to make header only in case of default header type. |
||||
-- Otherwise we would either do header by ourselfs, or do not do |
||||
-- header at all. |
||||
|
||||
if Header = None or else Header = GZip then |
||||
Win_Bits := -Win_Bits; |
||||
end if; |
||||
|
||||
-- For the GZip CRC calculation and make headers. |
||||
|
||||
if Header = GZip then |
||||
Filter.CRC := 0; |
||||
Filter.Offset := Simple_GZip_Header'First; |
||||
else |
||||
Filter.Offset := Simple_GZip_Header'Last + 1; |
||||
end if; |
||||
|
||||
Filter.Strm := new Z_Stream; |
||||
Filter.Compression := True; |
||||
Filter.Stream_End := False; |
||||
Filter.Opened := True; |
||||
Filter.Header := Header; |
||||
|
||||
if Thin.Deflate_Init |
||||
(To_Thin_Access (Filter.Strm), |
||||
Level => Thin.Int (Level), |
||||
method => Thin.Int (Method), |
||||
windowBits => Win_Bits, |
||||
memLevel => Thin.Int (Memory_Level), |
||||
strategy => Thin.Int (Strategy)) /= Thin.Z_OK |
||||
then |
||||
Raise_Error (Filter.Strm.all); |
||||
end if; |
||||
end Deflate_Init; |
||||
|
||||
----------- |
||||
-- Flush -- |
||||
----------- |
||||
|
||||
procedure Flush |
||||
(Filter : in out Filter_Type; |
||||
Out_Data : out Ada.Streams.Stream_Element_Array; |
||||
Out_Last : out Ada.Streams.Stream_Element_Offset; |
||||
Flush : in Flush_Mode) |
||||
is |
||||
No_Data : Stream_Element_Array := (1 .. 0 => 0); |
||||
Last : Stream_Element_Offset; |
||||
begin |
||||
Translate (Filter, No_Data, Last, Out_Data, Out_Last, Flush); |
||||
end Flush; |
||||
|
||||
----------------------- |
||||
-- Generic_Translate -- |
||||
----------------------- |
||||
|
||||
procedure Generic_Translate |
||||
(Filter : in out ZLib.Filter_Type; |
||||
In_Buffer_Size : Integer := Default_Buffer_Size; |
||||
Out_Buffer_Size : Integer := Default_Buffer_Size) |
||||
is |
||||
In_Buffer : Stream_Element_Array |
||||
(1 .. Stream_Element_Offset (In_Buffer_Size)); |
||||
Out_Buffer : Stream_Element_Array |
||||
(1 .. Stream_Element_Offset (Out_Buffer_Size)); |
||||
Last : Stream_Element_Offset; |
||||
In_Last : Stream_Element_Offset; |
||||
In_First : Stream_Element_Offset; |
||||
Out_Last : Stream_Element_Offset; |
||||
begin |
||||
Main : loop |
||||
Data_In (In_Buffer, Last); |
||||
|
||||
In_First := In_Buffer'First; |
||||
|
||||
loop |
||||
Translate |
||||
(Filter, |
||||
In_Buffer (In_First .. Last), |
||||
In_Last, |
||||
Out_Buffer, |
||||
Out_Last, |
||||
Flush_Finish (Last < In_Buffer'First)); |
||||
|
||||
Data_Out (Out_Buffer (Out_Buffer'First .. Out_Last)); |
||||
|
||||
exit Main when Stream_End (Filter); |
||||
|
||||
-- The end of in buffer. |
||||
exit when In_Last = Last; |
||||
|
||||
In_First := In_Last + 1; |
||||
end loop; |
||||
end loop Main; |
||||
|
||||
end Generic_Translate; |
||||
|
||||
------------------ |
||||
-- Inflate_Init -- |
||||
------------------ |
||||
|
||||
procedure Inflate_Init |
||||
(Filter : in out Filter_Type; |
||||
Window_Bits : in Window_Bits_Type := 15; |
||||
Header : in Header_Type := Default) |
||||
is |
||||
use type Thin.Int; |
||||
Win_Bits : Thin.Int := Thin.Int (Window_Bits); |
||||
|
||||
procedure Check_Version; |
||||
-- Check the latest header types compatibility. |
||||
|
||||
procedure Check_Version is |
||||
begin |
||||
if Version <= "1.1.4" then |
||||
Raise_Error |
||||
("Inflate header type " & Header_Type'Image (Header) |
||||
& " incompatible with ZLib version " & Version); |
||||
end if; |
||||
end Check_Version; |
||||
|
||||
begin |
||||
case Header is |
||||
when None => |
||||
Check_Version; |
||||
|
||||
-- Inflate data without headers determined |
||||
-- by negative Win_Bits. |
||||
|
||||
Win_Bits := -Win_Bits; |
||||
when GZip => |
||||
Check_Version; |
||||
|
||||
-- Inflate gzip data defined by flag 16. |
||||
|
||||
Win_Bits := Win_Bits + 16; |
||||
when Auto => |
||||
Check_Version; |
||||
|
||||
-- Inflate with automatic detection |
||||
-- of gzip or native header defined by flag 32. |
||||
|
||||
Win_Bits := Win_Bits + 32; |
||||
when Default => null; |
||||
end case; |
||||
|
||||
Filter.Strm := new Z_Stream; |
||||
Filter.Compression := False; |
||||
Filter.Stream_End := False; |
||||
Filter.Opened := True; |
||||
Filter.Header := Header; |
||||
|
||||
if Thin.Inflate_Init |
||||
(To_Thin_Access (Filter.Strm), Win_Bits) /= Thin.Z_OK |
||||
then |
||||
Raise_Error (Filter.Strm.all); |
||||
end if; |
||||
end Inflate_Init; |
||||
|
||||
----------------- |
||||
-- Raise_Error -- |
||||
----------------- |
||||
|
||||
procedure Raise_Error (Message : String) is |
||||
begin |
||||
Ada.Exceptions.Raise_Exception (ZLib_Error'Identity, Message); |
||||
end Raise_Error; |
||||
|
||||
procedure Raise_Error (Stream : Z_Stream) is |
||||
begin |
||||
Raise_Error (Last_Error_Message (Stream)); |
||||
end Raise_Error; |
||||
|
||||
---------- |
||||
-- Read -- |
||||
---------- |
||||
|
||||
procedure Read |
||||
(Filter : in out Filter_Type; |
||||
Item : out Ada.Streams.Stream_Element_Array; |
||||
Last : out Ada.Streams.Stream_Element_Offset) |
||||
is |
||||
In_Last : Stream_Element_Offset; |
||||
Item_First : Ada.Streams.Stream_Element_Offset := Item'First; |
||||
|
||||
begin |
||||
pragma Assert (Rest_First in Buffer'First .. Buffer'Last + 1); |
||||
|
||||
loop |
||||
if Rest_First > Buffer'Last then |
||||
Read (Buffer, Rest_Last); |
||||
Rest_First := Buffer'First; |
||||
end if; |
||||
|
||||
pragma Assert (Rest_Last in Buffer'First - 1 .. Buffer'Last); |
||||
|
||||
Translate |
||||
(Filter => Filter, |
||||
In_Data => Buffer (Rest_First .. Rest_Last), |
||||
In_Last => In_Last, |
||||
Out_Data => Item (Item_First .. Item'Last), |
||||
Out_Last => Last, |
||||
Flush => Flush_Finish (Rest_Last < Rest_First)); |
||||
|
||||
Rest_First := In_Last + 1; |
||||
|
||||
exit when Last = Item'Last or else Stream_End (Filter); |
||||
|
||||
Item_First := Last + 1; |
||||
end loop; |
||||
end Read; |
||||
|
||||
---------------- |
||||
-- Stream_End -- |
||||
---------------- |
||||
|
||||
function Stream_End (Filter : in Filter_Type) return Boolean is |
||||
begin |
||||
if Filter.Header = GZip and Filter.Compression then |
||||
return Filter.Stream_End |
||||
and then Filter.Offset = Footer_Array'Last + 1; |
||||
else |
||||
return Filter.Stream_End; |
||||
end if; |
||||
end Stream_End; |
||||
|
||||
-------------- |
||||
-- Total_In -- |
||||
-------------- |
||||
|
||||
function Total_In (Filter : in Filter_Type) return Count is |
||||
begin |
||||
return Count (Thin.Total_In (To_Thin_Access (Filter.Strm).all)); |
||||
end Total_In; |
||||
|
||||
--------------- |
||||
-- Total_Out -- |
||||
--------------- |
||||
|
||||
function Total_Out (Filter : in Filter_Type) return Count is |
||||
begin |
||||
return Count (Thin.Total_Out (To_Thin_Access (Filter.Strm).all)); |
||||
end Total_Out; |
||||
|
||||
--------------- |
||||
-- Translate -- |
||||
--------------- |
||||
|
||||
procedure Translate |
||||
(Filter : in out Filter_Type; |
||||
In_Data : in Ada.Streams.Stream_Element_Array; |
||||
In_Last : out Ada.Streams.Stream_Element_Offset; |
||||
Out_Data : out Ada.Streams.Stream_Element_Array; |
||||
Out_Last : out Ada.Streams.Stream_Element_Offset; |
||||
Flush : in Flush_Mode) is |
||||
begin |
||||
if Filter.Header = GZip and then Filter.Compression then |
||||
Translate_GZip |
||||
(Filter => Filter, |
||||
In_Data => In_Data, |
||||
In_Last => In_Last, |
||||
Out_Data => Out_Data, |
||||
Out_Last => Out_Last, |
||||
Flush => Flush); |
||||
else |
||||
Translate_Auto |
||||
(Filter => Filter, |
||||
In_Data => In_Data, |
||||
In_Last => In_Last, |
||||
Out_Data => Out_Data, |
||||
Out_Last => Out_Last, |
||||
Flush => Flush); |
||||
end if; |
||||
end Translate; |
||||
|
||||
-------------------- |
||||
-- Translate_Auto -- |
||||
-------------------- |
||||
|
||||
procedure Translate_Auto |
||||
(Filter : in out Filter_Type; |
||||
In_Data : in Ada.Streams.Stream_Element_Array; |
||||
In_Last : out Ada.Streams.Stream_Element_Offset; |
||||
Out_Data : out Ada.Streams.Stream_Element_Array; |
||||
Out_Last : out Ada.Streams.Stream_Element_Offset; |
||||
Flush : in Flush_Mode) |
||||
is |
||||
use type Thin.Int; |
||||
Code : Thin.Int; |
||||
|
||||
begin |
||||
if Filter.Opened = False then |
||||
raise ZLib_Error; |
||||
end if; |
||||
|
||||
if Out_Data'Length = 0 then |
||||
raise Constraint_Error; |
||||
end if; |
||||
|
||||
Set_Out (Filter.Strm.all, Out_Data'Address, Out_Data'Length); |
||||
Set_In (Filter.Strm.all, In_Data'Address, In_Data'Length); |
||||
|
||||
Code := Flate (Filter.Compression).Step |
||||
(To_Thin_Access (Filter.Strm), |
||||
Thin.Int (Flush)); |
||||
|
||||
if Code = Thin.Z_STREAM_END then |
||||
Filter.Stream_End := True; |
||||
else |
||||
Check_Error (Filter.Strm.all, Code); |
||||
end if; |
||||
|
||||
In_Last := In_Data'Last |
||||
- Stream_Element_Offset (Avail_In (Filter.Strm.all)); |
||||
Out_Last := Out_Data'Last |
||||
- Stream_Element_Offset (Avail_Out (Filter.Strm.all)); |
||||
|
||||
end Translate_Auto; |
||||
|
||||
-------------------- |
||||
-- Translate_GZip -- |
||||
-------------------- |
||||
|
||||
procedure Translate_GZip |
||||
(Filter : in out Filter_Type; |
||||
In_Data : in Ada.Streams.Stream_Element_Array; |
||||
In_Last : out Ada.Streams.Stream_Element_Offset; |
||||
Out_Data : out Ada.Streams.Stream_Element_Array; |
||||
Out_Last : out Ada.Streams.Stream_Element_Offset; |
||||
Flush : in Flush_Mode) |
||||
is |
||||
Out_First : Stream_Element_Offset; |
||||
|
||||
procedure Add_Data (Data : in Stream_Element_Array); |
||||
-- Add data to stream from the Filter.Offset till necessary, |
||||
-- used for add gzip headr/footer. |
||||
|
||||
procedure Put_32 |
||||
(Item : in out Stream_Element_Array; |
||||
Data : in Unsigned_32); |
||||
pragma Inline (Put_32); |
||||
|
||||
-------------- |
||||
-- Add_Data -- |
||||
-------------- |
||||
|
||||
procedure Add_Data (Data : in Stream_Element_Array) is |
||||
Data_First : Stream_Element_Offset renames Filter.Offset; |
||||
Data_Last : Stream_Element_Offset; |
||||
Data_Len : Stream_Element_Offset; -- -1 |
||||
Out_Len : Stream_Element_Offset; -- -1 |
||||
begin |
||||
Out_First := Out_Last + 1; |
||||
|
||||
if Data_First > Data'Last then |
||||
return; |
||||
end if; |
||||
|
||||
Data_Len := Data'Last - Data_First; |
||||
Out_Len := Out_Data'Last - Out_First; |
||||
|
||||
if Data_Len <= Out_Len then |
||||
Out_Last := Out_First + Data_Len; |
||||
Data_Last := Data'Last; |
||||
else |
||||
Out_Last := Out_Data'Last; |
||||
Data_Last := Data_First + Out_Len; |
||||
end if; |
||||
|
||||
Out_Data (Out_First .. Out_Last) := Data (Data_First .. Data_Last); |
||||
|
||||
Data_First := Data_Last + 1; |
||||
Out_First := Out_Last + 1; |
||||
end Add_Data; |
||||
|
||||
------------ |
||||
-- Put_32 -- |
||||
------------ |
||||
|
||||
procedure Put_32 |
||||
(Item : in out Stream_Element_Array; |
||||
Data : in Unsigned_32) |
||||
is |
||||
D : Unsigned_32 := Data; |
||||
begin |
||||
for J in Item'First .. Item'First + 3 loop |
||||
Item (J) := Stream_Element (D and 16#FF#); |
||||
D := Shift_Right (D, 8); |
||||
end loop; |
||||
end Put_32; |
||||
|
||||
begin |
||||
Out_Last := Out_Data'First - 1; |
||||
|
||||
if not Filter.Stream_End then |
||||
Add_Data (Simple_GZip_Header); |
||||
|
||||
Translate_Auto |
||||
(Filter => Filter, |
||||
In_Data => In_Data, |
||||
In_Last => In_Last, |
||||
Out_Data => Out_Data (Out_First .. Out_Data'Last), |
||||
Out_Last => Out_Last, |
||||
Flush => Flush); |
||||
|
||||
CRC32 (Filter.CRC, In_Data (In_Data'First .. In_Last)); |
||||
|
||||
end if; |
||||
|
||||
if Filter.Stream_End and then Out_Last <= Out_Data'Last then |
||||
-- This detection method would work only when |
||||
-- Simple_GZip_Header'Last > Footer_Array'Last |
||||
|
||||
if Filter.Offset = Simple_GZip_Header'Last + 1 then |
||||
Filter.Offset := Footer_Array'First; |
||||
end if; |
||||
|
||||
declare |
||||
Footer : Footer_Array; |
||||
begin |
||||
Put_32 (Footer, Filter.CRC); |
||||
Put_32 (Footer (Footer'First + 4 .. Footer'Last), |
||||
Unsigned_32 (Total_In (Filter))); |
||||
Add_Data (Footer); |
||||
end; |
||||
end if; |
||||
end Translate_GZip; |
||||
|
||||
------------- |
||||
-- Version -- |
||||
------------- |
||||
|
||||
function Version return String is |
||||
begin |
||||
return Interfaces.C.Strings.Value (Thin.zlibVersion); |
||||
end Version; |
||||
|
||||
----------- |
||||
-- Write -- |
||||
----------- |
||||
|
||||
procedure Write |
||||
(Filter : in out Filter_Type; |
||||
Item : in Ada.Streams.Stream_Element_Array; |
||||
Flush : in Flush_Mode) |
||||
is |
||||
Buffer : Stream_Element_Array (1 .. Buffer_Size); |
||||
In_Last, Out_Last : Stream_Element_Offset; |
||||
In_First : Stream_Element_Offset := Item'First; |
||||
begin |
||||
if Item'Length = 0 and Flush = No_Flush then |
||||
return; |
||||
end if; |
||||
|
||||
loop |
||||
Translate |
||||
(Filter => Filter, |
||||
In_Data => Item (In_First .. Item'Last), |
||||
In_Last => In_Last, |
||||
Out_Data => Buffer, |
||||
Out_Last => Out_Last, |
||||
Flush => Flush); |
||||
|
||||
if Out_Last >= Buffer'First then |
||||
Write (Buffer (1 .. Out_Last)); |
||||
end if; |
||||
|
||||
exit when In_Last = Item'Last or Stream_End (Filter); |
||||
|
||||
In_First := In_Last + 1; |
||||
end loop; |
||||
end Write; |
||||
|
||||
end ZLib; |
||||
@ -0,0 +1,311 @@ |
||||
------------------------------------------------------------------------------ |
||||
-- ZLib for Ada thick binding. -- |
||||
-- -- |
||||
-- Copyright (C) 2002-2003 Dmitriy Anisimkov -- |
||||
-- -- |
||||
-- This library 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. -- |
||||
-- -- |
||||
-- As a special exception, if other files instantiate generics from this -- |
||||
-- unit, or you link this unit with other files to produce an executable, -- |
||||
-- this unit does not by itself cause the resulting executable to be -- |
||||
-- covered by the GNU General Public License. This exception does not -- |
||||
-- however invalidate any other reasons why the executable file might be -- |
||||
-- covered by the GNU Public License. -- |
||||
------------------------------------------------------------------------------ |
||||
|
||||
-- $Id: zlib.ads,v 1.17 2003/08/12 13:19:07 vagul Exp $ |
||||
|
||||
with Ada.Streams; |
||||
|
||||
with Interfaces; |
||||
|
||||
package ZLib is |
||||
|
||||
ZLib_Error : exception; |
||||
|
||||
type Compression_Level is new Integer range -1 .. 9; |
||||
|
||||
type Flush_Mode is private; |
||||
|
||||
type Compression_Method is private; |
||||
|
||||
type Window_Bits_Type is new Integer range 8 .. 15; |
||||
|
||||
type Memory_Level_Type is new Integer range 1 .. 9; |
||||
|
||||
type Unsigned_32 is new Interfaces.Unsigned_32; |
||||
|
||||
type Strategy_Type is private; |
||||
|
||||
type Header_Type is (None, Auto, Default, GZip); |
||||
-- Header type usage have a some limitation for inflate. |
||||
-- See comment for Inflate_Init. |
||||
|
||||
subtype Count is Ada.Streams.Stream_Element_Count; |
||||
|
||||
---------------------------------- |
||||
-- Compression method constants -- |
||||
---------------------------------- |
||||
|
||||
Deflated : constant Compression_Method; |
||||
-- Only one method allowed in this ZLib version. |
||||
|
||||
--------------------------------- |
||||
-- Compression level constants -- |
||||
--------------------------------- |
||||
|
||||
No_Compression : constant Compression_Level := 0; |
||||
Best_Speed : constant Compression_Level := 1; |
||||
Best_Compression : constant Compression_Level := 9; |
||||
Default_Compression : constant Compression_Level := -1; |
||||
|
||||
-------------------------- |
||||
-- Flush mode constants -- |
||||
-------------------------- |
||||
|
||||
No_Flush : constant Flush_Mode; |
||||
-- Regular way for compression, no flush |
||||
|
||||
Partial_Flush : constant Flush_Mode; |
||||
-- will be removed, use Z_SYNC_FLUSH instead |
||||
|
||||
Sync_Flush : constant Flush_Mode; |
||||
-- 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. |
||||
|
||||
Full_Flush : constant Flush_Mode; |
||||
-- all output is flushed as with 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 |
||||
-- FULL_FLUSH too often can seriously degrade the compression. |
||||
|
||||
Finish : constant Flush_Mode; |
||||
-- Just for tell the compressor that input data is complete. |
||||
|
||||
------------------------------------ |
||||
-- Compression strategy constants -- |
||||
------------------------------------ |
||||
|
||||
-- RLE stategy could be used only in version 1.2.0 and later. |
||||
|
||||
Filtered : constant Strategy_Type; |
||||
Huffman_Only : constant Strategy_Type; |
||||
RLE : constant Strategy_Type; |
||||
Default_Strategy : constant Strategy_Type; |
||||
|
||||
Default_Buffer_Size : constant := 4096; |
||||
|
||||
type Filter_Type is limited private; |
||||
-- The filter is for compression and for decompression. |
||||
-- The usage of the type is depend of its initialization. |
||||
|
||||
function Version return String; |
||||
pragma Inline (Version); |
||||
-- Return string representation of the ZLib version. |
||||
|
||||
procedure Deflate_Init |
||||
(Filter : in out Filter_Type; |
||||
Level : in Compression_Level := Default_Compression; |
||||
Strategy : in Strategy_Type := Default_Strategy; |
||||
Method : in Compression_Method := Deflated; |
||||
Window_Bits : in Window_Bits_Type := 15; |
||||
Memory_Level : in Memory_Level_Type := 8; |
||||
Header : in Header_Type := Default); |
||||
-- Compressor initialization. |
||||
-- When Header parameter is Auto or Default, then default zlib header |
||||
-- would be provided for compressed data. |
||||
-- When Header is GZip, then gzip header would be set instead of |
||||
-- default header. |
||||
-- When Header is None, no header would be set for compressed data. |
||||
|
||||
procedure Inflate_Init |
||||
(Filter : in out Filter_Type; |
||||
Window_Bits : in Window_Bits_Type := 15; |
||||
Header : in Header_Type := Default); |
||||
-- Decompressor initialization. |
||||
-- Default header type mean that ZLib default header is expecting in the |
||||
-- input compressed stream. |
||||
-- Header type None mean that no header is expecting in the input stream. |
||||
-- GZip header type mean that GZip header is expecting in the |
||||
-- input compressed stream. |
||||
-- Auto header type mean that header type (GZip or Native) would be |
||||
-- detected automatically in the input stream. |
||||
-- Note that header types parameter values None, GZip and Auto is |
||||
-- supporting for inflate routine only in ZLib versions 1.2.0.2 and later. |
||||
-- Deflate_Init is supporting all header types. |
||||
|
||||
procedure Close |
||||
(Filter : in out Filter_Type; |
||||
Ignore_Error : in Boolean := False); |
||||
-- Closing the compression or decompressor. |
||||
-- If stream is closing before the complete and Ignore_Error is False, |
||||
-- The exception would be raised. |
||||
|
||||
generic |
||||
with procedure Data_In |
||||
(Item : out Ada.Streams.Stream_Element_Array; |
||||
Last : out Ada.Streams.Stream_Element_Offset); |
||||
with procedure Data_Out |
||||
(Item : in Ada.Streams.Stream_Element_Array); |
||||
procedure Generic_Translate |
||||
(Filter : in out Filter_Type; |
||||
In_Buffer_Size : in Integer := Default_Buffer_Size; |
||||
Out_Buffer_Size : in Integer := Default_Buffer_Size); |
||||
-- Compressing/decompressing data arrived from Data_In routine |
||||
-- to the Data_Out routine. User should provide Data_In and Data_Out |
||||
-- for compression/decompression data flow. |
||||
-- Compression or decompression depend on initialization of Filter. |
||||
|
||||
function Total_In (Filter : in Filter_Type) return Count; |
||||
pragma Inline (Total_In); |
||||
-- Return total number of input bytes read so far. |
||||
|
||||
function Total_Out (Filter : in Filter_Type) return Count; |
||||
pragma Inline (Total_Out); |
||||
-- Return total number of bytes output so far. |
||||
|
||||
function CRC32 |
||||
(CRC : in Unsigned_32; |
||||
Data : in Ada.Streams.Stream_Element_Array) |
||||
return Unsigned_32; |
||||
pragma Inline (CRC32); |
||||
-- Calculate CRC32, it could be necessary for make gzip format. |
||||
|
||||
procedure CRC32 |
||||
(CRC : in out Unsigned_32; |
||||
Data : in Ada.Streams.Stream_Element_Array); |
||||
pragma Inline (CRC32); |
||||
-- Calculate CRC32, it could be necessary for make gzip format. |
||||
|
||||
------------------------------------------------- |
||||
-- Below is more complex low level routines. -- |
||||
------------------------------------------------- |
||||
|
||||
procedure Translate |
||||
(Filter : in out Filter_Type; |
||||
In_Data : in Ada.Streams.Stream_Element_Array; |
||||
In_Last : out Ada.Streams.Stream_Element_Offset; |
||||
Out_Data : out Ada.Streams.Stream_Element_Array; |
||||
Out_Last : out Ada.Streams.Stream_Element_Offset; |
||||
Flush : in Flush_Mode); |
||||
-- Compressing/decompressing the datas from In_Data buffer to the |
||||
-- Out_Data buffer. |
||||
-- In_Data is incoming data portion, |
||||
-- In_Last is the index of last element from In_Data accepted by the |
||||
-- Filter. |
||||
-- Out_Data is the buffer for output data from the filter. |
||||
-- Out_Last is the last element of the received data from Filter. |
||||
-- To tell the filter that incoming data is complete put the |
||||
-- Flush parameter to FINISH. |
||||
|
||||
function Stream_End (Filter : in Filter_Type) return Boolean; |
||||
pragma Inline (Stream_End); |
||||
-- Return the true when the stream is complete. |
||||
|
||||
procedure Flush |
||||
(Filter : in out Filter_Type; |
||||
Out_Data : out Ada.Streams.Stream_Element_Array; |
||||
Out_Last : out Ada.Streams.Stream_Element_Offset; |
||||
Flush : in Flush_Mode); |
||||
pragma Inline (Flush); |
||||
-- Flushing the data from the compressor. |
||||
|
||||
generic |
||||
with procedure Write |
||||
(Item : in Ada.Streams.Stream_Element_Array); |
||||
-- User should provide this routine for accept |
||||
-- compressed/decompressed data. |
||||
|
||||
Buffer_Size : in Ada.Streams.Stream_Element_Offset |
||||
:= Default_Buffer_Size; |
||||
-- Buffer size for Write user routine. |
||||
|
||||
procedure Write |
||||
(Filter : in out Filter_Type; |
||||
Item : in Ada.Streams.Stream_Element_Array; |
||||
Flush : in Flush_Mode); |
||||
-- Compressing/Decompressing data from Item to the |
||||
-- generic parameter procedure Write. |
||||
-- Output buffer size could be set in Buffer_Size generic parameter. |
||||
|
||||
generic |
||||
with procedure Read |
||||
(Item : out Ada.Streams.Stream_Element_Array; |
||||
Last : out Ada.Streams.Stream_Element_Offset); |
||||
-- User should provide data for compression/decompression |
||||
-- thru this routine. |
||||
|
||||
Buffer : in out Ada.Streams.Stream_Element_Array; |
||||
-- Buffer for keep remaining data from the previous |
||||
-- back read. |
||||
|
||||
Rest_First, Rest_Last : in out Ada.Streams.Stream_Element_Offset; |
||||
-- Rest_First have to be initialized to Buffer'Last + 1 |
||||
-- before usage. |
||||
|
||||
procedure Read |
||||
(Filter : in out Filter_Type; |
||||
Item : out Ada.Streams.Stream_Element_Array; |
||||
Last : out Ada.Streams.Stream_Element_Offset); |
||||
-- Compressing/Decompressing data from generic parameter |
||||
-- procedure Read to the Item. |
||||
-- User should provide Buffer for the operation |
||||
-- and Rest_First variable first time initialized to the Buffer'Last + 1. |
||||
|
||||
private |
||||
|
||||
use Ada.Streams; |
||||
|
||||
type Flush_Mode is new Integer range 0 .. 4; |
||||
|
||||
type Compression_Method is new Integer range 8 .. 8; |
||||
|
||||
type Strategy_Type is new Integer range 0 .. 3; |
||||
|
||||
No_Flush : constant Flush_Mode := 0; |
||||
Sync_Flush : constant Flush_Mode := 2; |
||||
Full_Flush : constant Flush_Mode := 3; |
||||
Finish : constant Flush_Mode := 4; |
||||
Partial_Flush : constant Flush_Mode := 1; |
||||
-- will be removed, use Z_SYNC_FLUSH instead |
||||
|
||||
Filtered : constant Strategy_Type := 1; |
||||
Huffman_Only : constant Strategy_Type := 2; |
||||
RLE : constant Strategy_Type := 3; |
||||
Default_Strategy : constant Strategy_Type := 0; |
||||
|
||||
Deflated : constant Compression_Method := 8; |
||||
|
||||
type Z_Stream; |
||||
|
||||
type Z_Stream_Access is access all Z_Stream; |
||||
|
||||
type Filter_Type is record |
||||
Strm : Z_Stream_Access; |
||||
Compression : Boolean; |
||||
Stream_End : Boolean; |
||||
Header : Header_Type; |
||||
CRC : Unsigned_32; |
||||
Offset : Stream_Element_Offset; |
||||
-- Offset for gzip header/footer output. |
||||
|
||||
Opened : Boolean := False; |
||||
end record; |
||||
|
||||
end ZLib; |
||||
@ -0,0 +1,21 @@ |
||||
project Zlib is |
||||
|
||||
for Languages use ("Ada"); |
||||
for Source_Dirs use ("."); |
||||
for Object_Dir use "."; |
||||
for Main use ("test.adb", "mtest.adb", "read.adb"); |
||||
|
||||
package Compiler is |
||||
for Default_Switches ("ada") use ("-gnatwbcfilopru", "-gnatVcdfimorst", "-gnatyabcefhiklmnoprst"); |
||||
end Compiler; |
||||
|
||||
package Linker is |
||||
for Default_Switches ("ada") use ("-lz"); |
||||
end Linker; |
||||
|
||||
package Builder is |
||||
for Default_Switches ("ada") use ("-s", "-gnatQ"); |
||||
end Builder; |
||||
|
||||
end Zlib; |
||||
|
||||
@ -1,559 +0,0 @@ |
||||
; |
||||
; gvmat32.asm -- Asm 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 need wmask == 0x7fff |
||||
; (assembly code is faster with a fixed wmask) |
||||
; |
||||
; For Visual C++ 4.2 and ML 6.11c (version in directory \MASM611C of Win95 DDK) |
||||
; I compile with : "ml /coff /Zi /c gvmat32.asm" |
||||
; |
||||
|
||||
;uInt longest_match_7fff(s, cur_match) |
||||
; deflate_state *s; |
||||
; IPos cur_match; /* current match */ |
||||
|
||||
NbStack equ 76 |
||||
cur_match equ dword ptr[esp+NbStack-0] |
||||
str_s equ dword ptr[esp+NbStack-4] |
||||
; 5 dword on top (ret,ebp,esi,edi,ebx) |
||||
adrret equ dword ptr[esp+NbStack-8] |
||||
pushebp equ dword ptr[esp+NbStack-12] |
||||
pushedi equ dword ptr[esp+NbStack-16] |
||||
pushesi equ dword ptr[esp+NbStack-20] |
||||
pushebx equ dword ptr[esp+NbStack-24] |
||||
|
||||
chain_length equ dword ptr [esp+NbStack-28] |
||||
limit equ dword ptr [esp+NbStack-32] |
||||
best_len equ dword ptr [esp+NbStack-36] |
||||
window equ dword ptr [esp+NbStack-40] |
||||
prev equ dword ptr [esp+NbStack-44] |
||||
scan_start equ word ptr [esp+NbStack-48] |
||||
wmask equ dword ptr [esp+NbStack-52] |
||||
match_start_ptr equ dword ptr [esp+NbStack-56] |
||||
nice_match equ dword ptr [esp+NbStack-60] |
||||
scan equ dword ptr [esp+NbStack-64] |
||||
|
||||
windowlen equ dword ptr [esp+NbStack-68] |
||||
match_start equ dword ptr [esp+NbStack-72] |
||||
strend equ dword ptr [esp+NbStack-76] |
||||
NbStackAdd equ (NbStack-24) |
||||
|
||||
.386p |
||||
|
||||
name gvmatch |
||||
.MODEL FLAT |
||||
|
||||
|
||||
|
||||
; all the +4 offsets are due to the addition of pending_buf_size (in zlib |
||||
; in the deflate_state structure since the asm code was first written |
||||
; (if you compile with zlib 1.0.4 or older, remove the +4). |
||||
; Note : these value are good with a 8 bytes boundary pack structure |
||||
dep_chain_length equ 70h+4 |
||||
dep_window equ 2ch+4 |
||||
dep_strstart equ 60h+4 |
||||
dep_prev_length equ 6ch+4 |
||||
dep_nice_match equ 84h+4 |
||||
dep_w_size equ 20h+4 |
||||
dep_prev equ 34h+4 |
||||
dep_w_mask equ 28h+4 |
||||
dep_good_match equ 80h+4 |
||||
dep_match_start equ 64h+4 |
||||
dep_lookahead equ 68h+4 |
||||
|
||||
|
||||
_TEXT segment |
||||
|
||||
IFDEF NOUNDERLINE |
||||
public longest_match_7fff |
||||
; public match_init |
||||
ELSE |
||||
public _longest_match_7fff |
||||
; public _match_init |
||||
ENDIF |
||||
|
||||
MAX_MATCH equ 258 |
||||
MIN_MATCH equ 3 |
||||
MIN_LOOKAHEAD equ (MAX_MATCH+MIN_MATCH+1) |
||||
|
||||
|
||||
|
||||
IFDEF NOUNDERLINE |
||||
;match_init proc near |
||||
; ret |
||||
;match_init endp |
||||
ELSE |
||||
;_match_init proc near |
||||
; ret |
||||
;_match_init endp |
||||
ENDIF |
||||
|
||||
|
||||
IFDEF NOUNDERLINE |
||||
longest_match_7fff proc near |
||||
ELSE |
||||
_longest_match_7fff proc near |
||||
ENDIF |
||||
|
||||
mov edx,[esp+4] |
||||
|
||||
|
||||
|
||||
push ebp |
||||
push edi |
||||
push esi |
||||
push ebx |
||||
|
||||
sub esp,NbStackAdd |
||||
|
||||
; initialize or check the variables used in match.asm. |
||||
mov ebp,edx |
||||
|
||||
; chain_length = s->max_chain_length |
||||
; if (prev_length>=good_match) chain_length >>= 2 |
||||
mov edx,[ebp+dep_chain_length] |
||||
mov ebx,[ebp+dep_prev_length] |
||||
cmp [ebp+dep_good_match],ebx |
||||
ja noshr |
||||
shr edx,2 |
||||
noshr: |
||||
; we increment chain_length because in the asm, the --chain_lenght is in the beginning of the loop |
||||
inc edx |
||||
mov edi,[ebp+dep_nice_match] |
||||
mov chain_length,edx |
||||
mov eax,[ebp+dep_lookahead] |
||||
cmp eax,edi |
||||
; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; |
||||
jae nolookaheadnicematch |
||||
mov edi,eax |
||||
nolookaheadnicematch: |
||||
; best_len = s->prev_length |
||||
mov best_len,ebx |
||||
|
||||
; window = s->window |
||||
mov esi,[ebp+dep_window] |
||||
mov ecx,[ebp+dep_strstart] |
||||
mov window,esi |
||||
|
||||
mov nice_match,edi |
||||
; scan = window + strstart |
||||
add esi,ecx |
||||
mov scan,esi |
||||
; dx = *window |
||||
mov dx,word ptr [esi] |
||||
; bx = *(window+best_len-1) |
||||
mov bx,word ptr [esi+ebx-1] |
||||
add esi,MAX_MATCH-1 |
||||
; scan_start = *scan |
||||
mov scan_start,dx |
||||
; strend = scan + MAX_MATCH-1 |
||||
mov strend,esi |
||||
; bx = scan_end = *(window+best_len-1) |
||||
|
||||
; IPos limit = s->strstart > (IPos)MAX_DIST(s) ? |
||||
; s->strstart - (IPos)MAX_DIST(s) : NIL; |
||||
|
||||
mov esi,[ebp+dep_w_size] |
||||
sub esi,MIN_LOOKAHEAD |
||||
; here esi = MAX_DIST(s) |
||||
sub ecx,esi |
||||
ja nodist |
||||
xor ecx,ecx |
||||
nodist: |
||||
mov limit,ecx |
||||
|
||||
; prev = s->prev |
||||
mov edx,[ebp+dep_prev] |
||||
mov prev,edx |
||||
|
||||
; |
||||
mov edx,dword ptr [ebp+dep_match_start] |
||||
mov bp,scan_start |
||||
mov eax,cur_match |
||||
mov match_start,edx |
||||
|
||||
mov edx,window |
||||
mov edi,edx |
||||
add edi,best_len |
||||
mov esi,prev |
||||
dec edi |
||||
; windowlen = window + best_len -1 |
||||
mov windowlen,edi |
||||
|
||||
jmp beginloop2 |
||||
align 4 |
||||
|
||||
; here, in the loop |
||||
; eax = ax = cur_match |
||||
; ecx = limit |
||||
; bx = scan_end |
||||
; bp = scan_start |
||||
; edi = windowlen (window + best_len -1) |
||||
; esi = prev |
||||
|
||||
|
||||
;// here; chain_length <=16 |
||||
normalbeg0add16: |
||||
add chain_length,16 |
||||
jz exitloop |
||||
normalbeg0: |
||||
cmp word ptr[edi+eax],bx |
||||
je normalbeg2noroll |
||||
rcontlabnoroll: |
||||
; cur_match = prev[cur_match & wmask] |
||||
and eax,7fffh |
||||
mov ax,word ptr[esi+eax*2] |
||||
; if cur_match > limit, go to exitloop |
||||
cmp ecx,eax |
||||
jnb exitloop |
||||
; if --chain_length != 0, go to exitloop |
||||
dec chain_length |
||||
jnz normalbeg0 |
||||
jmp exitloop |
||||
|
||||
normalbeg2noroll: |
||||
; if (scan_start==*(cur_match+window)) goto normalbeg2 |
||||
cmp bp,word ptr[edx+eax] |
||||
jne rcontlabnoroll |
||||
jmp normalbeg2 |
||||
|
||||
contloop3: |
||||
mov edi,windowlen |
||||
|
||||
; cur_match = prev[cur_match & wmask] |
||||
and eax,7fffh |
||||
mov ax,word ptr[esi+eax*2] |
||||
; if cur_match > limit, go to exitloop |
||||
cmp ecx,eax |
||||
jnbexitloopshort1: |
||||
jnb exitloop |
||||
; if --chain_length != 0, go to exitloop |
||||
|
||||
|
||||
; begin the main loop |
||||
beginloop2: |
||||
sub chain_length,16+1 |
||||
; if chain_length <=16, don't use the unrolled loop |
||||
jna normalbeg0add16 |
||||
|
||||
do16: |
||||
cmp word ptr[edi+eax],bx |
||||
je normalbeg2dc0 |
||||
|
||||
maccn MACRO lab |
||||
and eax,7fffh |
||||
mov ax,word ptr[esi+eax*2] |
||||
cmp ecx,eax |
||||
jnb exitloop |
||||
cmp word ptr[edi+eax],bx |
||||
je lab |
||||
ENDM |
||||
|
||||
rcontloop0: |
||||
maccn normalbeg2dc1 |
||||
|
||||
rcontloop1: |
||||
maccn normalbeg2dc2 |
||||
|
||||
rcontloop2: |
||||
maccn normalbeg2dc3 |
||||
|
||||
rcontloop3: |
||||
maccn normalbeg2dc4 |
||||
|
||||
rcontloop4: |
||||
maccn normalbeg2dc5 |
||||
|
||||
rcontloop5: |
||||
maccn normalbeg2dc6 |
||||
|
||||
rcontloop6: |
||||
maccn normalbeg2dc7 |
||||
|
||||
rcontloop7: |
||||
maccn normalbeg2dc8 |
||||
|
||||
rcontloop8: |
||||
maccn normalbeg2dc9 |
||||
|
||||
rcontloop9: |
||||
maccn normalbeg2dc10 |
||||
|
||||
rcontloop10: |
||||
maccn short normalbeg2dc11 |
||||
|
||||
rcontloop11: |
||||
maccn short normalbeg2dc12 |
||||
|
||||
rcontloop12: |
||||
maccn short normalbeg2dc13 |
||||
|
||||
rcontloop13: |
||||
maccn short normalbeg2dc14 |
||||
|
||||
rcontloop14: |
||||
maccn short normalbeg2dc15 |
||||
|
||||
rcontloop15: |
||||
and eax,7fffh |
||||
mov ax,word ptr[esi+eax*2] |
||||
cmp ecx,eax |
||||
jnb exitloop |
||||
|
||||
sub chain_length,16 |
||||
ja do16 |
||||
jmp normalbeg0add16 |
||||
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
||||
|
||||
normbeg MACRO rcontlab,valsub |
||||
; if we are here, we know that *(match+best_len-1) == scan_end |
||||
cmp bp,word ptr[edx+eax] |
||||
; if (match != scan_start) goto rcontlab |
||||
jne rcontlab |
||||
; calculate the good chain_length, and we'll compare scan and match string |
||||
add chain_length,16-valsub |
||||
jmp iseq |
||||
ENDM |
||||
|
||||
|
||||
normalbeg2dc11: |
||||
normbeg rcontloop11,11 |
||||
|
||||
normalbeg2dc12: |
||||
normbeg short rcontloop12,12 |
||||
|
||||
normalbeg2dc13: |
||||
normbeg short rcontloop13,13 |
||||
|
||||
normalbeg2dc14: |
||||
normbeg short rcontloop14,14 |
||||
|
||||
normalbeg2dc15: |
||||
normbeg short rcontloop15,15 |
||||
|
||||
normalbeg2dc10: |
||||
normbeg rcontloop10,10 |
||||
|
||||
normalbeg2dc9: |
||||
normbeg rcontloop9,9 |
||||
|
||||
normalbeg2dc8: |
||||
normbeg rcontloop8,8 |
||||
|
||||
normalbeg2dc7: |
||||
normbeg rcontloop7,7 |
||||
|
||||
normalbeg2dc6: |
||||
normbeg rcontloop6,6 |
||||
|
||||
normalbeg2dc5: |
||||
normbeg rcontloop5,5 |
||||
|
||||
normalbeg2dc4: |
||||
normbeg rcontloop4,4 |
||||
|
||||
normalbeg2dc3: |
||||
normbeg rcontloop3,3 |
||||
|
||||
normalbeg2dc2: |
||||
normbeg rcontloop2,2 |
||||
|
||||
normalbeg2dc1: |
||||
normbeg rcontloop1,1 |
||||
|
||||
normalbeg2dc0: |
||||
normbeg rcontloop0,0 |
||||
|
||||
|
||||
; we go in normalbeg2 because *(ushf*)(match+best_len-1) == scan_end |
||||
|
||||
normalbeg2: |
||||
mov edi,window |
||||
|
||||
cmp bp,word ptr[edi+eax] |
||||
jne contloop3 ; if *(ushf*)match != scan_start, continue |
||||
|
||||
iseq: |
||||
; if we are here, we know that *(match+best_len-1) == scan_end |
||||
; and (match == scan_start) |
||||
|
||||
mov edi,edx |
||||
mov esi,scan ; esi = scan |
||||
add edi,eax ; edi = window + cur_match = match |
||||
|
||||
mov edx,[esi+3] ; compare manually dword at match+3 |
||||
xor edx,[edi+3] ; and scan +3 |
||||
|
||||
jz begincompare ; if equal, go to long compare |
||||
|
||||
; we will determine the unmatch byte and calculate len (in esi) |
||||
or dl,dl |
||||
je eq1rr |
||||
mov esi,3 |
||||
jmp trfinval |
||||
eq1rr: |
||||
or dx,dx |
||||
je eq1 |
||||
|
||||
mov esi,4 |
||||
jmp trfinval |
||||
eq1: |
||||
and edx,0ffffffh |
||||
jz eq11 |
||||
mov esi,5 |
||||
jmp trfinval |
||||
eq11: |
||||
mov esi,6 |
||||
jmp trfinval |
||||
|
||||
begincompare: |
||||
; here we now scan and match begin same |
||||
add edi,6 |
||||
add esi,6 |
||||
mov ecx,(MAX_MATCH-(2+4))/4 ; scan for at most MAX_MATCH bytes |
||||
repe cmpsd ; loop until mismatch |
||||
|
||||
je trfin ; go to trfin if not unmatch |
||||
; we determine the unmatch byte |
||||
sub esi,4 |
||||
mov edx,[edi-4] |
||||
xor edx,[esi] |
||||
|
||||
or dl,dl |
||||
jnz trfin |
||||
inc esi |
||||
|
||||
or dx,dx |
||||
jnz trfin |
||||
inc esi |
||||
|
||||
and edx,0ffffffh |
||||
jnz trfin |
||||
inc esi |
||||
|
||||
trfin: |
||||
sub esi,scan ; esi = len |
||||
trfinval: |
||||
; here we have finised compare, and esi contain len of equal string |
||||
cmp esi,best_len ; if len > best_len, go newbestlen |
||||
ja short newbestlen |
||||
; now we restore edx, ecx and esi, for the big loop |
||||
mov esi,prev |
||||
mov ecx,limit |
||||
mov edx,window |
||||
jmp contloop3 |
||||
|
||||
newbestlen: |
||||
mov best_len,esi ; len become best_len |
||||
|
||||
mov match_start,eax ; save new position as match_start |
||||
cmp esi,nice_match ; if best_len >= nice_match, exit |
||||
jae exitloop |
||||
mov ecx,scan |
||||
mov edx,window ; restore edx=window |
||||
add ecx,esi |
||||
add esi,edx |
||||
|
||||
dec esi |
||||
mov windowlen,esi ; windowlen = window + best_len-1 |
||||
mov bx,[ecx-1] ; bx = *(scan+best_len-1) = scan_end |
||||
|
||||
; now we restore ecx and esi, for the big loop : |
||||
mov esi,prev |
||||
mov ecx,limit |
||||
jmp contloop3 |
||||
|
||||
exitloop: |
||||
; exit : s->match_start=match_start |
||||
mov ebx,match_start |
||||
mov ebp,str_s |
||||
mov ecx,best_len |
||||
mov dword ptr [ebp+dep_match_start],ebx |
||||
mov eax,dword ptr [ebp+dep_lookahead] |
||||
cmp ecx,eax |
||||
ja minexlo |
||||
mov eax,ecx |
||||
minexlo: |
||||
; return min(best_len,s->lookahead) |
||||
|
||||
; restore stack and register ebx,esi,edi,ebp |
||||
add esp,NbStackAdd |
||||
|
||||
pop ebx |
||||
pop esi |
||||
pop edi |
||||
pop ebp |
||||
ret |
||||
InfoAuthor: |
||||
; please don't remove this string ! |
||||
; Your are free use gvmat32 in any fre or commercial apps if you don't remove the string in the binary! |
||||
db 0dh,0ah,"GVMat32 optimised assembly code written 1996-98 by Gilles Vollant",0dh,0ah |
||||
|
||||
|
||||
|
||||
IFDEF NOUNDERLINE |
||||
longest_match_7fff endp |
||||
ELSE |
||||
_longest_match_7fff endp |
||||
ENDIF |
||||
|
||||
|
||||
IFDEF NOUNDERLINE |
||||
cpudetect32 proc near |
||||
ELSE |
||||
_cpudetect32 proc near |
||||
ENDIF |
||||
|
||||
|
||||
pushfd ; push original EFLAGS |
||||
pop eax ; get original EFLAGS |
||||
mov ecx, eax ; save original EFLAGS |
||||
xor eax, 40000h ; flip AC bit in EFLAGS |
||||
push eax ; save new EFLAGS value on stack |
||||
popfd ; replace current EFLAGS value |
||||
pushfd ; get new EFLAGS |
||||
pop eax ; store new EFLAGS in EAX |
||||
xor eax, ecx ; can’t toggle AC bit, processor=80386 |
||||
jz end_cpu_is_386 ; jump if 80386 processor |
||||
push ecx |
||||
popfd ; restore AC bit in EFLAGS first |
||||
|
||||
pushfd |
||||
pushfd |
||||
pop ecx |
||||
|
||||
mov eax, ecx ; get original EFLAGS |
||||
xor eax, 200000h ; flip ID bit in EFLAGS |
||||
push eax ; save new EFLAGS value on stack |
||||
popfd ; replace current EFLAGS value |
||||
pushfd ; get new EFLAGS |
||||
pop eax ; store new EFLAGS in EAX |
||||
popfd ; restore original EFLAGS |
||||
xor eax, ecx ; can’t toggle ID bit, |
||||
je is_old_486 ; processor=old |
||||
|
||||
mov eax,1 |
||||
db 0fh,0a2h ;CPUID |
||||
|
||||
exitcpudetect: |
||||
ret |
||||
|
||||
end_cpu_is_386: |
||||
mov eax,0300h |
||||
jmp exitcpudetect |
||||
|
||||
is_old_486: |
||||
mov eax,0400h |
||||
jmp exitcpudetect |
||||
|
||||
IFDEF NOUNDERLINE |
||||
cpudetect32 endp |
||||
ELSE |
||||
_cpudetect32 endp |
||||
ENDIF |
||||
|
||||
_TEXT ends |
||||
end |
||||
@ -1,200 +0,0 @@ |
||||
/* 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 <windows.h> |
||||
|
||||
#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 |
||||
#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( |
||||
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==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 */ |
||||
@ -1 +0,0 @@ |
||||
c:\masm611\bin\ml /coff /Zi /c /Flgvmat32.lst gvmat32.asm |
||||
@ -1,74 +0,0 @@ |
||||
LIBRARY "zlib" |
||||
|
||||
DESCRIPTION '"""zlib data compression library"""' |
||||
|
||||
|
||||
VERSION 1.11 |
||||
|
||||
|
||||
HEAPSIZE 1048576,8192 |
||||
|
||||
EXPORTS |
||||
adler32 @1 |
||||
compress @2 |
||||
crc32 @3 |
||||
deflate @4 |
||||
deflateCopy @5 |
||||
deflateEnd @6 |
||||
deflateInit2_ @7 |
||||
deflateInit_ @8 |
||||
deflateParams @9 |
||||
deflateReset @10 |
||||
deflateSetDictionary @11 |
||||
gzclose @12 |
||||
gzdopen @13 |
||||
gzerror @14 |
||||
gzflush @15 |
||||
gzopen @16 |
||||
gzread @17 |
||||
gzwrite @18 |
||||
inflate @19 |
||||
inflateEnd @20 |
||||
inflateInit2_ @21 |
||||
inflateInit_ @22 |
||||
inflateReset @23 |
||||
inflateSetDictionary @24 |
||||
inflateSync @25 |
||||
uncompress @26 |
||||
zlibVersion @27 |
||||
gzprintf @28 |
||||
gzputc @29 |
||||
gzgetc @30 |
||||
gzseek @31 |
||||
gzrewind @32 |
||||
gztell @33 |
||||
gzeof @34 |
||||
gzsetparams @35 |
||||
zError @36 |
||||
inflateSyncPoint @37 |
||||
get_crc_table @38 |
||||
compress2 @39 |
||||
gzputs @40 |
||||
gzgets @41 |
||||
|
||||
unzOpen @61 |
||||
unzClose @62 |
||||
unzGetGlobalInfo @63 |
||||
unzGetCurrentFileInfo @64 |
||||
unzGoToFirstFile @65 |
||||
unzGoToNextFile @66 |
||||
unzOpenCurrentFile @67 |
||||
unzReadCurrentFile @68 |
||||
unztell @70 |
||||
unzeof @71 |
||||
unzCloseCurrentFile @72 |
||||
unzGetGlobalComment @73 |
||||
unzStringFileNameCompare @74 |
||||
unzLocateFile @75 |
||||
unzGetLocalExtrafield @76 |
||||
|
||||
zipOpen @80 |
||||
zipOpenNewFileInZip @81 |
||||
zipWriteInFileInZip @82 |
||||
zipCloseFileInZip @83 |
||||
zipClose @84 |
||||
@ -1,651 +0,0 @@ |
||||
# Microsoft Developer Studio Project File - Name="zlibvc" - Package Owner=<4> |
||||
# Microsoft Developer Studio Generated Build File, Format Version 5.00 |
||||
# ** DO NOT EDIT ** |
||||
|
||||
# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102 |
||||
# TARGTYPE "Win32 (ALPHA) Dynamic-Link Library" 0x0602 |
||||
|
||||
CFG=zlibvc - Win32 Release |
||||
!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 "zlibvc.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 "zlibvc.mak" CFG="zlibvc - Win32 Release" |
||||
!MESSAGE |
||||
!MESSAGE Possible choices for configuration are: |
||||
!MESSAGE |
||||
!MESSAGE "zlibvc - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library") |
||||
!MESSAGE "zlibvc - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library") |
||||
!MESSAGE "zlibvc - Win32 ReleaseAxp" (based on\ |
||||
"Win32 (ALPHA) Dynamic-Link Library") |
||||
!MESSAGE "zlibvc - Win32 ReleaseWithoutAsm" (based on\ |
||||
"Win32 (x86) Dynamic-Link Library") |
||||
!MESSAGE "zlibvc - Win32 ReleaseWithoutCrtdll" (based on\ |
||||
"Win32 (x86) Dynamic-Link Library") |
||||
!MESSAGE |
||||
|
||||
# Begin Project |
||||
# PROP Scc_ProjName "" |
||||
# PROP Scc_LocalPath "" |
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
# PROP BASE Use_MFC 0 |
||||
# 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 Ignore_Export_Lib 0 |
||||
# PROP Target_Dir "" |
||||
CPP=cl.exe |
||||
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c |
||||
# ADD CPP /nologo /MT /W3 /GX /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_WINDLL" /D "_WIN32" /D "BUILD_ZLIBDLL" /D "ZLIB_DLL" /D "DYNAMIC_CRC_TABLE" /D "ASMV" /FAcs /FR /FD /c |
||||
# SUBTRACT CPP /YX |
||||
MTL=midl.exe |
||||
# ADD BASE MTL /nologo /D "NDEBUG" /win32 |
||||
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32 |
||||
RSC=rc.exe |
||||
# ADD BASE RSC /l 0x40c /d "NDEBUG" |
||||
# ADD RSC /l 0x40c /d "NDEBUG" |
||||
BSC32=bscmake.exe |
||||
# ADD BASE BSC32 /nologo |
||||
# ADD BSC32 /nologo |
||||
LINK32=link.exe |
||||
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /machine:I386 |
||||
# ADD LINK32 gvmat32.obj kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib crtdll.lib /nologo /subsystem:windows /dll /map /machine:I386 /nodefaultlib /out:".\Release\zlib.dll" |
||||
# SUBTRACT LINK32 /pdb:none |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
# PROP BASE Use_MFC 0 |
||||
# 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 "" |
||||
CPP=cl.exe |
||||
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c |
||||
# ADD CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_WINDLL" /D "_WIN32" /D "BUILD_ZLIBDLL" /D "ZLIB_DLL" /FD /c |
||||
# SUBTRACT CPP /YX |
||||
MTL=midl.exe |
||||
# ADD BASE MTL /nologo /D "_DEBUG" /win32 |
||||
# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32 |
||||
RSC=rc.exe |
||||
# ADD BASE RSC /l 0x40c /d "_DEBUG" |
||||
# ADD RSC /l 0x40c /d "_DEBUG" |
||||
BSC32=bscmake.exe |
||||
# ADD BASE BSC32 /nologo |
||||
# ADD BSC32 /nologo |
||||
LINK32=link.exe |
||||
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /debug /machine:I386 |
||||
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /subsystem:windows /dll /debug /machine:I386 /out:".\Debug\zlib.dll" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseAxp" |
||||
|
||||
# PROP BASE Use_MFC 0 |
||||
# PROP BASE Use_Debug_Libraries 0 |
||||
# PROP BASE Output_Dir "zlibvc__" |
||||
# PROP BASE Intermediate_Dir "zlibvc__" |
||||
# PROP BASE Ignore_Export_Lib 0 |
||||
# PROP BASE Target_Dir "" |
||||
# PROP Use_MFC 0 |
||||
# PROP Use_Debug_Libraries 0 |
||||
# PROP Output_Dir "zlibvc__" |
||||
# PROP Intermediate_Dir "zlibvc__" |
||||
# PROP Ignore_Export_Lib 0 |
||||
# PROP Target_Dir "" |
||||
MTL=midl.exe |
||||
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32 |
||||
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32 |
||||
CPP=cl.exe |
||||
# ADD BASE CPP /nologo /MT /Gt0 /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_WIN32" /D "BUILD_ZLIBDLL" /D "ZLIB_DLL" /D "DYNAMIC_CRC_TABLE" /FAcs /FR /YX /FD /c |
||||
# ADD CPP /nologo /MT /Gt0 /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_WIN32" /D "BUILD_ZLIBDLL" /D "ZLIB_DLL" /D "DYNAMIC_CRC_TABLE" /FAcs /FR /FD /c |
||||
# SUBTRACT CPP /YX |
||||
RSC=rc.exe |
||||
# ADD BASE RSC /l 0x40c /d "NDEBUG" |
||||
# ADD RSC /l 0x40c /d "NDEBUG" |
||||
BSC32=bscmake.exe |
||||
# ADD BASE BSC32 /nologo |
||||
# ADD BSC32 /nologo |
||||
LINK32=link.exe |
||||
# ADD BASE LINK32 crtdll.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /subsystem:windows /dll /map /machine:ALPHA /nodefaultlib /out:".\Release\zlib.dll" |
||||
# SUBTRACT BASE LINK32 /pdb:none |
||||
# ADD LINK32 crtdll.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /subsystem:windows /dll /map /machine:ALPHA /nodefaultlib /out:"zlibvc__\zlib.dll" |
||||
# SUBTRACT LINK32 /pdb:none |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm" |
||||
|
||||
# PROP BASE Use_MFC 0 |
||||
# PROP BASE Use_Debug_Libraries 0 |
||||
# PROP BASE Output_Dir "zlibvc_0" |
||||
# PROP BASE Intermediate_Dir "zlibvc_0" |
||||
# PROP BASE Ignore_Export_Lib 0 |
||||
# PROP BASE Target_Dir "" |
||||
# PROP Use_MFC 0 |
||||
# PROP Use_Debug_Libraries 0 |
||||
# PROP Output_Dir "zlibvc_0" |
||||
# PROP Intermediate_Dir "zlibvc_0" |
||||
# PROP Ignore_Export_Lib 0 |
||||
# PROP Target_Dir "" |
||||
CPP=cl.exe |
||||
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_WINDLL" /D "_WIN32" /D "BUILD_ZLIBDLL" /D "ZLIB_DLL" /D "DYNAMIC_CRC_TABLE" /FAcs /FR /YX /FD /c |
||||
# ADD CPP /nologo /MT /W3 /GX /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_WINDLL" /D "_WIN32" /D "BUILD_ZLIBDLL" /D "ZLIB_DLL" /D "DYNAMIC_CRC_TABLE" /FAcs /FR /FD /c |
||||
# SUBTRACT CPP /YX |
||||
MTL=midl.exe |
||||
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32 |
||||
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32 |
||||
RSC=rc.exe |
||||
# ADD BASE RSC /l 0x40c /d "NDEBUG" |
||||
# ADD RSC /l 0x40c /d "NDEBUG" |
||||
BSC32=bscmake.exe |
||||
# ADD BASE BSC32 /nologo |
||||
# ADD BSC32 /nologo |
||||
LINK32=link.exe |
||||
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib crtdll.lib /nologo /subsystem:windows /dll /map /machine:I386 /nodefaultlib /out:".\Release\zlib.dll" |
||||
# SUBTRACT BASE LINK32 /pdb:none |
||||
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib crtdll.lib /nologo /subsystem:windows /dll /map /machine:I386 /nodefaultlib /out:".\zlibvc_0\zlib.dll" |
||||
# SUBTRACT LINK32 /pdb:none |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll" |
||||
|
||||
# PROP BASE Use_MFC 0 |
||||
# PROP BASE Use_Debug_Libraries 0 |
||||
# PROP BASE Output_Dir "zlibvc_1" |
||||
# PROP BASE Intermediate_Dir "zlibvc_1" |
||||
# PROP BASE Ignore_Export_Lib 0 |
||||
# PROP BASE Target_Dir "" |
||||
# PROP Use_MFC 0 |
||||
# PROP Use_Debug_Libraries 0 |
||||
# PROP Output_Dir "zlibvc_1" |
||||
# PROP Intermediate_Dir "zlibvc_1" |
||||
# PROP Ignore_Export_Lib 0 |
||||
# PROP Target_Dir "" |
||||
CPP=cl.exe |
||||
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_WINDLL" /D "_WIN32" /D "BUILD_ZLIBDLL" /D "ZLIB_DLL" /D "DYNAMIC_CRC_TABLE" /D "ASMV" /FAcs /FR /YX /FD /c |
||||
# ADD CPP /nologo /MT /W3 /GX /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_WINDLL" /D "_WIN32" /D "BUILD_ZLIBDLL" /D "ZLIB_DLL" /D "DYNAMIC_CRC_TABLE" /D "ASMV" /FAcs /FR /FD /c |
||||
# SUBTRACT CPP /YX |
||||
MTL=midl.exe |
||||
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32 |
||||
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32 |
||||
RSC=rc.exe |
||||
# ADD BASE RSC /l 0x40c /d "NDEBUG" |
||||
# ADD RSC /l 0x40c /d "NDEBUG" |
||||
BSC32=bscmake.exe |
||||
# ADD BASE BSC32 /nologo |
||||
# ADD BSC32 /nologo |
||||
LINK32=link.exe |
||||
# ADD BASE LINK32 gvmat32.obj kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib crtdll.lib /nologo /subsystem:windows /dll /map /machine:I386 /nodefaultlib /out:".\Release\zlib.dll" |
||||
# SUBTRACT BASE LINK32 /pdb:none |
||||
# ADD LINK32 gvmat32.obj kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib crtdll.lib /nologo /subsystem:windows /dll /map /machine:I386 /nodefaultlib /out:".\zlibvc_1\zlib.dll" |
||||
# SUBTRACT LINK32 /pdb:none |
||||
|
||||
!ENDIF |
||||
|
||||
# Begin Target |
||||
|
||||
# Name "zlibvc - Win32 Release" |
||||
# Name "zlibvc - Win32 Debug" |
||||
# Name "zlibvc - Win32 ReleaseAxp" |
||||
# Name "zlibvc - Win32 ReleaseWithoutAsm" |
||||
# Name "zlibvc - Win32 ReleaseWithoutCrtdll" |
||||
# Begin Group "Source Files" |
||||
|
||||
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;hpj;bat;for;f90" |
||||
# Begin Source File |
||||
|
||||
SOURCE=.\adler32.c |
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseAxp" |
||||
|
||||
DEP_CPP_ADLER=\ |
||||
".\zconf.h"\ |
||||
".\zlib.h"\ |
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll" |
||||
|
||||
!ENDIF |
||||
|
||||
# End Source File |
||||
# Begin Source File |
||||
|
||||
SOURCE=.\compress.c |
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseAxp" |
||||
|
||||
DEP_CPP_COMPR=\ |
||||
".\zconf.h"\ |
||||
".\zlib.h"\ |
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll" |
||||
|
||||
!ENDIF |
||||
|
||||
# End Source File |
||||
# Begin Source File |
||||
|
||||
SOURCE=.\crc32.c |
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseAxp" |
||||
|
||||
DEP_CPP_CRC32=\ |
||||
".\zconf.h"\ |
||||
".\zlib.h"\ |
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll" |
||||
|
||||
!ENDIF |
||||
|
||||
# End Source File |
||||
# Begin Source File |
||||
|
||||
SOURCE=.\deflate.c |
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseAxp" |
||||
|
||||
DEP_CPP_DEFLA=\ |
||||
".\deflate.h"\ |
||||
".\zconf.h"\ |
||||
".\zlib.h"\ |
||||
".\zutil.h"\ |
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll" |
||||
|
||||
!ENDIF |
||||
|
||||
# End Source File |
||||
# Begin Source File |
||||
|
||||
SOURCE=.\gvmat32c.c |
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseAxp" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll" |
||||
|
||||
!ENDIF |
||||
|
||||
# End Source File |
||||
# Begin Source File |
||||
|
||||
SOURCE=.\gzio.c |
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseAxp" |
||||
|
||||
DEP_CPP_GZIO_=\ |
||||
".\zconf.h"\ |
||||
".\zlib.h"\ |
||||
".\zutil.h"\ |
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll" |
||||
|
||||
!ENDIF |
||||
|
||||
# End Source File |
||||
# Begin Source File |
||||
|
||||
SOURCE=.\infblock.c |
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseAxp" |
||||
|
||||
DEP_CPP_INFBL=\ |
||||
".\infblock.h"\ |
||||
".\infcodes.h"\ |
||||
".\inftrees.h"\ |
||||
".\infutil.h"\ |
||||
".\zconf.h"\ |
||||
".\zlib.h"\ |
||||
".\zutil.h"\ |
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll" |
||||
|
||||
!ENDIF |
||||
|
||||
# End Source File |
||||
# Begin Source File |
||||
|
||||
SOURCE=.\infcodes.c |
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseAxp" |
||||
|
||||
DEP_CPP_INFCO=\ |
||||
".\infblock.h"\ |
||||
".\infcodes.h"\ |
||||
".\inffast.h"\ |
||||
".\inftrees.h"\ |
||||
".\infutil.h"\ |
||||
".\zconf.h"\ |
||||
".\zlib.h"\ |
||||
".\zutil.h"\ |
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll" |
||||
|
||||
!ENDIF |
||||
|
||||
# End Source File |
||||
# Begin Source File |
||||
|
||||
SOURCE=.\inffast.c |
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseAxp" |
||||
|
||||
DEP_CPP_INFFA=\ |
||||
".\infblock.h"\ |
||||
".\infcodes.h"\ |
||||
".\inffast.h"\ |
||||
".\inftrees.h"\ |
||||
".\infutil.h"\ |
||||
".\zconf.h"\ |
||||
".\zlib.h"\ |
||||
".\zutil.h"\ |
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll" |
||||
|
||||
!ENDIF |
||||
|
||||
# End Source File |
||||
# Begin Source File |
||||
|
||||
SOURCE=.\inflate.c |
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseAxp" |
||||
|
||||
DEP_CPP_INFLA=\ |
||||
".\infblock.h"\ |
||||
".\zconf.h"\ |
||||
".\zlib.h"\ |
||||
".\zutil.h"\ |
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll" |
||||
|
||||
!ENDIF |
||||
|
||||
# End Source File |
||||
# Begin Source File |
||||
|
||||
SOURCE=.\inftrees.c |
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseAxp" |
||||
|
||||
DEP_CPP_INFTR=\ |
||||
".\inftrees.h"\ |
||||
".\zconf.h"\ |
||||
".\zlib.h"\ |
||||
".\zutil.h"\ |
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll" |
||||
|
||||
!ENDIF |
||||
|
||||
# End Source File |
||||
# Begin Source File |
||||
|
||||
SOURCE=.\infutil.c |
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseAxp" |
||||
|
||||
DEP_CPP_INFUT=\ |
||||
".\infblock.h"\ |
||||
".\infcodes.h"\ |
||||
".\inftrees.h"\ |
||||
".\infutil.h"\ |
||||
".\zconf.h"\ |
||||
".\zlib.h"\ |
||||
".\zutil.h"\ |
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll" |
||||
|
||||
!ENDIF |
||||
|
||||
# End Source File |
||||
# Begin Source File |
||||
|
||||
SOURCE=.\trees.c |
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseAxp" |
||||
|
||||
DEP_CPP_TREES=\ |
||||
".\deflate.h"\ |
||||
".\zconf.h"\ |
||||
".\zlib.h"\ |
||||
".\zutil.h"\ |
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll" |
||||
|
||||
!ENDIF |
||||
|
||||
# End Source File |
||||
# Begin Source File |
||||
|
||||
SOURCE=.\uncompr.c |
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseAxp" |
||||
|
||||
DEP_CPP_UNCOM=\ |
||||
".\zconf.h"\ |
||||
".\zlib.h"\ |
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll" |
||||
|
||||
!ENDIF |
||||
|
||||
# End Source File |
||||
# Begin Source File |
||||
|
||||
SOURCE=.\unzip.c |
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseAxp" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll" |
||||
|
||||
!ENDIF |
||||
|
||||
# End Source File |
||||
# Begin Source File |
||||
|
||||
SOURCE=.\zip.c |
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseAxp" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll" |
||||
|
||||
!ENDIF |
||||
|
||||
# End Source File |
||||
# Begin Source File |
||||
|
||||
SOURCE=.\zlib.rc |
||||
# End Source File |
||||
# Begin Source File |
||||
|
||||
SOURCE=.\zlibvc.def |
||||
# End Source File |
||||
# Begin Source File |
||||
|
||||
SOURCE=.\zutil.c |
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseAxp" |
||||
|
||||
DEP_CPP_ZUTIL=\ |
||||
".\zconf.h"\ |
||||
".\zlib.h"\ |
||||
".\zutil.h"\ |
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutAsm" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 ReleaseWithoutCrtdll" |
||||
|
||||
!ENDIF |
||||
|
||||
# End Source File |
||||
# End Group |
||||
# Begin Group "Header Files" |
||||
|
||||
# PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd" |
||||
# Begin Source File |
||||
|
||||
SOURCE=.\deflate.h |
||||
# End Source File |
||||
# Begin Source File |
||||
|
||||
SOURCE=.\infblock.h |
||||
# End Source File |
||||
# Begin Source File |
||||
|
||||
SOURCE=.\infcodes.h |
||||
# End Source File |
||||
# Begin Source File |
||||
|
||||
SOURCE=.\inffast.h |
||||
# End Source File |
||||
# Begin Source File |
||||
|
||||
SOURCE=.\inftrees.h |
||||
# End Source File |
||||
# Begin Source File |
||||
|
||||
SOURCE=.\infutil.h |
||||
# End Source File |
||||
# Begin Source File |
||||
|
||||
SOURCE=.\zconf.h |
||||
# End Source File |
||||
# Begin Source File |
||||
|
||||
SOURCE=.\zlib.h |
||||
# End Source File |
||||
# Begin Source File |
||||
|
||||
SOURCE=.\zutil.h |
||||
# End Source File |
||||
# End Group |
||||
# Begin Group "Resource Files" |
||||
|
||||
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;cnt;rtf;gif;jpg;jpeg;jpe" |
||||
# End Group |
||||
# End Target |
||||
# End Project |
||||
@ -1,41 +0,0 @@ |
||||
Microsoft Developer Studio Workspace File, Format Version 5.00 |
||||
# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE! |
||||
|
||||
############################################################################### |
||||
|
||||
Project: "zlibstat"=.\zlibstat.dsp - Package Owner=<4> |
||||
|
||||
Package=<5> |
||||
{{{ |
||||
}}} |
||||
|
||||
Package=<4> |
||||
{{{ |
||||
}}} |
||||
|
||||
############################################################################### |
||||
|
||||
Project: "zlibvc"=.\zlibvc.dsp - Package Owner=<4> |
||||
|
||||
Package=<5> |
||||
{{{ |
||||
}}} |
||||
|
||||
Package=<4> |
||||
{{{ |
||||
}}} |
||||
|
||||
############################################################################### |
||||
|
||||
Global: |
||||
|
||||
Package=<5> |
||||
{{{ |
||||
}}} |
||||
|
||||
Package=<3> |
||||
{{{ |
||||
}}} |
||||
|
||||
############################################################################### |
||||
|
||||
@ -0,0 +1,11 @@ |
||||
unit ZLibConst; |
||||
|
||||
interface |
||||
|
||||
resourcestring |
||||
sTargetBufferTooSmall = 'ZLib error: target buffer may be too small'; |
||||
sInvalidStreamOp = 'Invalid stream operation'; |
||||
|
||||
implementation |
||||
|
||||
end. |
||||
@ -0,0 +1,76 @@ |
||||
|
||||
Overview |
||||
======== |
||||
|
||||
This directory contains an update to the ZLib interface unit, |
||||
distributed by Borland as a Delphi supplemental component. |
||||
|
||||
The original ZLib unit is Copyright (c) 1997,99 Borland Corp., |
||||
and is based on zlib version 1.0.4. There are a series of bugs |
||||
and security problems associated with that old zlib version, and |
||||
we recommend the users to update their ZLib unit. |
||||
|
||||
|
||||
Summary of modifications |
||||
======================== |
||||
|
||||
- Improved makefile, adapted to zlib version 1.2.0. |
||||
|
||||
- Some field types from TZStreamRec are changed from Integer to |
||||
Longint, for consistency with the zlib.h header, and for 64-bit |
||||
readiness. |
||||
|
||||
- The zlib_version constant is updated. |
||||
|
||||
- The new Z_RLE strategy has its corresponding symbolic constant. |
||||
|
||||
- The allocation and deallocation functions and function types |
||||
(TAlloc, TFree, zlibAllocMem and zlibFreeMem) are now cdecl, |
||||
and _malloc and _free are added as C RTL stubs. As a result, |
||||
the original C sources of zlib can be compiled out of the box, |
||||
and linked to the ZLib unit. |
||||
|
||||
|
||||
Suggestions for improvements |
||||
============================ |
||||
|
||||
Currently, the ZLib unit provides only a limited wrapper around |
||||
the zlib library, and much of the original zlib functionality is |
||||
missing. Handling compressed file formats like ZIP/GZIP or PNG |
||||
cannot be implemented without having this functionality. |
||||
Applications that handle these formats are either using their own, |
||||
duplicated code, or not using the ZLib unit at all. |
||||
|
||||
Here are a few suggestions: |
||||
|
||||
- Checksum class wrappers around adler32() and crc32(), similar |
||||
to the Java classes that implement the java.util.zip.Checksum |
||||
interface. |
||||
|
||||
- The ability to read and write raw deflate streams, without the |
||||
zlib stream header and trailer. Raw deflate streams are used |
||||
in the ZIP file format. |
||||
|
||||
- The ability to read and write gzip streams, used in the GZIP |
||||
file format, and normally produced by the gzip program. |
||||
|
||||
- The ability to select a different compression strategy, useful |
||||
to PNG and MNG image compression, and to multimedia compression |
||||
in general. Besides the compression level |
||||
|
||||
TCompressionLevel = (clNone, clFastest, clDefault, clMax); |
||||
|
||||
which, in fact, could have used the 'z' prefix and avoided |
||||
TColor-like symbols |
||||
|
||||
TCompressionLevel = (zcNone, zcFastest, zcDefault, zcMax); |
||||
|
||||
there could be a compression strategy |
||||
|
||||
TCompressionStrategy = (zsDefault, zsFiltered, zsHuffmanOnly, zsRle); |
||||
|
||||
- ZIP and GZIP stream handling via TStreams. |
||||
|
||||
|
||||
-- |
||||
Cosmin Truta <cosmint@cs.ubbcluj.ro> |
||||
@ -1,36 +0,0 @@ |
||||
# Makefile for zlib32bd.lib
|
||||
# ------------- Borland C++ 4.5 -------------
|
||||
|
||||
# The (32-bit) zlib32bd.lib made with this makefile is intended for use
|
||||
# in making the (32-bit) DLL, png32bd.dll. It uses the "stdcall" calling
|
||||
# convention.
|
||||
|
||||
CFLAGS= -ps -O2 -C -K -N- -k- -d -3 -r- -w-par -w-aus -WDE
|
||||
CC=f:\bc45\bin\bcc32
|
||||
LIBFLAGS= /C
|
||||
LIB=f:\bc45\bin\tlib
|
||||
ZLIB=zlib32bd.lib
|
||||
|
||||
.autodepend |
||||
.c.obj: |
||||
$(CC) -c $(CFLAGS) $<
|
||||
|
||||
OBJ1=adler32.obj compress.obj crc32.obj deflate.obj gzio.obj infblock.obj
|
||||
OBJ2=infcodes.obj inflate.obj inftrees.obj infutil.obj inffast.obj
|
||||
OBJ3=trees.obj uncompr.obj zutil.obj
|
||||
pOBJ1=+adler32.obj+compress.obj+crc32.obj+deflate.obj+gzio.obj+infblock.obj
|
||||
pOBJ2=+infcodes.obj+inflate.obj+inftrees.obj+infutil.obj+inffast.obj
|
||||
pOBJ3=+trees.obj+uncompr.obj+zutil.obj
|
||||
|
||||
all: $(ZLIB) |
||||
|
||||
$(ZLIB): $(OBJ1) $(OBJ2) $(OBJ3) |
||||
@if exist $@ del $@
|
||||
$(LIB) @&&|
|
||||
$@ $(LIBFLAGS) & |
||||
$(pOBJ1) & |
||||
$(pOBJ2) & |
||||
$(pOBJ3) |
||||
| |
||||
|
||||
# End of makefile for zlib32bd.lib
|
||||
@ -0,0 +1,93 @@ |
||||
# Makefile for zlib
|
||||
# For use with Delphi and C++ Builder under Win32
|
||||
# Updated for zlib 1.2.x by Cosmin Truta
|
||||
|
||||
# ------------ Borland C++ ------------
|
||||
|
||||
# This project uses the Delphi (fastcall/register) calling convention:
|
||||
LOC = -DZEXPORT=__fastcall -DZEXPORTVA=__cdecl
|
||||
|
||||
CC = bcc32
|
||||
LD = bcc32
|
||||
AR = tlib
|
||||
# do not use "-pr" in CFLAGS
|
||||
CFLAGS = -a -d -k- -O2 $(LOC)
|
||||
LDFLAGS =
|
||||
|
||||
|
||||
# variables
|
||||
ZLIB_LIB = zlib.lib
|
||||
|
||||
OBJ1 = adler32.obj compress.obj crc32.obj deflate.obj gzio.obj infback.obj
|
||||
OBJ2 = inffast.obj inflate.obj inftrees.obj trees.obj uncompr.obj zutil.obj
|
||||
OBJP1 = +adler32.obj+compress.obj+crc32.obj+deflate.obj+gzio.obj+infback.obj
|
||||
OBJP2 = +inffast.obj+inflate.obj+inftrees.obj+trees.obj+uncompr.obj+zutil.obj
|
||||
|
||||
|
||||
# targets
|
||||
all: $(ZLIB_LIB) example.exe minigzip.exe |
||||
|
||||
.c.obj: |
||||
$(CC) -c $(CFLAGS) $*.c
|
||||
|
||||
adler32.obj: adler32.c zlib.h zconf.h |
||||
|
||||
compress.obj: compress.c zlib.h zconf.h |
||||
|
||||
crc32.obj: crc32.c zlib.h zconf.h crc32.h |
||||
|
||||
deflate.obj: deflate.c deflate.h zutil.h zlib.h zconf.h |
||||
|
||||
gzio.obj: gzio.c zutil.h zlib.h zconf.h |
||||
|
||||
infback.obj: infback.c zutil.h zlib.h zconf.h inftrees.h inflate.h \
|
||||
inffast.h inffixed.h
|
||||
|
||||
inffast.obj: inffast.c zutil.h zlib.h zconf.h inftrees.h inflate.h \
|
||||
inffast.h
|
||||
|
||||
inflate.obj: inflate.c zutil.h zlib.h zconf.h inftrees.h inflate.h \
|
||||
inffast.h inffixed.h
|
||||
|
||||
inftrees.obj: inftrees.c zutil.h zlib.h zconf.h inftrees.h |
||||
|
||||
trees.obj: trees.c zutil.h zlib.h zconf.h deflate.h trees.h |
||||
|
||||
uncompr.obj: uncompr.c zlib.h zconf.h |
||||
|
||||
zutil.obj: zutil.c zutil.h zlib.h zconf.h |
||||
|
||||
example.obj: example.c zlib.h zconf.h |
||||
|
||||
minigzip.obj: minigzip.c zlib.h zconf.h |
||||
|
||||
|
||||
# For the sake of the old Borland make,
|
||||
# the command line is cut to fit in the MS-DOS 128 byte limit:
|
||||
$(ZLIB_LIB): $(OBJ1) $(OBJ2) |
||||
-del $(ZLIB_LIB)
|
||||
$(AR) $(ZLIB_LIB) $(OBJP1)
|
||||
$(AR) $(ZLIB_LIB) $(OBJP2)
|
||||
|
||||
|
||||
# testing
|
||||
test: example.exe minigzip.exe |
||||
example
|
||||
echo hello world | minigzip | minigzip -d
|
||||
|
||||
example.exe: example.obj $(ZLIB_LIB) |
||||
$(LD) $(LDFLAGS) example.obj $(ZLIB_LIB)
|
||||
|
||||
minigzip.exe: minigzip.obj $(ZLIB_LIB) |
||||
$(LD) $(LDFLAGS) minigzip.obj $(ZLIB_LIB)
|
||||
|
||||
|
||||
# cleanup
|
||||
clean: |
||||
-del *.obj
|
||||
-del *.exe
|
||||
-del *.lib
|
||||
-del *.tds
|
||||
-del zlib.bak
|
||||
-del foo.gz
|
||||
|
||||
@ -1,169 +0,0 @@ |
||||
unit zlibdef; |
||||
|
||||
interface |
||||
|
||||
uses |
||||
Windows; |
||||
|
||||
const |
||||
ZLIB_VERSION = '1.1.3'; |
||||
|
||||
type |
||||
voidpf = Pointer; |
||||
int = Integer; |
||||
uInt = Cardinal; |
||||
pBytef = PChar; |
||||
uLong = Cardinal; |
||||
|
||||
alloc_func = function(opaque: voidpf; items, size: uInt): voidpf; |
||||
stdcall; |
||||
free_func = procedure(opaque, address: voidpf); |
||||
stdcall; |
||||
|
||||
internal_state = Pointer; |
||||
|
||||
z_streamp = ^z_stream; |
||||
z_stream = packed record |
||||
next_in: pBytef; // next input byte |
||||
avail_in: uInt; // number of bytes available at next_in |
||||
total_in: uLong; // total nb of input bytes read so far |
||||
|
||||
next_out: pBytef; // next output byte should be put there |
||||
avail_out: uInt; // remaining free space at next_out |
||||
total_out: uLong; // total nb of bytes output so far |
||||
|
||||
msg: PChar; // last error message, NULL if no error |
||||
state: internal_state; // not visible by applications |
||||
|
||||
zalloc: alloc_func; // used to allocate the internal state |
||||
zfree: free_func; // used to free the internal state |
||||
opaque: voidpf; // private data object passed to zalloc and zfree |
||||
|
||||
data_type: int; // best guess about the data type: ascii or binary |
||||
adler: uLong; // adler32 value of the uncompressed data |
||||
reserved: uLong; // reserved for future use |
||||
end; |
||||
|
||||
const |
||||
Z_NO_FLUSH = 0; |
||||
Z_SYNC_FLUSH = 2; |
||||
Z_FULL_FLUSH = 3; |
||||
Z_FINISH = 4; |
||||
|
||||
Z_OK = 0; |
||||
Z_STREAM_END = 1; |
||||
|
||||
Z_NO_COMPRESSION = 0; |
||||
Z_BEST_SPEED = 1; |
||||
Z_BEST_COMPRESSION = 9; |
||||
Z_DEFAULT_COMPRESSION = -1; |
||||
|
||||
Z_FILTERED = 1; |
||||
Z_HUFFMAN_ONLY = 2; |
||||
Z_DEFAULT_STRATEGY = 0; |
||||
|
||||
Z_BINARY = 0; |
||||
Z_ASCII = 1; |
||||
Z_UNKNOWN = 2; |
||||
|
||||
Z_DEFLATED = 8; |
||||
|
||||
MAX_MEM_LEVEL = 9; |
||||
|
||||
function adler32(adler: uLong; const buf: pBytef; len: uInt): uLong; |
||||
stdcall; |
||||
function crc32(crc: uLong; const buf: pBytef; len: uInt): uLong; |
||||
stdcall; |
||||
function deflate(strm: z_streamp; flush: int): int; |
||||
stdcall; |
||||
function deflateCopy(dest, source: z_streamp): int; |
||||
stdcall; |
||||
function deflateEnd(strm: z_streamp): int; |
||||
stdcall; |
||||
function deflateInit2_(strm: z_streamp; level, method, |
||||
windowBits, memLevel, strategy: int; |
||||
const version: PChar; stream_size: int): int; |
||||
stdcall; |
||||
function deflateInit_(strm: z_streamp; level: int; |
||||
const version: PChar; stream_size: int): int; |
||||
stdcall; |
||||
function deflateParams(strm: z_streamp; level, strategy: int): int; |
||||
stdcall; |
||||
function deflateReset(strm: z_streamp): int; |
||||
stdcall; |
||||
function deflateSetDictionary(strm: z_streamp; |
||||
const dictionary: pBytef; |
||||
dictLength: uInt): int; |
||||
stdcall; |
||||
function inflate(strm: z_streamp; flush: int): int; |
||||
stdcall; |
||||
function inflateEnd(strm: z_streamp): int; |
||||
stdcall; |
||||
function inflateInit2_(strm: z_streamp; windowBits: int; |
||||
const version: PChar; stream_size: int): int; |
||||
stdcall; |
||||
function inflateInit_(strm: z_streamp; const version: PChar; |
||||
stream_size: int): int; |
||||
stdcall; |
||||
function inflateReset(strm: z_streamp): int; |
||||
stdcall; |
||||
function inflateSetDictionary(strm: z_streamp; |
||||
const dictionary: pBytef; |
||||
dictLength: uInt): int; |
||||
stdcall; |
||||
function inflateSync(strm: z_streamp): int; |
||||
stdcall; |
||||
|
||||
function deflateInit(strm: z_streamp; level: int): int; |
||||
function deflateInit2(strm: z_streamp; level, method, windowBits, |
||||
memLevel, strategy: int): int; |
||||
function inflateInit(strm: z_streamp): int; |
||||
function inflateInit2(strm: z_streamp; windowBits: int): int; |
||||
|
||||
implementation |
||||
|
||||
function deflateInit(strm: z_streamp; level: int): int; |
||||
begin |
||||
Result := deflateInit_(strm, level, ZLIB_VERSION, sizeof(z_stream)); |
||||
end; |
||||
|
||||
function deflateInit2(strm: z_streamp; level, method, windowBits, |
||||
memLevel, strategy: int): int; |
||||
begin |
||||
Result := deflateInit2_(strm, level, method, windowBits, memLevel, |
||||
strategy, ZLIB_VERSION, sizeof(z_stream)); |
||||
end; |
||||
|
||||
function inflateInit(strm: z_streamp): int; |
||||
begin |
||||
Result := inflateInit_(strm, ZLIB_VERSION, sizeof(z_stream)); |
||||
end; |
||||
|
||||
function inflateInit2(strm: z_streamp; windowBits: int): int; |
||||
begin |
||||
Result := inflateInit2_(strm, windowBits, ZLIB_VERSION, |
||||
sizeof(z_stream)); |
||||
end; |
||||
|
||||
const |
||||
zlibDLL = 'png32bd.dll'; |
||||
|
||||
function adler32; external zlibDLL; |
||||
function crc32; external zlibDLL; |
||||
function deflate; external zlibDLL; |
||||
function deflateCopy; external zlibDLL; |
||||
function deflateEnd; external zlibDLL; |
||||
function deflateInit2_; external zlibDLL; |
||||
function deflateInit_; external zlibDLL; |
||||
function deflateParams; external zlibDLL; |
||||
function deflateReset; external zlibDLL; |
||||
function deflateSetDictionary; external zlibDLL; |
||||
function inflate; external zlibDLL; |
||||
function inflateEnd; external zlibDLL; |
||||
function inflateInit2_; external zlibDLL; |
||||
function inflateInit_; external zlibDLL; |
||||
function inflateReset; external zlibDLL; |
||||
function inflateSetDictionary; external zlibDLL; |
||||
function inflateSync; external zlibDLL; |
||||
|
||||
end. |
||||
@ -1,224 +0,0 @@ |
||||
# --------------------------------------------------------------------------- |
||||
!if !$d(BCB) |
||||
BCB = $(MAKEDIR)\.. |
||||
!endif |
||||
|
||||
# --------------------------------------------------------------------------- |
||||
# IDE SECTION |
||||
# --------------------------------------------------------------------------- |
||||
# The following section of the project makefile is managed by the BCB IDE. |
||||
# It is recommended to use the IDE to change any of the values in this |
||||
# section. |
||||
# --------------------------------------------------------------------------- |
||||
|
||||
VERSION = BCB.03 |
||||
# --------------------------------------------------------------------------- |
||||
PROJECT = d_zlib.lib |
||||
OBJFILES = d_zlib.obj adler32.obj deflate.obj infblock.obj infcodes.obj inffast.obj \ |
||||
inflate.obj inftrees.obj infutil.obj trees.obj |
||||
RESFILES = |
||||
RESDEPEN = $(RESFILES) |
||||
LIBFILES = |
||||
LIBRARIES = VCL35.lib |
||||
SPARELIBS = VCL35.lib |
||||
DEFFILE = |
||||
PACKAGES = VCLX35.bpi VCL35.bpi VCLDB35.bpi VCLDBX35.bpi ibsmp35.bpi bcbsmp35.bpi \ |
||||
dclocx35.bpi QRPT35.bpi TEEUI35.bpi TEEDB35.bpi TEE35.bpi DSS35.bpi \ |
||||
NMFAST35.bpi INETDB35.bpi INET35.bpi VCLMID35.bpi |
||||
# --------------------------------------------------------------------------- |
||||
PATHCPP = .; |
||||
PATHASM = .; |
||||
PATHPAS = .; |
||||
PATHRC = .; |
||||
DEBUGLIBPATH = $(BCB)\lib\debug |
||||
RELEASELIBPATH = $(BCB)\lib\release |
||||
# --------------------------------------------------------------------------- |
||||
CFLAG1 = -O2 -Ve -d -k- -vi |
||||
CFLAG2 = -I$(BCB)\include;$(BCB)\include\vcl -H=$(BCB)\lib\vcl35.csm |
||||
CFLAG3 = -ff -pr -5 |
||||
PFLAGS = -U;$(DEBUGLIBPATH) -I$(BCB)\include;$(BCB)\include\vcl -H -W -$I- -v -JPHN -M |
||||
RFLAGS = -i$(BCB)\include;$(BCB)\include\vcl |
||||
AFLAGS = /i$(BCB)\include /i$(BCB)\include\vcl /mx /w2 /zn |
||||
LFLAGS = |
||||
IFLAGS = -g -Gn |
||||
# --------------------------------------------------------------------------- |
||||
ALLOBJ = c0w32.obj $(OBJFILES) |
||||
ALLRES = $(RESFILES) |
||||
ALLLIB = $(LIBFILES) $(LIBRARIES) import32.lib cp32mt.lib |
||||
# --------------------------------------------------------------------------- |
||||
!!ifdef IDEOPTIONS |
||||
|
||||
[Version Info] |
||||
IncludeVerInfo=0 |
||||
AutoIncBuild=0 |
||||
MajorVer=1 |
||||
MinorVer=0 |
||||
Release=0 |
||||
Build=0 |
||||
Debug=0 |
||||
PreRelease=0 |
||||
Special=0 |
||||
Private=0 |
||||
DLL=0 |
||||
Locale=1040 |
||||
CodePage=1252 |
||||
|
||||
[Version Info Keys] |
||||
CompanyName= |
||||
FileDescription= |
||||
FileVersion=1.0.0.0 |
||||
InternalName= |
||||
LegalCopyright= |
||||
LegalTrademarks= |
||||
OriginalFilename= |
||||
ProductName= |
||||
ProductVersion=1.0.0.0 |
||||
Comments= |
||||
|
||||
[HistoryLists\hlIncludePath] |
||||
Count=2 |
||||
Item0=$(BCB)\include |
||||
Item1=$(BCB)\include;$(BCB)\include\vcl |
||||
|
||||
[HistoryLists\hlLibraryPath] |
||||
Count=1 |
||||
Item0=$(BCB)\lib\obj;$(BCB)\lib |
||||
|
||||
[HistoryLists\hlDebugSourcePath] |
||||
Count=1 |
||||
Item0=$(BCB)\source\vcl |
||||
|
||||
[Debugging] |
||||
DebugSourceDirs= |
||||
|
||||
[Parameters] |
||||
RunParams= |
||||
HostApplication= |
||||
|
||||
!endif |
||||
|
||||
--------------------------------------------------------------------------- |
||||
# MAKE SECTION |
||||
# --------------------------------------------------------------------------- |
||||
# This section of the project file is not used by the BCB IDE. It is for |
||||
# the benefit of building from the command-line using the MAKE utility. |
||||
# --------------------------------------------------------------------------- |
||||
|
||||
.autodepend |
||||
# --------------------------------------------------------------------------- |
||||
!if !$d(BCC32) |
||||
BCC32 = bcc32 |
||||
!endif |
||||
|
||||
!if !$d(DCC32) |
||||
DCC32 = dcc32 |
||||
!endif |
||||
|
||||
!if !$d(TASM32) |
||||
TASM32 = tasm32 |
||||
!endif |
||||
|
||||
!if !$d(LINKER) |
||||
LINKER = TLib |
||||
!endif |
||||
|
||||
!if !$d(BRCC32) |
||||
BRCC32 = brcc32 |
||||
!endif |
||||
# --------------------------------------------------------------------------- |
||||
!if $d(PATHCPP) |
||||
.PATH.CPP = $(PATHCPP) |
||||
.PATH.C = $(PATHCPP) |
||||
!endif |
||||
|
||||
!if $d(PATHPAS) |
||||
.PATH.PAS = $(PATHPAS) |
||||
!endif |
||||
|
||||
!if $d(PATHASM) |
||||
.PATH.ASM = $(PATHASM) |
||||
!endif |
||||
|
||||
!if $d(PATHRC) |
||||
.PATH.RC = $(PATHRC) |
||||
!endif |
||||
# --------------------------------------------------------------------------- |
||||
!ifdef IDEOPTIONS |
||||
|
||||
[Version Info] |
||||
IncludeVerInfo=0 |
||||
AutoIncBuild=0 |
||||
MajorVer=1 |
||||
MinorVer=0 |
||||
Release=0 |
||||
Build=0 |
||||
Debug=0 |
||||
PreRelease=0 |
||||
Special=0 |
||||
Private=0 |
||||
DLL=0 |
||||
Locale=1040 |
||||
CodePage=1252 |
||||
|
||||
[Version Info Keys] |
||||
CompanyName= |
||||
FileDescription= |
||||
FileVersion=1.0.0.0 |
||||
InternalName= |
||||
LegalCopyright= |
||||
LegalTrademarks= |
||||
OriginalFilename= |
||||
ProductName= |
||||
ProductVersion=1.0.0.0 |
||||
Comments= |
||||
|
||||
[HistoryLists\hlIncludePath] |
||||
Count=2 |
||||
Item0=$(BCB)\include;$(BCB)\include\vcl |
||||
Item1=$(BCB)\include |
||||
|
||||
[HistoryLists\hlLibraryPath] |
||||
Count=1 |
||||
Item0=$(BCB)\lib\obj;$(BCB)\lib |
||||
|
||||
[HistoryLists\hlDebugSourcePath] |
||||
Count=1 |
||||
Item0=$(BCB)\source\vcl |
||||
|
||||
[Debugging] |
||||
DebugSourceDirs= |
||||
|
||||
[Parameters] |
||||
RunParams= |
||||
HostApplication= |
||||
|
||||
!endif |
||||
|
||||
$(PROJECT): $(OBJFILES) $(RESDEPEN) $(DEFFILE) |
||||
$(BCB)\BIN\$(LINKER) @&&! |
||||
$(LFLAGS) $(IFLAGS) + |
||||
$(ALLOBJ), + |
||||
$(PROJECT),, + |
||||
$(ALLLIB), + |
||||
$(DEFFILE), + |
||||
$(ALLRES) |
||||
! |
||||
# --------------------------------------------------------------------------- |
||||
.pas.hpp: |
||||
$(BCB)\BIN\$(DCC32) $(PFLAGS) {$< } |
||||
|
||||
.pas.obj: |
||||
$(BCB)\BIN\$(DCC32) $(PFLAGS) {$< } |
||||
|
||||
.cpp.obj: |
||||
$(BCB)\BIN\$(BCC32) $(CFLAG1) $(CFLAG2) $(CFLAG3) -n$(@D) {$< } |
||||
|
||||
.c.obj: |
||||
$(BCB)\BIN\$(BCC32) $(CFLAG1) $(CFLAG2) $(CFLAG3) -n$(@D) {$< } |
||||
|
||||
.asm.obj: |
||||
$(BCB)\BIN\$(TASM32) $(AFLAGS) $<, $@ |
||||
|
||||
.rc.res: |
||||
$(BCB)\BIN\$(BRCC32) $(RFLAGS) -fo$@ $< |
||||
# --------------------------------------------------------------------------- |
||||
@ -1,17 +0,0 @@ |
||||
#include <condefs.h> |
||||
#pragma hdrstop |
||||
//---------------------------------------------------------------------------
|
||||
USEUNIT("adler32.c"); |
||||
USEUNIT("deflate.c"); |
||||
USEUNIT("infblock.c"); |
||||
USEUNIT("infcodes.c"); |
||||
USEUNIT("inffast.c"); |
||||
USEUNIT("inflate.c"); |
||||
USEUNIT("inftrees.c"); |
||||
USEUNIT("infutil.c"); |
||||
USEUNIT("trees.c"); |
||||
//---------------------------------------------------------------------------
|
||||
#define Library |
||||
|
||||
// To add a file to the library use the Project menu 'Add to Project'.
|
||||
|
||||
@ -1,17 +0,0 @@ |
||||
These are files used to compile zlib under Borland C++ Builder 3. |
||||
|
||||
zlib.bpg is the main project group that can be loaded in the BCB IDE and |
||||
loads all other *.bpr projects |
||||
|
||||
zlib.bpr is a project used to create a static zlib.lib library with C calling |
||||
convention for functions. |
||||
|
||||
zlib32.bpr creates a zlib32.dll dynamic link library with Windows standard |
||||
calling convention. |
||||
|
||||
d_zlib.bpr creates a set of .obj files with register calling convention. |
||||
These files are used by zlib.pas to create a Delphi unit containing zlib. |
||||
The d_zlib.lib file generated isn't useful and can be deleted. |
||||
|
||||
zlib.cpp, zlib32.cpp and d_zlib.cpp are used by the above projects. |
||||
|
||||
@ -1,26 +0,0 @@ |
||||
#------------------------------------------------------------------------------ |
||||
VERSION = BWS.01 |
||||
#------------------------------------------------------------------------------ |
||||
!ifndef ROOT |
||||
ROOT = $(MAKEDIR)\.. |
||||
!endif |
||||
#------------------------------------------------------------------------------ |
||||
MAKE = $(ROOT)\bin\make.exe -$(MAKEFLAGS) -f$** |
||||
DCC = $(ROOT)\bin\dcc32.exe $** |
||||
BRCC = $(ROOT)\bin\brcc32.exe $** |
||||
#------------------------------------------------------------------------------ |
||||
PROJECTS = zlib zlib32 d_zlib |
||||
#------------------------------------------------------------------------------ |
||||
default: $(PROJECTS) |
||||
#------------------------------------------------------------------------------ |
||||
|
||||
zlib: zlib.bpr |
||||
$(MAKE) |
||||
|
||||
zlib32: zlib32.bpr |
||||
$(MAKE) |
||||
|
||||
d_zlib: d_zlib.bpr |
||||
$(MAKE) |
||||
|
||||
|
||||
@ -1,225 +0,0 @@ |
||||
# --------------------------------------------------------------------------- |
||||
!if !$d(BCB) |
||||
BCB = $(MAKEDIR)\.. |
||||
!endif |
||||
|
||||
# --------------------------------------------------------------------------- |
||||
# IDE SECTION |
||||
# --------------------------------------------------------------------------- |
||||
# The following section of the project makefile is managed by the BCB IDE. |
||||
# It is recommended to use the IDE to change any of the values in this |
||||
# section. |
||||
# --------------------------------------------------------------------------- |
||||
|
||||
VERSION = BCB.03 |
||||
# --------------------------------------------------------------------------- |
||||
PROJECT = zlib.lib |
||||
OBJFILES = zlib.obj adler32.obj compress.obj crc32.obj deflate.obj gzio.obj infblock.obj \ |
||||
infcodes.obj inffast.obj inflate.obj inftrees.obj infutil.obj trees.obj \ |
||||
uncompr.obj zutil.obj |
||||
RESFILES = |
||||
RESDEPEN = $(RESFILES) |
||||
LIBFILES = |
||||
LIBRARIES = VCL35.lib |
||||
SPARELIBS = VCL35.lib |
||||
DEFFILE = |
||||
PACKAGES = VCLX35.bpi VCL35.bpi VCLDB35.bpi VCLDBX35.bpi ibsmp35.bpi bcbsmp35.bpi \ |
||||
dclocx35.bpi QRPT35.bpi TEEUI35.bpi TEEDB35.bpi TEE35.bpi DSS35.bpi \ |
||||
NMFAST35.bpi INETDB35.bpi INET35.bpi VCLMID35.bpi |
||||
# --------------------------------------------------------------------------- |
||||
PATHCPP = .; |
||||
PATHASM = .; |
||||
PATHPAS = .; |
||||
PATHRC = .; |
||||
DEBUGLIBPATH = $(BCB)\lib\debug |
||||
RELEASELIBPATH = $(BCB)\lib\release |
||||
# --------------------------------------------------------------------------- |
||||
CFLAG1 = -O2 -Ve -d -k- -vi |
||||
CFLAG2 = -I$(BCB)\include;$(BCB)\include\vcl -H=$(BCB)\lib\vcl35.csm |
||||
CFLAG3 = -ff -5 |
||||
PFLAGS = -U;$(DEBUGLIBPATH) -I$(BCB)\include;$(BCB)\include\vcl -H -W -$I- -v -JPHN -M |
||||
RFLAGS = -i$(BCB)\include;$(BCB)\include\vcl |
||||
AFLAGS = /i$(BCB)\include /i$(BCB)\include\vcl /mx /w2 /zn |
||||
LFLAGS = |
||||
IFLAGS = -g -Gn |
||||
# --------------------------------------------------------------------------- |
||||
ALLOBJ = c0w32.obj $(OBJFILES) |
||||
ALLRES = $(RESFILES) |
||||
ALLLIB = $(LIBFILES) $(LIBRARIES) import32.lib cp32mt.lib |
||||
# --------------------------------------------------------------------------- |
||||
!!ifdef IDEOPTIONS |
||||
|
||||
[Version Info] |
||||
IncludeVerInfo=0 |
||||
AutoIncBuild=0 |
||||
MajorVer=1 |
||||
MinorVer=0 |
||||
Release=0 |
||||
Build=0 |
||||
Debug=0 |
||||
PreRelease=0 |
||||
Special=0 |
||||
Private=0 |
||||
DLL=0 |
||||
Locale=1040 |
||||
CodePage=1252 |
||||
|
||||
[Version Info Keys] |
||||
CompanyName= |
||||
FileDescription= |
||||
FileVersion=1.0.0.0 |
||||
InternalName= |
||||
LegalCopyright= |
||||
LegalTrademarks= |
||||
OriginalFilename= |
||||
ProductName= |
||||
ProductVersion=1.0.0.0 |
||||
Comments= |
||||
|
||||
[HistoryLists\hlIncludePath] |
||||
Count=2 |
||||
Item0=$(BCB)\include |
||||
Item1=$(BCB)\include;$(BCB)\include\vcl |
||||
|
||||
[HistoryLists\hlLibraryPath] |
||||
Count=1 |
||||
Item0=$(BCB)\lib\obj;$(BCB)\lib |
||||
|
||||
[HistoryLists\hlDebugSourcePath] |
||||
Count=1 |
||||
Item0=$(BCB)\source\vcl |
||||
|
||||
[Debugging] |
||||
DebugSourceDirs= |
||||
|
||||
[Parameters] |
||||
RunParams= |
||||
HostApplication= |
||||
|
||||
!endif |
||||
|
||||
--------------------------------------------------------------------------- |
||||
# MAKE SECTION |
||||
# --------------------------------------------------------------------------- |
||||
# This section of the project file is not used by the BCB IDE. It is for |
||||
# the benefit of building from the command-line using the MAKE utility. |
||||
# --------------------------------------------------------------------------- |
||||
|
||||
.autodepend |
||||
# --------------------------------------------------------------------------- |
||||
!if !$d(BCC32) |
||||
BCC32 = bcc32 |
||||
!endif |
||||
|
||||
!if !$d(DCC32) |
||||
DCC32 = dcc32 |
||||
!endif |
||||
|
||||
!if !$d(TASM32) |
||||
TASM32 = tasm32 |
||||
!endif |
||||
|
||||
!if !$d(LINKER) |
||||
LINKER = TLib |
||||
!endif |
||||
|
||||
!if !$d(BRCC32) |
||||
BRCC32 = brcc32 |
||||
!endif |
||||
# --------------------------------------------------------------------------- |
||||
!if $d(PATHCPP) |
||||
.PATH.CPP = $(PATHCPP) |
||||
.PATH.C = $(PATHCPP) |
||||
!endif |
||||
|
||||
!if $d(PATHPAS) |
||||
.PATH.PAS = $(PATHPAS) |
||||
!endif |
||||
|
||||
!if $d(PATHASM) |
||||
.PATH.ASM = $(PATHASM) |
||||
!endif |
||||
|
||||
!if $d(PATHRC) |
||||
.PATH.RC = $(PATHRC) |
||||
!endif |
||||
# --------------------------------------------------------------------------- |
||||
!ifdef IDEOPTIONS |
||||
|
||||
[Version Info] |
||||
IncludeVerInfo=0 |
||||
AutoIncBuild=0 |
||||
MajorVer=1 |
||||
MinorVer=0 |
||||
Release=0 |
||||
Build=0 |
||||
Debug=0 |
||||
PreRelease=0 |
||||
Special=0 |
||||
Private=0 |
||||
DLL=0 |
||||
Locale=1040 |
||||
CodePage=1252 |
||||
|
||||
[Version Info Keys] |
||||
CompanyName= |
||||
FileDescription= |
||||
FileVersion=1.0.0.0 |
||||
InternalName= |
||||
LegalCopyright= |
||||
LegalTrademarks= |
||||
OriginalFilename= |
||||
ProductName= |
||||
ProductVersion=1.0.0.0 |
||||
Comments= |
||||
|
||||
[HistoryLists\hlIncludePath] |
||||
Count=2 |
||||
Item0=$(BCB)\include;$(BCB)\include\vcl |
||||
Item1=$(BCB)\include |
||||
|
||||
[HistoryLists\hlLibraryPath] |
||||
Count=1 |
||||
Item0=$(BCB)\lib\obj;$(BCB)\lib |
||||
|
||||
[HistoryLists\hlDebugSourcePath] |
||||
Count=1 |
||||
Item0=$(BCB)\source\vcl |
||||
|
||||
[Debugging] |
||||
DebugSourceDirs= |
||||
|
||||
[Parameters] |
||||
RunParams= |
||||
HostApplication= |
||||
|
||||
!endif |
||||
|
||||
$(PROJECT): $(OBJFILES) $(RESDEPEN) $(DEFFILE) |
||||
$(BCB)\BIN\$(LINKER) @&&! |
||||
$(LFLAGS) $(IFLAGS) + |
||||
$(ALLOBJ), + |
||||
$(PROJECT),, + |
||||
$(ALLLIB), + |
||||
$(DEFFILE), + |
||||
$(ALLRES) |
||||
! |
||||
# --------------------------------------------------------------------------- |
||||
.pas.hpp: |
||||
$(BCB)\BIN\$(DCC32) $(PFLAGS) {$< } |
||||
|
||||
.pas.obj: |
||||
$(BCB)\BIN\$(DCC32) $(PFLAGS) {$< } |
||||
|
||||
.cpp.obj: |
||||
$(BCB)\BIN\$(BCC32) $(CFLAG1) $(CFLAG2) $(CFLAG3) -n$(@D) {$< } |
||||
|
||||
.c.obj: |
||||
$(BCB)\BIN\$(BCC32) $(CFLAG1) $(CFLAG2) $(CFLAG3) -n$(@D) {$< } |
||||
|
||||
.asm.obj: |
||||
$(BCB)\BIN\$(TASM32) $(AFLAGS) $<, $@ |
||||
|
||||
.rc.res: |
||||
$(BCB)\BIN\$(BRCC32) $(RFLAGS) -fo$@ $< |
||||
# --------------------------------------------------------------------------- |
||||
@ -1,22 +0,0 @@ |
||||
#include <condefs.h> |
||||
#pragma hdrstop |
||||
//---------------------------------------------------------------------------
|
||||
USEUNIT("adler32.c"); |
||||
USEUNIT("compress.c"); |
||||
USEUNIT("crc32.c"); |
||||
USEUNIT("deflate.c"); |
||||
USEUNIT("gzio.c"); |
||||
USEUNIT("infblock.c"); |
||||
USEUNIT("infcodes.c"); |
||||
USEUNIT("inffast.c"); |
||||
USEUNIT("inflate.c"); |
||||
USEUNIT("inftrees.c"); |
||||
USEUNIT("infutil.c"); |
||||
USEUNIT("trees.c"); |
||||
USEUNIT("uncompr.c"); |
||||
USEUNIT("zutil.c"); |
||||
//---------------------------------------------------------------------------
|
||||
#define Library |
||||
|
||||
// To add a file to the library use the Project menu 'Add to Project'.
|
||||
|
||||
@ -1,174 +0,0 @@ |
||||
# --------------------------------------------------------------------------- |
||||
!if !$d(BCB) |
||||
BCB = $(MAKEDIR)\.. |
||||
!endif |
||||
|
||||
# --------------------------------------------------------------------------- |
||||
# IDE SECTION |
||||
# --------------------------------------------------------------------------- |
||||
# The following section of the project makefile is managed by the BCB IDE. |
||||
# It is recommended to use the IDE to change any of the values in this |
||||
# section. |
||||
# --------------------------------------------------------------------------- |
||||
|
||||
VERSION = BCB.03 |
||||
# --------------------------------------------------------------------------- |
||||
PROJECT = zlib32.dll |
||||
OBJFILES = zlib32.obj adler32.obj compress.obj crc32.obj deflate.obj gzio.obj infblock.obj \ |
||||
infcodes.obj inffast.obj inflate.obj inftrees.obj infutil.obj trees.obj \ |
||||
uncompr.obj zutil.obj |
||||
RESFILES = |
||||
RESDEPEN = $(RESFILES) |
||||
LIBFILES = |
||||
LIBRARIES = |
||||
SPARELIBS = |
||||
DEFFILE = |
||||
PACKAGES = VCLX35.bpi VCL35.bpi VCLDB35.bpi VCLDBX35.bpi ibsmp35.bpi bcbsmp35.bpi \ |
||||
dclocx35.bpi QRPT35.bpi TEEUI35.bpi TEEDB35.bpi TEE35.bpi DSS35.bpi \ |
||||
NMFAST35.bpi INETDB35.bpi INET35.bpi VCLMID35.bpi |
||||
# --------------------------------------------------------------------------- |
||||
PATHCPP = .; |
||||
PATHASM = .; |
||||
PATHPAS = .; |
||||
PATHRC = .; |
||||
DEBUGLIBPATH = $(BCB)\lib\debug |
||||
RELEASELIBPATH = $(BCB)\lib\release |
||||
# --------------------------------------------------------------------------- |
||||
CFLAG1 = -WD -O2 -Ve -d -k- -vi -c -tWD |
||||
CFLAG2 = -D_NO_VCL;ZLIB_DLL -I$(BCB)\include |
||||
CFLAG3 = -ff -5 |
||||
PFLAGS = -D_NO_VCL;ZLIB_DLL -U$(BCB)\lib;$(RELEASELIBPATH) -I$(BCB)\include -$I- -v \ |
||||
-JPHN -M |
||||
RFLAGS = -D_NO_VCL;ZLIB_DLL -i$(BCB)\include |
||||
AFLAGS = /i$(BCB)\include /d_NO_VCL /dZLIB_DLL /mx /w2 /zn |
||||
LFLAGS = -L$(BCB)\lib;$(RELEASELIBPATH) -aa -Tpd -x -Gi |
||||
IFLAGS = -Gn -g |
||||
# --------------------------------------------------------------------------- |
||||
ALLOBJ = c0d32.obj $(OBJFILES) |
||||
ALLRES = $(RESFILES) |
||||
ALLLIB = $(LIBFILES) import32.lib cw32mt.lib |
||||
# --------------------------------------------------------------------------- |
||||
!ifdef IDEOPTIONS |
||||
|
||||
[Version Info] |
||||
IncludeVerInfo=0 |
||||
AutoIncBuild=0 |
||||
MajorVer=1 |
||||
MinorVer=0 |
||||
Release=0 |
||||
Build=0 |
||||
Debug=0 |
||||
PreRelease=0 |
||||
Special=0 |
||||
Private=0 |
||||
DLL=1 |
||||
Locale=1040 |
||||
CodePage=1252 |
||||
|
||||
[Version Info Keys] |
||||
CompanyName= |
||||
FileDescription=DLL (GUI) |
||||
FileVersion=1.0.0.0 |
||||
InternalName= |
||||
LegalCopyright= |
||||
LegalTrademarks= |
||||
OriginalFilename= |
||||
ProductName= |
||||
ProductVersion=1.0.0.0 |
||||
Comments= |
||||
|
||||
[HistoryLists\hlIncludePath] |
||||
Count=1 |
||||
Item0=$(BCB)\include |
||||
|
||||
[HistoryLists\hlLibraryPath] |
||||
Count=1 |
||||
Item0=$(BCB)\lib |
||||
|
||||
[HistoryLists\hlConditionals] |
||||
Count=1 |
||||
Item0=_NO_VCL;ZLIB_DLL |
||||
|
||||
[Debugging] |
||||
DebugSourceDirs= |
||||
|
||||
[Parameters] |
||||
RunParams= |
||||
HostApplication= |
||||
|
||||
!endif |
||||
|
||||
# --------------------------------------------------------------------------- |
||||
# MAKE SECTION |
||||
# --------------------------------------------------------------------------- |
||||
# This section of the project file is not used by the BCB IDE. It is for |
||||
# the benefit of building from the command-line using the MAKE utility. |
||||
# --------------------------------------------------------------------------- |
||||
|
||||
.autodepend |
||||
# --------------------------------------------------------------------------- |
||||
!if !$d(BCC32) |
||||
BCC32 = bcc32 |
||||
!endif |
||||
|
||||
!if !$d(DCC32) |
||||
DCC32 = dcc32 |
||||
!endif |
||||
|
||||
!if !$d(TASM32) |
||||
TASM32 = tasm32 |
||||
!endif |
||||
|
||||
!if !$d(LINKER) |
||||
LINKER = ilink32 |
||||
!endif |
||||
|
||||
!if !$d(BRCC32) |
||||
BRCC32 = brcc32 |
||||
!endif |
||||
# --------------------------------------------------------------------------- |
||||
!if $d(PATHCPP) |
||||
.PATH.CPP = $(PATHCPP) |
||||
.PATH.C = $(PATHCPP) |
||||
!endif |
||||
|
||||
!if $d(PATHPAS) |
||||
.PATH.PAS = $(PATHPAS) |
||||
!endif |
||||
|
||||
!if $d(PATHASM) |
||||
.PATH.ASM = $(PATHASM) |
||||
!endif |
||||
|
||||
!if $d(PATHRC) |
||||
.PATH.RC = $(PATHRC) |
||||
!endif |
||||
# --------------------------------------------------------------------------- |
||||
$(PROJECT): $(OBJFILES) $(RESDEPEN) $(DEFFILE) |
||||
$(BCB)\BIN\$(LINKER) @&&! |
||||
$(LFLAGS) $(IFLAGS) + |
||||
$(ALLOBJ), + |
||||
$(PROJECT),, + |
||||
$(ALLLIB), + |
||||
$(DEFFILE), + |
||||
$(ALLRES) |
||||
! |
||||
# --------------------------------------------------------------------------- |
||||
.pas.hpp: |
||||
$(BCB)\BIN\$(DCC32) $(PFLAGS) {$< } |
||||
|
||||
.pas.obj: |
||||
$(BCB)\BIN\$(DCC32) $(PFLAGS) {$< } |
||||
|
||||
.cpp.obj: |
||||
$(BCB)\BIN\$(BCC32) $(CFLAG1) $(CFLAG2) $(CFLAG3) -n$(@D) {$< } |
||||
|
||||
.c.obj: |
||||
$(BCB)\BIN\$(BCC32) $(CFLAG1) $(CFLAG2) $(CFLAG3) -n$(@D) {$< } |
||||
|
||||
.asm.obj: |
||||
$(BCB)\BIN\$(TASM32) $(AFLAGS) $<, $@ |
||||
|
||||
.rc.res: |
||||
$(BCB)\BIN\$(BRCC32) $(RFLAGS) -fo$@ $< |
||||
# --------------------------------------------------------------------------- |
||||
@ -1,42 +0,0 @@ |
||||
|
||||
#include <windows.h> |
||||
#pragma hdrstop |
||||
#include <condefs.h> |
||||
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
// Important note about DLL memory management in a VCL DLL:
|
||||
//
|
||||
//
|
||||
//
|
||||
// If your DLL uses VCL and exports any functions that pass VCL String objects
|
||||
// (or structs/classes containing nested Strings) as parameter or function
|
||||
// results, you will need to build both your DLL project and any EXE projects
|
||||
// that use your DLL with the dynamic RTL (the RTL DLL). This will change your
|
||||
// DLL and its calling EXE's to use BORLNDMM.DLL as their memory manager. In
|
||||
// these cases, the file BORLNDMM.DLL should be deployed along with your DLL
|
||||
// and the RTL DLL (CP3240MT.DLL). To avoid the requiring BORLNDMM.DLL in
|
||||
// these situations, pass string information using "char *" or ShortString
|
||||
// parameters and then link with the static RTL.
|
||||
//
|
||||
//---------------------------------------------------------------------------
|
||||
USEUNIT("adler32.c"); |
||||
USEUNIT("compress.c"); |
||||
USEUNIT("crc32.c"); |
||||
USEUNIT("deflate.c"); |
||||
USEUNIT("gzio.c"); |
||||
USEUNIT("infblock.c"); |
||||
USEUNIT("infcodes.c"); |
||||
USEUNIT("inffast.c"); |
||||
USEUNIT("inflate.c"); |
||||
USEUNIT("inftrees.c"); |
||||
USEUNIT("infutil.c"); |
||||
USEUNIT("trees.c"); |
||||
USEUNIT("uncompr.c"); |
||||
USEUNIT("zutil.c"); |
||||
//---------------------------------------------------------------------------
|
||||
#pragma argsused |
||||
int WINAPI DllEntryPoint(HINSTANCE hinst, unsigned long reason, void*) |
||||
{ |
||||
return 1; |
||||
} |
||||
@ -0,0 +1 @@ |
||||
See infback9.h for what this is and how to use it. |
||||
@ -0,0 +1,427 @@ |
||||
*** infback.c Mon Aug 11 16:48:06 2003
|
||||
--- infback9.c Mon Sep 8 21:22:46 2003
|
||||
***************
|
||||
*** 1,19 ****
|
||||
! /* infback.c -- inflate using a call-back interface
|
||||
* Copyright (C) 1995-2003 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
- /*
|
||||
- This code is largely copied from inflate.c. Normally either infback.o or
|
||||
- inflate.o would be linked into an application--not both. The interface
|
||||
- with inffast.c is retained so that optimized assembler-coded versions of
|
||||
- inflate_fast() can be used with either inflate.c or infback.c.
|
||||
- */
|
||||
-
|
||||
#include "zutil.h"
|
||||
! #include "inftrees.h"
|
||||
#include "inflate.h"
|
||||
- #include "inffast.h"
|
||||
|
||||
/* function prototypes */
|
||||
local void fixedtables OF((struct inflate_state FAR *state));
|
||||
--- 1,12 ----
|
||||
! /* infback9.c -- inflate deflate64 data using a call-back interface
|
||||
* Copyright (C) 1995-2003 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
#include "zutil.h"
|
||||
! #include "infback9.h"
|
||||
! #include "inftree9.h"
|
||||
#include "inflate.h"
|
||||
|
||||
/* function prototypes */
|
||||
local void fixedtables OF((struct inflate_state FAR *state));
|
||||
***************
|
||||
*** 22,33 ****
|
||||
strm provides memory allocation functions in zalloc and zfree, or
|
||||
Z_NULL to use the library memory allocation functions.
|
||||
|
||||
! windowBits is in the range 8..15, and window is a user-supplied
|
||||
! window and output buffer that is 2**windowBits bytes.
|
||||
*/
|
||||
! int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size)
|
||||
z_stream FAR *strm;
|
||||
- int windowBits;
|
||||
unsigned char FAR *window;
|
||||
const char *version;
|
||||
int stream_size;
|
||||
--- 15,24 ----
|
||||
strm provides memory allocation functions in zalloc and zfree, or
|
||||
Z_NULL to use the library memory allocation functions.
|
||||
|
||||
! window is a user-supplied window and output buffer that is 64K bytes.
|
||||
*/
|
||||
! int ZEXPORT inflateBack9Init_(strm, window, version, stream_size)
|
||||
z_stream FAR *strm;
|
||||
unsigned char FAR *window;
|
||||
const char *version;
|
||||
int stream_size;
|
||||
***************
|
||||
*** 37,44 ****
|
||||
if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
|
||||
stream_size != (int)(sizeof(z_stream)))
|
||||
return Z_VERSION_ERROR;
|
||||
! if (strm == Z_NULL || window == Z_NULL ||
|
||||
! windowBits < 8 || windowBits > 15)
|
||||
return Z_STREAM_ERROR;
|
||||
strm->msg = Z_NULL; /* in case we return an error */
|
||||
if (strm->zalloc == (alloc_func)0) {
|
||||
--- 28,34 ----
|
||||
if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
|
||||
stream_size != (int)(sizeof(z_stream)))
|
||||
return Z_VERSION_ERROR;
|
||||
! if (strm == Z_NULL || window == Z_NULL)
|
||||
return Z_STREAM_ERROR;
|
||||
strm->msg = Z_NULL; /* in case we return an error */
|
||||
if (strm->zalloc == (alloc_func)0) {
|
||||
***************
|
||||
*** 51,58 ****
|
||||
if (state == Z_NULL) return Z_MEM_ERROR;
|
||||
Tracev((stderr, "inflate: allocated\n"));
|
||||
strm->state = (voidpf)state;
|
||||
! state->wbits = windowBits;
|
||||
! state->wsize = 1U << windowBits;
|
||||
state->window = window;
|
||||
state->write = 0;
|
||||
state->whave = 0;
|
||||
--- 41,48 ----
|
||||
if (state == Z_NULL) return Z_MEM_ERROR;
|
||||
Tracev((stderr, "inflate: allocated\n"));
|
||||
strm->state = (voidpf)state;
|
||||
! state->wbits = 16;
|
||||
! state->wsize = 1U << 16;
|
||||
state->window = window;
|
||||
state->write = 0;
|
||||
state->whave = 0;
|
||||
***************
|
||||
*** 91,110 ****
|
||||
next = fixed;
|
||||
lenfix = next;
|
||||
bits = 9;
|
||||
! inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
|
||||
|
||||
/* distance table */
|
||||
sym = 0;
|
||||
while (sym < 32) state->lens[sym++] = 5;
|
||||
distfix = next;
|
||||
bits = 5;
|
||||
! inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
|
||||
|
||||
/* do this just once */
|
||||
virgin = 0;
|
||||
}
|
||||
#else /* !BUILDFIXED */
|
||||
! # include "inffixed.h"
|
||||
#endif /* BUILDFIXED */
|
||||
state->lencode = lenfix;
|
||||
state->lenbits = 9;
|
||||
--- 81,100 ----
|
||||
next = fixed;
|
||||
lenfix = next;
|
||||
bits = 9;
|
||||
! inflate_table9(LENS, state->lens, 288, &(next), &(bits), state->work);
|
||||
|
||||
/* distance table */
|
||||
sym = 0;
|
||||
while (sym < 32) state->lens[sym++] = 5;
|
||||
distfix = next;
|
||||
bits = 5;
|
||||
! inflate_table9(DISTS, state->lens, 32, &(next), &(bits), state->work);
|
||||
|
||||
/* do this just once */
|
||||
virgin = 0;
|
||||
}
|
||||
#else /* !BUILDFIXED */
|
||||
! # include "inffix9.h"
|
||||
#endif /* BUILDFIXED */
|
||||
state->lencode = lenfix;
|
||||
state->lenbits = 9;
|
||||
***************
|
||||
*** 114,141 ****
|
||||
|
||||
/* Macros for inflateBack(): */
|
||||
|
||||
- /* Load returned state from inflate_fast() */
|
||||
- #define LOAD() \
|
||||
- do { \
|
||||
- put = strm->next_out; \
|
||||
- left = strm->avail_out; \
|
||||
- next = strm->next_in; \
|
||||
- have = strm->avail_in; \
|
||||
- hold = state->hold; \
|
||||
- bits = state->bits; \
|
||||
- } while (0)
|
||||
-
|
||||
- /* Set state from registers for inflate_fast() */
|
||||
- #define RESTORE() \
|
||||
- do { \
|
||||
- strm->next_out = put; \
|
||||
- strm->avail_out = left; \
|
||||
- strm->next_in = next; \
|
||||
- strm->avail_in = have; \
|
||||
- state->hold = hold; \
|
||||
- state->bits = bits; \
|
||||
- } while (0)
|
||||
-
|
||||
/* Clear the input bit accumulator */
|
||||
#define INITBITS() \
|
||||
do { \
|
||||
--- 104,109 ----
|
||||
***************
|
||||
*** 237,243 ****
|
||||
inflateBack() can also return Z_STREAM_ERROR if the input parameters
|
||||
are not correct, i.e. strm is Z_NULL or the state was not initialized.
|
||||
*/
|
||||
! int ZEXPORT inflateBack(strm, in, in_desc, out, out_desc)
|
||||
z_stream FAR *strm;
|
||||
in_func in;
|
||||
void FAR *in_desc;
|
||||
--- 205,211 ----
|
||||
inflateBack() can also return Z_STREAM_ERROR if the input parameters
|
||||
are not correct, i.e. strm is Z_NULL or the state was not initialized.
|
||||
*/
|
||||
! int ZEXPORT inflateBack9(strm, in, in_desc, out, out_desc)
|
||||
z_stream FAR *strm;
|
||||
in_func in;
|
||||
void FAR *in_desc;
|
||||
***************
|
||||
*** 354,366 ****
|
||||
DROPBITS(5);
|
||||
state->ncode = BITS(4) + 4;
|
||||
DROPBITS(4);
|
||||
! #ifndef PKZIP_BUG_WORKAROUND
|
||||
! if (state->nlen > 286 || state->ndist > 30) {
|
||||
! strm->msg = (char *)"too many length or distance symbols";
|
||||
state->mode = BAD;
|
||||
break;
|
||||
}
|
||||
- #endif
|
||||
Tracev((stderr, "inflate: table sizes ok\n"));
|
||||
|
||||
/* get code length code lengths (not a typo) */
|
||||
--- 322,332 ----
|
||||
DROPBITS(5);
|
||||
state->ncode = BITS(4) + 4;
|
||||
DROPBITS(4);
|
||||
! if (state->nlen > 286) {
|
||||
! strm->msg = (char *)"too many length symbols";
|
||||
state->mode = BAD;
|
||||
break;
|
||||
}
|
||||
Tracev((stderr, "inflate: table sizes ok\n"));
|
||||
|
||||
/* get code length code lengths (not a typo) */
|
||||
***************
|
||||
*** 375,381 ****
|
||||
state->next = state->codes;
|
||||
state->lencode = (code const FAR *)(state->next);
|
||||
state->lenbits = 7;
|
||||
! ret = inflate_table(CODES, state->lens, 19, &(state->next),
|
||||
&(state->lenbits), state->work);
|
||||
if (ret) {
|
||||
strm->msg = (char *)"invalid code lengths set";
|
||||
--- 341,347 ----
|
||||
state->next = state->codes;
|
||||
state->lencode = (code const FAR *)(state->next);
|
||||
state->lenbits = 7;
|
||||
! ret = inflate_table9(CODES, state->lens, 19, &(state->next),
|
||||
&(state->lenbits), state->work);
|
||||
if (ret) {
|
||||
strm->msg = (char *)"invalid code lengths set";
|
||||
***************
|
||||
*** 438,445 ****
|
||||
state->next = state->codes;
|
||||
state->lencode = (code const FAR *)(state->next);
|
||||
state->lenbits = 9;
|
||||
! ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
|
||||
! &(state->lenbits), state->work);
|
||||
if (ret) {
|
||||
strm->msg = (char *)"invalid literal/lengths set";
|
||||
state->mode = BAD;
|
||||
--- 404,411 ----
|
||||
state->next = state->codes;
|
||||
state->lencode = (code const FAR *)(state->next);
|
||||
state->lenbits = 9;
|
||||
! ret = inflate_table9(LENS, state->lens, state->nlen,
|
||||
! &(state->next), &(state->lenbits), state->work);
|
||||
if (ret) {
|
||||
strm->msg = (char *)"invalid literal/lengths set";
|
||||
state->mode = BAD;
|
||||
***************
|
||||
*** 447,454 ****
|
||||
}
|
||||
state->distcode = (code const FAR *)(state->next);
|
||||
state->distbits = 6;
|
||||
! ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
|
||||
! &(state->next), &(state->distbits), state->work);
|
||||
if (ret) {
|
||||
strm->msg = (char *)"invalid distances set";
|
||||
state->mode = BAD;
|
||||
--- 413,421 ----
|
||||
}
|
||||
state->distcode = (code const FAR *)(state->next);
|
||||
state->distbits = 6;
|
||||
! ret = inflate_table9(DISTS, state->lens + state->nlen,
|
||||
! state->ndist, &(state->next), &(state->distbits),
|
||||
! state->work);
|
||||
if (ret) {
|
||||
strm->msg = (char *)"invalid distances set";
|
||||
state->mode = BAD;
|
||||
***************
|
||||
*** 458,473 ****
|
||||
state->mode = LEN;
|
||||
|
||||
case LEN:
|
||||
- /* use inflate_fast() if we have enough input and output */
|
||||
- if (have >= 6 && left >= 258) {
|
||||
- RESTORE();
|
||||
- if (state->whave < state->wsize)
|
||||
- state->whave = state->wsize - left;
|
||||
- inflate_fast(strm, state->wsize);
|
||||
- LOAD();
|
||||
- break;
|
||||
- }
|
||||
-
|
||||
/* get a literal, length, or end-of-block code */
|
||||
for (;;) {
|
||||
this = state->lencode[BITS(state->lenbits)];
|
||||
--- 425,430 ----
|
||||
***************
|
||||
*** 607,613 ****
|
||||
return ret;
|
||||
}
|
||||
|
||||
! int ZEXPORT inflateBackEnd(strm)
|
||||
z_stream FAR *strm;
|
||||
{
|
||||
if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
|
||||
--- 564,570 ----
|
||||
return ret;
|
||||
}
|
||||
|
||||
! int ZEXPORT inflateBack9End(strm)
|
||||
z_stream FAR *strm;
|
||||
{
|
||||
if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
|
||||
*** inftrees.c Sun Sep 7 10:59:10 2003
|
||||
--- inftree9.c Mon Sep 8 20:54:36 2003
|
||||
***************
|
||||
*** 1,15 ****
|
||||
! /* inftrees.c -- generate Huffman trees for efficient decoding
|
||||
* Copyright (C) 1995-2003 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
#include "zutil.h"
|
||||
! #include "inftrees.h"
|
||||
|
||||
#define MAXBITS 15
|
||||
|
||||
! const char inflate_copyright[] =
|
||||
! " inflate 1.2.0.5 Copyright 1995-2003 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
|
||||
--- 1,15 ----
|
||||
! /* inftree9.c -- generate Huffman trees for efficient decoding
|
||||
* Copyright (C) 1995-2003 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
#include "zutil.h"
|
||||
! #include "inftree9.h"
|
||||
|
||||
#define MAXBITS 15
|
||||
|
||||
! const char inflate9_copyright[] =
|
||||
! " inflate9 1.2.0.5 Copyright 1995-2003 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
|
||||
***************
|
||||
*** 29,35 ****
|
||||
table index bits. It will differ if the request is greater than the
|
||||
longest code or if it is less than the shortest code.
|
||||
*/
|
||||
! int inflate_table(type, lens, codes, table, bits, work)
|
||||
codetype type;
|
||||
unsigned short FAR *lens;
|
||||
unsigned codes;
|
||||
--- 29,35 ----
|
||||
table index bits. It will differ if the request is greater than the
|
||||
longest code or if it is less than the shortest code.
|
||||
*/
|
||||
! int inflate_table9(type, lens, codes, table, bits, work)
|
||||
codetype type;
|
||||
unsigned short FAR *lens;
|
||||
unsigned codes;
|
||||
***************
|
||||
*** 59,76 ****
|
||||
unsigned short offs[MAXBITS+1]; /* offsets in table for each length */
|
||||
static const unsigned short lbase[31] = { /* Length codes 257..285 base */
|
||||
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};
|
||||
static const unsigned short lext[31] = { /* Length codes 257..285 extra */
|
||||
16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
|
||||
! 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 192, 78};
|
||||
! static const unsigned short dbase[32] = { /* Distance codes 0..29 base */
|
||||
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, 0, 0};
|
||||
! static const unsigned short dext[32] = { /* Distance codes 0..29 extra */
|
||||
16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
|
||||
23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
|
||||
! 28, 28, 29, 29, 64, 64};
|
||||
|
||||
/*
|
||||
Process a set of code lengths to create a canonical Huffman code. The
|
||||
--- 59,76 ----
|
||||
unsigned short offs[MAXBITS+1]; /* offsets in table for each length */
|
||||
static const unsigned short lbase[31] = { /* Length codes 257..285 base */
|
||||
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, 3, 0, 0};
|
||||
static const unsigned short lext[31] = { /* Length codes 257..285 extra */
|
||||
16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
|
||||
! 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 32, 192, 78};
|
||||
! static const unsigned short dbase[32] = { /* Distance codes 0..31 base */
|
||||
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, 32769, 49153};
|
||||
! static const unsigned short dext[32] = { /* Distance codes 0..31 extra */
|
||||
16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
|
||||
23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
|
||||
! 28, 28, 29, 29, 30, 30};
|
||||
|
||||
/*
|
||||
Process a set of code lengths to create a canonical Huffman code. The
|
||||
*** inftrees.h Sun Aug 10 15:15:50 2003
|
||||
--- inftree9.h Mon Sep 8 20:54:51 2003
|
||||
***************
|
||||
*** 1,4 ****
|
||||
! /* inftrees.h -- header to use inftrees.c
|
||||
* Copyright (C) 1995-2003 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
--- 1,4 ----
|
||||
! /* inftree9.h -- header to use inftree9.c
|
||||
* Copyright (C) 1995-2003 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
***************
|
||||
*** 50,55 ****
|
||||
DISTS
|
||||
} codetype;
|
||||
|
||||
! extern int inflate_table OF((codetype type, unsigned short FAR *lens,
|
||||
unsigned codes, code FAR * FAR *table,
|
||||
unsigned FAR *bits, unsigned short FAR *work));
|
||||
--- 50,55 ----
|
||||
DISTS
|
||||
} codetype;
|
||||
|
||||
! extern int inflate_table9 OF((codetype type, unsigned short FAR *lens,
|
||||
unsigned codes, code FAR * FAR *table,
|
||||
unsigned FAR *bits, unsigned short FAR *work));
|
||||
@ -0,0 +1,26 @@ |
||||
/* infback9.h -- header for using inflateBack9 functions
|
||||
* Copyright (C) 2003 Mark Adler |
||||
* For conditions of distribution and use, see copyright notice in zlib.h |
||||
*/ |
||||
|
||||
/*
|
||||
* This header file and associated patches provide a decoder for PKWare's |
||||
* undocumented deflate64 compression method (method 9). Use with infback9.c, |
||||
* inftree9.h, inftree9.c, and inffix9.h. These patches are not supported. |
||||
* This code will almost certainly not work on 16-bit architectures. See the |
||||
* comments in zlib.h for inflateBack() usage. These functions are used |
||||
* identically, except that there is no windowBits parameter, and a 64K |
||||
* window must be provided. zlib.h must be included before this header file. |
||||
*/ |
||||
|
||||
ZEXTERN int ZEXPORT inflateBack9 OF((z_stream FAR *strm, |
||||
in_func in, void FAR *in_desc, |
||||
out_func out, void FAR *out_desc)); |
||||
ZEXTERN int ZEXPORT inflateBack9End OF((z_stream FAR *strm)); |
||||
ZEXTERN int ZEXPORT inflateBack9Init_ OF((z_stream FAR *strm, |
||||
unsigned char FAR *window, |
||||
const char *version, |
||||
int stream_size)); |
||||
#define inflateBack9Init(strm, window) \ |
||||
inflateBack9Init_((strm), (window), \
|
||||
ZLIB_VERSION, sizeof(z_stream)) |
||||
@ -0,0 +1,94 @@ |
||||
/* inffix9.h -- table for decoding fixed codes
|
||||
* Generated automatically by makefixed(). |
||||
*/ |
||||
|
||||
/* WARNING: this file should *not* be used by applications.
|
||||
It is part of the implementation of this library and is |
||||
subject to change. Applications should only use zlib.h. |
||||
*/ |
||||
|
||||
static const code lenfix[512] = { |
||||
{96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48}, |
||||
{0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128}, |
||||
{0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59}, |
||||
{0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176}, |
||||
{0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20}, |
||||
{21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100}, |
||||
{0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8}, |
||||
{0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216}, |
||||
{18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76}, |
||||
{0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114}, |
||||
{0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2}, |
||||
{0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148}, |
||||
{20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42}, |
||||
{0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86}, |
||||
{0,8,22},{192,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15}, |
||||
{0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236}, |
||||
{16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62}, |
||||
{0,9,220},{18,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,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31}, |
||||
{0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162}, |
||||
{0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25}, |
||||
{0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105}, |
||||
{0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4}, |
||||
{0,8,85},{0,8,21},{32,8,3},{19,7,43},{0,8,117},{0,8,53},{0,9,202}, |
||||
{17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69}, |
||||
{0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125}, |
||||
{0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13}, |
||||
{0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195}, |
||||
{19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35}, |
||||
{0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91}, |
||||
{0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19}, |
||||
{0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246}, |
||||
{16,7,5},{0,8,87},{0,8,23},{78,8,0},{19,7,51},{0,8,119},{0,8,55}, |
||||
{0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135}, |
||||
{0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99}, |
||||
{0,8,127},{0,8,63},{0,9,222},{18,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,0},{0,8,80},{0,8,16}, |
||||
{20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96}, |
||||
{0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6}, |
||||
{0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209}, |
||||
{17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72}, |
||||
{0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116}, |
||||
{0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4}, |
||||
{0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153}, |
||||
{20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44}, |
||||
{0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82}, |
||||
{0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11}, |
||||
{0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229}, |
||||
{16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58}, |
||||
{0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138}, |
||||
{0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{192,8,0},{19,7,51}, |
||||
{0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173}, |
||||
{0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30}, |
||||
{0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,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,0}, |
||||
{0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195}, |
||||
{16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65}, |
||||
{0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121}, |
||||
{0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9}, |
||||
{0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{32,8,3}, |
||||
{19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37}, |
||||
{0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93}, |
||||
{0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23}, |
||||
{0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251}, |
||||
{16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51}, |
||||
{0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131}, |
||||
{0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67}, |
||||
{0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183}, |
||||
{0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23}, |
||||
{78,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103}, |
||||
{0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9}, |
||||
{0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223}, |
||||
{18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79}, |
||||
{0,9,255} |
||||
}; |
||||
|
||||
static const code distfix[32] = { |
||||
{16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025}, |
||||
{21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193}, |
||||
{18,5,9},{26,5,2049},{22,5,129},{30,5,32769},{16,5,2},{23,5,385}, |
||||
{19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577}, |
||||
{16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073}, |
||||
{22,5,193},{30,5,49153} |
||||
}; |
||||
@ -0,0 +1,408 @@ |
||||
|
||||
; match.asm -- Pentium-Pro optimized version of longest_match() |
||||
; |
||||
; Updated for zlib 1.1.3 and converted to MASM 6.1x |
||||
; Copyright (C) 2000 Dan Higdon <hdan@kinesoft.com> |
||||
; and Chuck Walbourn <chuckw@kinesoft.com> |
||||
; Corrections by Cosmin Truta <cosmint@cs.ubbcluj.ro> |
||||
; |
||||
; This is free software; you can redistribute it and/or modify it |
||||
; under the terms of the GNU General Public License. |
||||
|
||||
; Based on match.S |
||||
; Written for zlib 1.1.2 |
||||
; Copyright (C) 1998 Brian Raiter <breadbox@muppetlabs.com> |
||||
|
||||
.686P |
||||
.MODEL FLAT |
||||
|
||||
;=========================================================================== |
||||
; EQUATES |
||||
;=========================================================================== |
||||
|
||||
MAX_MATCH EQU 258 |
||||
MIN_MATCH EQU 3 |
||||
MIN_LOOKAHEAD EQU (MAX_MATCH + MIN_MATCH + 1) |
||||
MAX_MATCH_8 EQU ((MAX_MATCH + 7) AND (NOT 7)) |
||||
|
||||
;=========================================================================== |
||||
; STRUCTURES |
||||
;=========================================================================== |
||||
|
||||
; This STRUCT assumes a 4-byte alignment |
||||
|
||||
DEFLATE_STATE STRUCT |
||||
ds_strm dd ? |
||||
ds_status dd ? |
||||
ds_pending_buf dd ? |
||||
ds_pending_buf_size dd ? |
||||
ds_pending_out dd ? |
||||
ds_pending dd ? |
||||
ds_wrap dd ? |
||||
ds_data_type db ? |
||||
ds_method db ? |
||||
db ? ; padding |
||||
db ? ; padding |
||||
ds_last_flush dd ? |
||||
ds_w_size dd ? ; used |
||||
ds_w_bits dd ? |
||||
ds_w_mask dd ? ; used |
||||
ds_window dd ? ; used |
||||
ds_window_size dd ? |
||||
ds_prev dd ? ; used |
||||
ds_head dd ? |
||||
ds_ins_h dd ? |
||||
ds_hash_size dd ? |
||||
ds_hash_bits dd ? |
||||
ds_hash_mask dd ? |
||||
ds_hash_shift dd ? |
||||
ds_block_start dd ? |
||||
ds_match_length dd ? ; used |
||||
ds_prev_match dd ? ; used |
||||
ds_match_available dd ? |
||||
ds_strstart dd ? ; used |
||||
ds_match_start dd ? ; used |
||||
ds_lookahead dd ? ; used |
||||
ds_prev_length dd ? ; used |
||||
ds_max_chain_length dd ? ; used |
||||
ds_max_laxy_match dd ? |
||||
ds_level dd ? |
||||
ds_strategy dd ? |
||||
ds_good_match dd ? ; used |
||||
ds_nice_match dd ? ; used |
||||
|
||||
; Don't need anymore of the struct for match |
||||
DEFLATE_STATE ENDS |
||||
|
||||
;=========================================================================== |
||||
; CODE |
||||
;=========================================================================== |
||||
_TEXT SEGMENT |
||||
|
||||
;--------------------------------------------------------------------------- |
||||
; match_init |
||||
;--------------------------------------------------------------------------- |
||||
ALIGN 4 |
||||
PUBLIC _match_init |
||||
_match_init PROC |
||||
; no initialization needed |
||||
ret |
||||
_match_init ENDP |
||||
|
||||
;--------------------------------------------------------------------------- |
||||
; uInt longest_match(deflate_state *deflatestate, IPos curmatch) |
||||
;--------------------------------------------------------------------------- |
||||
ALIGN 4 |
||||
|
||||
PUBLIC _longest_match |
||||
_longest_match PROC |
||||
|
||||
; Since this code uses EBP for a scratch register, the stack frame must |
||||
; be manually constructed and referenced relative to the ESP register. |
||||
|
||||
; Stack image |
||||
; Variables |
||||
chainlenwmask = 0 ; high word: current chain len |
||||
; low word: s->wmask |
||||
window = 4 ; local copy of s->window |
||||
windowbestlen = 8 ; s->window + bestlen |
||||
scanend = 12 ; last two bytes of string |
||||
scanstart = 16 ; first two bytes of string |
||||
scanalign = 20 ; dword-misalignment of string |
||||
nicematch = 24 ; a good enough match size |
||||
bestlen = 28 ; size of best match so far |
||||
scan = 32 ; ptr to string wanting match |
||||
varsize = 36 ; number of bytes (also offset to last saved register) |
||||
|
||||
; Saved Registers (actually pushed into place) |
||||
ebx_save = 36 |
||||
edi_save = 40 |
||||
esi_save = 44 |
||||
ebp_save = 48 |
||||
|
||||
; Parameters |
||||
retaddr = 52 |
||||
deflatestate = 56 |
||||
curmatch = 60 |
||||
|
||||
; Save registers that the compiler may be using |
||||
push ebp |
||||
push edi |
||||
push esi |
||||
push ebx |
||||
|
||||
; Allocate local variable space |
||||
sub esp,varsize |
||||
|
||||
; Retrieve the function arguments. ecx will hold cur_match |
||||
; throughout the entire function. edx will hold the pointer to the |
||||
; deflate_state structure during the function's setup (before |
||||
; entering the main loop). |
||||
|
||||
mov edx, [esp+deflatestate] |
||||
ASSUME edx:PTR DEFLATE_STATE |
||||
|
||||
mov ecx, [esp+curmatch] |
||||
|
||||
; uInt wmask = s->w_mask; |
||||
; unsigned chain_length = s->max_chain_length; |
||||
; if (s->prev_length >= s->good_match) { |
||||
; chain_length >>= 2; |
||||
; } |
||||
|
||||
mov eax, [edx].ds_prev_length |
||||
mov ebx, [edx].ds_good_match |
||||
cmp eax, ebx |
||||
mov eax, [edx].ds_w_mask |
||||
mov ebx, [edx].ds_max_chain_length |
||||
jl SHORT LastMatchGood |
||||
shr ebx, 2 |
||||
LastMatchGood: |
||||
|
||||
; chainlen is decremented once beforehand so that the function can |
||||
; use the sign flag instead of the zero flag for the exit test. |
||||
; It is then shifted into the high word, to make room for the wmask |
||||
; value, which it will always accompany. |
||||
|
||||
dec ebx |
||||
shl ebx, 16 |
||||
or ebx, eax |
||||
mov [esp+chainlenwmask], ebx |
||||
|
||||
; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; |
||||
|
||||
mov eax, [edx].ds_nice_match |
||||
mov ebx, [edx].ds_lookahead |
||||
cmp ebx, eax |
||||
jl SHORT LookaheadLess |
||||
mov ebx, eax |
||||
LookaheadLess: |
||||
mov [esp+nicematch], ebx |
||||
|
||||
;/* register Bytef *scan = s->window + s->strstart; */ |
||||
|
||||
mov esi, [edx].ds_window |
||||
mov [esp+window], esi |
||||
mov ebp, [edx].ds_strstart |
||||
lea edi, [esi+ebp] |
||||
mov [esp+scan],edi |
||||
|
||||
;/* Determine how many bytes the scan ptr is off from being */ |
||||
;/* dword-aligned. */ |
||||
|
||||
mov eax, edi |
||||
neg eax |
||||
and eax, 3 |
||||
mov [esp+scanalign], eax |
||||
|
||||
;/* IPos limit = s->strstart > (IPos)MAX_DIST(s) ? */ |
||||
;/* s->strstart - (IPos)MAX_DIST(s) : NIL; */ |
||||
|
||||
mov eax, [edx].ds_w_size |
||||
sub eax, MIN_LOOKAHEAD |
||||
sub ebp, eax |
||||
jg SHORT LimitPositive |
||||
xor ebp, ebp |
||||
LimitPositive: |
||||
|
||||
;/* int best_len = s->prev_length; */ |
||||
|
||||
mov eax, [edx].ds_prev_length |
||||
mov [esp+bestlen], eax |
||||
|
||||
;/* Store the sum of s->window + best_len in %esi locally, and in %esi. */ |
||||
|
||||
add esi, eax |
||||
mov [esp+windowbestlen], esi |
||||
|
||||
;/* register ush scan_start = *(ushf*)scan; */ |
||||
;/* register ush scan_end = *(ushf*)(scan+best_len-1); */ |
||||
;/* Posf *prev = s->prev; */ |
||||
|
||||
movzx ebx, WORD PTR[edi] |
||||
mov [esp+scanstart], ebx |
||||
movzx ebx, WORD PTR[eax+edi-1] |
||||
mov [esp+scanend], ebx |
||||
mov edi, [edx].ds_prev |
||||
|
||||
;/* Jump into the main loop. */ |
||||
|
||||
mov edx, [esp+chainlenwmask] |
||||
jmp SHORT LoopEntry |
||||
|
||||
;/* do { |
||||
; * match = s->window + cur_match; |
||||
; * if (*(ushf*)(match+best_len-1) != scan_end || |
||||
; * *(ushf*)match != scan_start) continue; |
||||
; * [...] |
||||
; * } while ((cur_match = prev[cur_match & wmask]) > limit |
||||
; * && --chain_length != 0); |
||||
; * |
||||
; * Here is the inner loop of the function. The function will spend the |
||||
; * majority of its time in this loop, and majority of that time will |
||||
; * be spent in the first ten instructions. |
||||
; * |
||||
; * Within this loop: |
||||
; * %ebx = scanend |
||||
; * %ecx = curmatch |
||||
; * %edx = chainlenwmask - i.e., ((chainlen << 16) | wmask) |
||||
; * %esi = windowbestlen - i.e., (window + bestlen) |
||||
; * %edi = prev |
||||
; * %ebp = limit |
||||
; */ |
||||
|
||||
ALIGN 4 |
||||
LookupLoop: |
||||
and ecx, edx |
||||
movzx ecx, WORD PTR[edi+ecx*2] |
||||
cmp ecx, ebp |
||||
jbe LeaveNow |
||||
sub edx, 000010000H |
||||
js LeaveNow |
||||
|
||||
LoopEntry: |
||||
movzx eax, WORD PTR[esi+ecx-1] |
||||
cmp eax, ebx |
||||
jnz SHORT LookupLoop |
||||
|
||||
mov eax, [esp+window] |
||||
movzx eax, WORD PTR[eax+ecx] |
||||
cmp eax, [esp+scanstart] |
||||
jnz SHORT LookupLoop |
||||
|
||||
;/* Store the current value of chainlen. */ |
||||
|
||||
mov [esp+chainlenwmask], edx |
||||
|
||||
;/* Point %edi to the string under scrutiny, and %esi to the string we */ |
||||
;/* are hoping to match it up with. In actuality, %esi and %edi are */ |
||||
;/* both pointed (MAX_MATCH_8 - scanalign) bytes ahead, and %edx is */ |
||||
;/* initialized to -(MAX_MATCH_8 - scanalign). */ |
||||
|
||||
mov esi, [esp+window] |
||||
mov edi, [esp+scan] |
||||
add esi, ecx |
||||
mov eax, [esp+scanalign] |
||||
mov edx, -MAX_MATCH_8 |
||||
lea edi, [edi+eax+MAX_MATCH_8] |
||||
lea esi, [esi+eax+MAX_MATCH_8] |
||||
|
||||
;/* Test the strings for equality, 8 bytes at a time. At the end, |
||||
; * adjust %edx so that it is offset to the exact byte that mismatched. |
||||
; * |
||||
; * We already know at this point that the first three bytes of the |
||||
; * strings match each other, and they can be safely passed over before |
||||
; * starting the compare loop. So what this code does is skip over 0-3 |
||||
; * bytes, as much as necessary in order to dword-align the %edi |
||||
; * pointer. (%esi will still be misaligned three times out of four.) |
||||
; * |
||||
; * It should be confessed that this loop usually does not represent |
||||
; * much of the total running time. Replacing it with a more |
||||
; * straightforward "rep cmpsb" would not drastically degrade |
||||
; * performance. |
||||
; */ |
||||
|
||||
LoopCmps: |
||||
mov eax, DWORD PTR[esi+edx] |
||||
xor eax, DWORD PTR[edi+edx] |
||||
jnz SHORT LeaveLoopCmps |
||||
|
||||
mov eax, DWORD PTR[esi+edx+4] |
||||
xor eax, DWORD PTR[edi+edx+4] |
||||
jnz SHORT LeaveLoopCmps4 |
||||
|
||||
add edx, 8 |
||||
jnz SHORT LoopCmps |
||||
jmp LenMaximum |
||||
ALIGN 4 |
||||
|
||||
LeaveLoopCmps4: |
||||
add edx, 4 |
||||
|
||||
LeaveLoopCmps: |
||||
test eax, 00000FFFFH |
||||
jnz SHORT LenLower |
||||
|
||||
add edx, 2 |
||||
shr eax, 16 |
||||
|
||||
LenLower: |
||||
sub al, 1 |
||||
adc edx, 0 |
||||
|
||||
;/* Calculate the length of the match. If it is longer than MAX_MATCH, */ |
||||
;/* then automatically accept it as the best possible match and leave. */ |
||||
|
||||
lea eax, [edi+edx] |
||||
mov edi, [esp+scan] |
||||
sub eax, edi |
||||
cmp eax, MAX_MATCH |
||||
jge SHORT LenMaximum |
||||
|
||||
;/* If the length of the match is not longer than the best match we */ |
||||
;/* have so far, then forget it and return to the lookup loop. */ |
||||
|
||||
mov edx, [esp+deflatestate] |
||||
mov ebx, [esp+bestlen] |
||||
cmp eax, ebx |
||||
jg SHORT LongerMatch |
||||
mov esi, [esp+windowbestlen] |
||||
mov edi, [edx].ds_prev |
||||
mov ebx, [esp+scanend] |
||||
mov edx, [esp+chainlenwmask] |
||||
jmp LookupLoop |
||||
ALIGN 4 |
||||
|
||||
;/* s->match_start = cur_match; */ |
||||
;/* best_len = len; */ |
||||
;/* if (len >= nice_match) break; */ |
||||
;/* scan_end = *(ushf*)(scan+best_len-1); */ |
||||
|
||||
LongerMatch: |
||||
mov ebx, [esp+nicematch] |
||||
mov [esp+bestlen], eax |
||||
mov [edx].ds_match_start, ecx |
||||
cmp eax, ebx |
||||
jge SHORT LeaveNow |
||||
mov esi, [esp+window] |
||||
add esi, eax |
||||
mov [esp+windowbestlen], esi |
||||
movzx ebx, WORD PTR[edi+eax-1] |
||||
mov edi, [edx].ds_prev |
||||
mov [esp+scanend], ebx |
||||
mov edx, [esp+chainlenwmask] |
||||
jmp LookupLoop |
||||
ALIGN 4 |
||||
|
||||
;/* Accept the current string, with the maximum possible length. */ |
||||
|
||||
LenMaximum: |
||||
mov edx, [esp+deflatestate] |
||||
mov DWORD PTR[esp+bestlen], MAX_MATCH |
||||
mov [edx].ds_match_start, ecx |
||||
|
||||
;/* if ((uInt)best_len <= s->lookahead) return (uInt)best_len; */ |
||||
;/* return s->lookahead; */ |
||||
|
||||
LeaveNow: |
||||
mov edx, [esp+deflatestate] |
||||
mov ebx, [esp+bestlen] |
||||
mov eax, [edx].ds_lookahead |
||||
cmp ebx, eax |
||||
jg SHORT LookaheadRet |
||||
mov eax, ebx |
||||
LookaheadRet: |
||||
|
||||
; Restore the stack and return from whence we came. |
||||
|
||||
add esp, varsize |
||||
pop ebx |
||||
pop esi |
||||
pop edi |
||||
pop ebp |
||||
ret |
||||
|
||||
_longest_match ENDP |
||||
|
||||
_TEXT ENDS |
||||
END |
||||
File diff suppressed because it is too large
Load Diff
@ -1,209 +1,206 @@ |
||||
/* 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 <windows.h>
|
||||
|
||||
#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 */ |
||||
/* 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" |
||||
|
||||
#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 */ |
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,3 @@ |
||||
cl /I..\.. /O2 /c gvmat32c.c |
||||
ml /coff /Zi /c /Flgvmat32.lst gvmat32.asm |
||||
ml /coff /Zi /c /Flinffas32.lst inffas32.asm |
||||
@ -0,0 +1,21 @@ |
||||
|
||||
Summary |
||||
------- |
||||
This directory contains ASM implementations of the functions |
||||
longest_match() and inflate_fast(). |
||||
|
||||
|
||||
Use instructions |
||||
---------------- |
||||
Copy these files into the zlib source directory, then run the |
||||
appropriate makefile, as suggested below. |
||||
|
||||
|
||||
Build instructions |
||||
------------------ |
||||
* With Microsoft C and MASM: |
||||
nmake -f win32/Makefile.msc LOC="-DASMV -DASMINF" OBJA="gvmat32c.obj gvmat32.obj inffas32.obj" |
||||
|
||||
* With Borland C and TASM: |
||||
make -f win32/Makefile.bor LOCAL_ZLIB="-DASMV -DASMINF" OBJA="gvmat32c.obj gvmat32.obj inffas32.obj" OBJPA="+gvmat32c.obj+gvmat32.obj+inffas32.obj" |
||||
|
||||
@ -1,51 +1,51 @@ |
||||
Change in 0.22: (19 May 03) |
||||
- crypting support (unless you define NOCRYPT) |
||||
- append file in existing zipfile |
||||
|
||||
Change in 0.21: (10 Mar 03) |
||||
- bug fixes |
||||
|
||||
Change in 0.17: (27 Jan 02) |
||||
- bug fixes |
||||
|
||||
Change in 0.16: (19 Jan 02) |
||||
- Support of ioapi for virtualize zip file access |
||||
|
||||
Change in 0.15: (19 Mar 98) |
||||
- fix memory leak in minizip.c |
||||
|
||||
Change in 0.14: (10 Mar 98) |
||||
- fix bugs in minizip.c sample for zipping big file |
||||
- fix problem in month in date handling |
||||
- fix bug in unzlocal_GetCurrentFileInfoInternal in unzip.c for |
||||
comment handling |
||||
|
||||
Change in 0.13: (6 Mar 98) |
||||
- fix bugs in zip.c |
||||
- add real minizip sample |
||||
|
||||
Change in 0.12: (4 Mar 98) |
||||
- add zip.c and zip.h for creates .zip file |
||||
- fix change_file_date in miniunz.c for Unix (Jean-loup Gailly) |
||||
- fix miniunz.c for file without specific record for directory |
||||
|
||||
Change in 0.11: (3 Mar 98) |
||||
- fix bug in unzGetCurrentFileInfo for get extra field and comment |
||||
- enhance miniunz sample, remove the bad unztst.c sample |
||||
|
||||
Change in 0.10: (2 Mar 98) |
||||
- fix bug in unzReadCurrentFile |
||||
- rename unzip* to unz* function and structure |
||||
- remove Windows-like hungary notation variable name |
||||
- modify some structure in unzip.h |
||||
- add somes comment in source |
||||
- remove unzipGetcCurrentFile function |
||||
- replace ZUNZEXPORT by ZEXPORT |
||||
- add unzGetLocalExtrafield for get the local extrafield info |
||||
- add a new sample, miniunz.c |
||||
|
||||
Change in 0.4: (25 Feb 98) |
||||
- suppress the type unzipFileInZip. |
||||
Only on file in the zipfile can be open at the same time |
||||
- fix somes typo in code |
||||
- added tm_unz structure in unzip_file_info (date/time in readable format) |
||||
Change in 0.22: (19 May 03) |
||||
- crypting support (unless you define NOCRYPT) |
||||
- append file in existing zipfile |
||||
|
||||
Change in 0.21: (10 Mar 03) |
||||
- bug fixes |
||||
|
||||
Change in 0.17: (27 Jan 02) |
||||
- bug fixes |
||||
|
||||
Change in 0.16: (19 Jan 02) |
||||
- Support of ioapi for virtualize zip file access |
||||
|
||||
Change in 0.15: (19 Mar 98) |
||||
- fix memory leak in minizip.c |
||||
|
||||
Change in 0.14: (10 Mar 98) |
||||
- fix bugs in minizip.c sample for zipping big file |
||||
- fix problem in month in date handling |
||||
- fix bug in unzlocal_GetCurrentFileInfoInternal in unzip.c for |
||||
comment handling |
||||
|
||||
Change in 0.13: (6 Mar 98) |
||||
- fix bugs in zip.c |
||||
- add real minizip sample |
||||
|
||||
Change in 0.12: (4 Mar 98) |
||||
- add zip.c and zip.h for creates .zip file |
||||
- fix change_file_date in miniunz.c for Unix (Jean-loup Gailly) |
||||
- fix miniunz.c for file without specific record for directory |
||||
|
||||
Change in 0.11: (3 Mar 98) |
||||
- fix bug in unzGetCurrentFileInfo for get extra field and comment |
||||
- enhance miniunz sample, remove the bad unztst.c sample |
||||
|
||||
Change in 0.10: (2 Mar 98) |
||||
- fix bug in unzReadCurrentFile |
||||
- rename unzip* to unz* function and structure |
||||
- remove Windows-like hungary notation variable name |
||||
- modify some structure in unzip.h |
||||
- add somes comment in source |
||||
- remove unzipGetcCurrentFile function |
||||
- replace ZUNZEXPORT by ZEXPORT |
||||
- add unzGetLocalExtrafield for get the local extrafield info |
||||
- add a new sample, miniunz.c |
||||
|
||||
Change in 0.4: (25 Feb 98) |
||||
- suppress the type unzipFileInZip. |
||||
Only on file in the zipfile can be open at the same time |
||||
- fix somes typo in code |
||||
- added tm_unz structure in unzip_file_info (date/time in readable format) |
||||
|
||||
@ -1,25 +1,25 @@ |
||||
CC=cc
|
||||
CFLAGS=-O -I../..
|
||||
|
||||
UNZ_OBJS = miniunz.o unzip.o ioapi.o ../../libz.a
|
||||
ZIP_OBJS = minizip.o zip.o ioapi.o ../../libz.a
|
||||
|
||||
.c.o: |
||||
$(CC) -c $(CFLAGS) $*.c
|
||||
|
||||
all: miniunz minizip |
||||
|
||||
miniunz: $(UNZ_OBJS) |
||||
$(CC) $(CFLAGS) -o $@ $(UNZ_OBJS)
|
||||
|
||||
minizip: $(ZIP_OBJS) |
||||
$(CC) $(CFLAGS) -o $@ $(ZIP_OBJS)
|
||||
|
||||
test: miniunz minizip |
||||
./minizip test readme.txt
|
||||
./miniunz -l test.zip
|
||||
mv readme.txt readme.old
|
||||
./miniunz test.zip
|
||||
|
||||
clean: |
||||
/bin/rm -f *.o *~ minizip miniunz
|
||||
CC=cc
|
||||
CFLAGS=-O -I../..
|
||||
|
||||
UNZ_OBJS = miniunz.o unzip.o ioapi.o ../../libz.a
|
||||
ZIP_OBJS = minizip.o zip.o ioapi.o ../../libz.a
|
||||
|
||||
.c.o: |
||||
$(CC) -c $(CFLAGS) $*.c
|
||||
|
||||
all: miniunz minizip |
||||
|
||||
miniunz: $(UNZ_OBJS) |
||||
$(CC) $(CFLAGS) -o $@ $(UNZ_OBJS)
|
||||
|
||||
minizip: $(ZIP_OBJS) |
||||
$(CC) $(CFLAGS) -o $@ $(ZIP_OBJS)
|
||||
|
||||
test: miniunz minizip |
||||
./minizip test readme.txt
|
||||
./miniunz -l test.zip
|
||||
mv readme.txt readme.old
|
||||
./miniunz test.zip
|
||||
|
||||
clean: |
||||
/bin/rm -f *.o *~ minizip miniunz
|
||||
|
||||
@ -1,104 +1,104 @@ |
||||
|
||||
#define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8)) |
||||
|
||||
/***********************************************************************
|
||||
* Return the next byte in the pseudo-random sequence |
||||
*/ |
||||
static int decrypt_byte(unsigned long* pkeys, const unsigned long* pcrc_32_tab) |
||||
{ |
||||
unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an
|
||||
* unpredictable manner on 16-bit systems; not a problem |
||||
* with any known compiler so far, though */ |
||||
|
||||
temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2; |
||||
return (int)(((temp * (temp ^ 1)) >> 8) & 0xff); |
||||
} |
||||
|
||||
/***********************************************************************
|
||||
* Update the encryption keys with the next byte of plain text |
||||
*/ |
||||
static int update_keys(unsigned long* pkeys,const unsigned long* pcrc_32_tab,int c) |
||||
{ |
||||
(*(pkeys+0)) = CRC32((*(pkeys+0)), c); |
||||
(*(pkeys+1)) += (*(pkeys+0)) & 0xff; |
||||
(*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1; |
||||
{ |
||||
register int keyshift = (int)((*(pkeys+1)) >> 24); |
||||
(*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift); |
||||
} |
||||
return c; |
||||
} |
||||
|
||||
|
||||
/***********************************************************************
|
||||
* Initialize the encryption keys and the random header according to |
||||
* the given password. |
||||
*/ |
||||
static void init_keys(const char* passwd,unsigned long* pkeys,const unsigned long* pcrc_32_tab) |
||||
{ |
||||
*(pkeys+0) = 305419896L; |
||||
*(pkeys+1) = 591751049L; |
||||
*(pkeys+2) = 878082192L; |
||||
while (*passwd != '\0') { |
||||
update_keys(pkeys,pcrc_32_tab,(int)*passwd); |
||||
passwd++; |
||||
} |
||||
} |
||||
|
||||
#define zdecode(pkeys,pcrc_32_tab,c) \ |
||||
(update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab))) |
||||
|
||||
#define zencode(pkeys,pcrc_32_tab,c,t) \ |
||||
(t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c)) |
||||
|
||||
#ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED |
||||
|
||||
#define RAND_HEAD_LEN 12 |
||||
/* "last resort" source for second part of crypt seed pattern */ |
||||
# ifndef ZCR_SEED2 |
||||
# define ZCR_SEED2 (unsigned long)3141592654L /* use PI as default pattern */ |
||||
# endif |
||||
|
||||
static int crypthead(passwd, buf, bufSize, pkeys, pcrc_32_tab, crcForCrypting) |
||||
const char *passwd; /* password string */ |
||||
unsigned char *buf; /* where to write header */ |
||||
int bufSize; |
||||
unsigned long* pkeys; |
||||
const unsigned long* pcrc_32_tab; |
||||
unsigned long crcForCrypting; |
||||
{ |
||||
int n; /* index in random header */ |
||||
int t; /* temporary */ |
||||
int c; /* random byte */ |
||||
unsigned char header[RAND_HEAD_LEN-2]; /* random header */ |
||||
static unsigned calls = 0; /* ensure different random header each time */ |
||||
|
||||
if (bufSize<RAND_HEAD_LEN) |
||||
return 0; |
||||
|
||||
/* First generate RAND_HEAD_LEN-2 random bytes. We encrypt the
|
||||
* output of rand() to get less predictability, since rand() is |
||||
* often poorly implemented. |
||||
*/ |
||||
if (++calls == 1) |
||||
{ |
||||
srand((unsigned)(time(NULL) ^ ZCR_SEED2)); |
||||
} |
||||
init_keys(passwd, pkeys, pcrc_32_tab); |
||||
for (n = 0; n < RAND_HEAD_LEN-2; n++) |
||||
{ |
||||
c = (rand() >> 7) & 0xff; |
||||
header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t); |
||||
} |
||||
/* Encrypt random header (last two bytes is high word of crc) */ |
||||
init_keys(passwd, pkeys, pcrc_32_tab); |
||||
for (n = 0; n < RAND_HEAD_LEN-2; n++) |
||||
{ |
||||
buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t); |
||||
} |
||||
buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t); |
||||
buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t); |
||||
return n; |
||||
} |
||||
|
||||
#endif |
||||
|
||||
#define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8)) |
||||
|
||||
/***********************************************************************
|
||||
* Return the next byte in the pseudo-random sequence |
||||
*/ |
||||
static int decrypt_byte(unsigned long* pkeys, const unsigned long* pcrc_32_tab) |
||||
{ |
||||
unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an
|
||||
* unpredictable manner on 16-bit systems; not a problem |
||||
* with any known compiler so far, though */ |
||||
|
||||
temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2; |
||||
return (int)(((temp * (temp ^ 1)) >> 8) & 0xff); |
||||
} |
||||
|
||||
/***********************************************************************
|
||||
* Update the encryption keys with the next byte of plain text |
||||
*/ |
||||
static int update_keys(unsigned long* pkeys,const unsigned long* pcrc_32_tab,int c) |
||||
{ |
||||
(*(pkeys+0)) = CRC32((*(pkeys+0)), c); |
||||
(*(pkeys+1)) += (*(pkeys+0)) & 0xff; |
||||
(*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1; |
||||
{ |
||||
register int keyshift = (int)((*(pkeys+1)) >> 24); |
||||
(*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift); |
||||
} |
||||
return c; |
||||
} |
||||
|
||||
|
||||
/***********************************************************************
|
||||
* Initialize the encryption keys and the random header according to |
||||
* the given password. |
||||
*/ |
||||
static void init_keys(const char* passwd,unsigned long* pkeys,const unsigned long* pcrc_32_tab) |
||||
{ |
||||
*(pkeys+0) = 305419896L; |
||||
*(pkeys+1) = 591751049L; |
||||
*(pkeys+2) = 878082192L; |
||||
while (*passwd != '\0') { |
||||
update_keys(pkeys,pcrc_32_tab,(int)*passwd); |
||||
passwd++; |
||||
} |
||||
} |
||||
|
||||
#define zdecode(pkeys,pcrc_32_tab,c) \ |
||||
(update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab))) |
||||
|
||||
#define zencode(pkeys,pcrc_32_tab,c,t) \ |
||||
(t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c)) |
||||
|
||||
#ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED |
||||
|
||||
#define RAND_HEAD_LEN 12 |
||||
/* "last resort" source for second part of crypt seed pattern */ |
||||
# ifndef ZCR_SEED2 |
||||
# define ZCR_SEED2 3141592654UL /* use PI as default pattern */ |
||||
# endif |
||||
|
||||
static int crypthead(passwd, buf, bufSize, pkeys, pcrc_32_tab, crcForCrypting) |
||||
const char *passwd; /* password string */ |
||||
unsigned char *buf; /* where to write header */ |
||||
int bufSize; |
||||
unsigned long* pkeys; |
||||
const unsigned long* pcrc_32_tab; |
||||
unsigned long crcForCrypting; |
||||
{ |
||||
int n; /* index in random header */ |
||||
int t; /* temporary */ |
||||
int c; /* random byte */ |
||||
unsigned char header[RAND_HEAD_LEN-2]; /* random header */ |
||||
static unsigned calls = 0; /* ensure different random header each time */ |
||||
|
||||
if (bufSize<RAND_HEAD_LEN) |
||||
return 0; |
||||
|
||||
/* First generate RAND_HEAD_LEN-2 random bytes. We encrypt the
|
||||
* output of rand() to get less predictability, since rand() is |
||||
* often poorly implemented. |
||||
*/ |
||||
if (++calls == 1) |
||||
{ |
||||
srand((unsigned)(time(NULL) ^ ZCR_SEED2)); |
||||
} |
||||
init_keys(passwd, pkeys, pcrc_32_tab); |
||||
for (n = 0; n < RAND_HEAD_LEN-2; n++) |
||||
{ |
||||
c = (rand() >> 7) & 0xff; |
||||
header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t); |
||||
} |
||||
/* Encrypt random header (last two bytes is high word of crc) */ |
||||
init_keys(passwd, pkeys, pcrc_32_tab); |
||||
for (n = 0; n < RAND_HEAD_LEN-2; n++) |
||||
{ |
||||
buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t); |
||||
} |
||||
buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t); |
||||
buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t); |
||||
return n; |
||||
} |
||||
|
||||
#endif |
||||
|
||||
@ -1,177 +1,177 @@ |
||||
/* ioapi.c -- IO base function header for compress/uncompress .zip
|
||||
files using zlib + zip or unzip API |
||||
|
||||
Version 0.22, May 19th, 2003 |
||||
|
||||
Copyright (C) 1998-2003 Gilles Vollant |
||||
*/ |
||||
|
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <string.h> |
||||
|
||||
#include "zlib.h" |
||||
#include "ioapi.h" |
||||
|
||||
|
||||
|
||||
/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */ |
||||
|
||||
#ifndef SEEK_CUR |
||||
#define SEEK_CUR 1 |
||||
#endif |
||||
|
||||
#ifndef SEEK_END |
||||
#define SEEK_END 2 |
||||
#endif |
||||
|
||||
#ifndef SEEK_SET |
||||
#define SEEK_SET 0 |
||||
#endif |
||||
|
||||
voidpf ZCALLBACK fopen_file_func OF(( |
||||
voidpf opaque, |
||||
const char* filename, |
||||
int mode)); |
||||
|
||||
uLong ZCALLBACK fread_file_func OF(( |
||||
voidpf opaque, |
||||
voidpf stream, |
||||
void* buf, |
||||
uLong size)); |
||||
|
||||
uLong ZCALLBACK fwrite_file_func OF(( |
||||
voidpf opaque, |
||||
voidpf stream, |
||||
const void* buf, |
||||
uLong size)); |
||||
|
||||
long ZCALLBACK ftell_file_func OF(( |
||||
voidpf opaque, |
||||
voidpf stream)); |
||||
|
||||
long ZCALLBACK fseek_file_func OF(( |
||||
voidpf opaque, |
||||
voidpf stream, |
||||
uLong offset, |
||||
int origin)); |
||||
|
||||
int ZCALLBACK fclose_file_func OF(( |
||||
voidpf opaque, |
||||
voidpf stream)); |
||||
|
||||
int ZCALLBACK ferror_file_func OF(( |
||||
voidpf opaque, |
||||
voidpf stream)); |
||||
|
||||
|
||||
voidpf ZCALLBACK fopen_file_func (opaque, filename, mode) |
||||
voidpf opaque; |
||||
const char* filename; |
||||
int mode; |
||||
{ |
||||
FILE* file = NULL; |
||||
const char* mode_fopen = NULL; |
||||
if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ) |
||||
mode_fopen = "rb"; |
||||
else |
||||
if (mode & ZLIB_FILEFUNC_MODE_EXISTING) |
||||
mode_fopen = "r+b"; |
||||
else |
||||
if (mode & ZLIB_FILEFUNC_MODE_CREATE) |
||||
mode_fopen = "wb"; |
||||
|
||||
if ((filename!=NULL) && (mode_fopen != NULL)) |
||||
file = fopen(filename, mode_fopen); |
||||
return file; |
||||
} |
||||
|
||||
|
||||
uLong ZCALLBACK fread_file_func (opaque, stream, buf, size) |
||||
voidpf opaque; |
||||
voidpf stream; |
||||
void* buf; |
||||
uLong size; |
||||
{ |
||||
uLong ret; |
||||
ret = fread(buf, 1, (size_t)size, (FILE *)stream); |
||||
return ret; |
||||
} |
||||
|
||||
|
||||
uLong ZCALLBACK fwrite_file_func (opaque, stream, buf, size) |
||||
voidpf opaque; |
||||
voidpf stream; |
||||
const void* buf; |
||||
uLong size; |
||||
{ |
||||
uLong ret; |
||||
ret = fwrite(buf, 1, (size_t)size, (FILE *)stream); |
||||
return ret; |
||||
} |
||||
|
||||
long ZCALLBACK ftell_file_func (opaque, stream) |
||||
voidpf opaque; |
||||
voidpf stream; |
||||
{ |
||||
long ret; |
||||
ret = ftell((FILE *)stream); |
||||
return ret; |
||||
} |
||||
|
||||
long ZCALLBACK fseek_file_func (opaque, stream, offset, origin) |
||||
voidpf opaque; |
||||
voidpf stream; |
||||
uLong offset; |
||||
int origin; |
||||
{ |
||||
int fseek_origin=0; |
||||
long ret; |
||||
switch (origin) |
||||
{ |
||||
case ZLIB_FILEFUNC_SEEK_CUR : |
||||
fseek_origin = SEEK_CUR; |
||||
break; |
||||
case ZLIB_FILEFUNC_SEEK_END : |
||||
fseek_origin = SEEK_END; |
||||
break; |
||||
case ZLIB_FILEFUNC_SEEK_SET : |
||||
fseek_origin = SEEK_SET; |
||||
break; |
||||
default: return -1; |
||||
} |
||||
ret = 0; |
||||
fseek((FILE *)stream, offset, fseek_origin); |
||||
return ret; |
||||
} |
||||
|
||||
int ZCALLBACK fclose_file_func (opaque, stream) |
||||
voidpf opaque; |
||||
voidpf stream; |
||||
{ |
||||
int ret; |
||||
ret = fclose((FILE *)stream); |
||||
return ret; |
||||
} |
||||
|
||||
int ZCALLBACK ferror_file_func (opaque, stream) |
||||
voidpf opaque; |
||||
voidpf stream; |
||||
{ |
||||
int ret; |
||||
ret = ferror((FILE *)stream); |
||||
return ret; |
||||
} |
||||
|
||||
void fill_fopen_filefunc (pzlib_filefunc_def) |
||||
zlib_filefunc_def* pzlib_filefunc_def; |
||||
{ |
||||
pzlib_filefunc_def->zopen_file = fopen_file_func; |
||||
pzlib_filefunc_def->zread_file = fread_file_func; |
||||
pzlib_filefunc_def->zwrite_file = fwrite_file_func; |
||||
pzlib_filefunc_def->ztell_file = ftell_file_func; |
||||
pzlib_filefunc_def->zseek_file = fseek_file_func; |
||||
pzlib_filefunc_def->zclose_file = fclose_file_func; |
||||
pzlib_filefunc_def->zerror_file = ferror_file_func; |
||||
pzlib_filefunc_def->opaque = NULL; |
||||
} |
||||
/* ioapi.c -- IO base function header for compress/uncompress .zip
|
||||
files using zlib + zip or unzip API |
||||
|
||||
Version 0.22, May 19th, 2003 |
||||
|
||||
Copyright (C) 1998-2003 Gilles Vollant |
||||
*/ |
||||
|
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <string.h> |
||||
|
||||
#include "zlib.h" |
||||
#include "ioapi.h" |
||||
|
||||
|
||||
|
||||
/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */ |
||||
|
||||
#ifndef SEEK_CUR |
||||
#define SEEK_CUR 1 |
||||
#endif |
||||
|
||||
#ifndef SEEK_END |
||||
#define SEEK_END 2 |
||||
#endif |
||||
|
||||
#ifndef SEEK_SET |
||||
#define SEEK_SET 0 |
||||
#endif |
||||
|
||||
voidpf ZCALLBACK fopen_file_func OF(( |
||||
voidpf opaque, |
||||
const char* filename, |
||||
int mode)); |
||||
|
||||
uLong ZCALLBACK fread_file_func OF(( |
||||
voidpf opaque, |
||||
voidpf stream, |
||||
void* buf, |
||||
uLong size)); |
||||
|
||||
uLong ZCALLBACK fwrite_file_func OF(( |
||||
voidpf opaque, |
||||
voidpf stream, |
||||
const void* buf, |
||||
uLong size)); |
||||
|
||||
long ZCALLBACK ftell_file_func OF(( |
||||
voidpf opaque, |
||||
voidpf stream)); |
||||
|
||||
long ZCALLBACK fseek_file_func OF(( |
||||
voidpf opaque, |
||||
voidpf stream, |
||||
uLong offset, |
||||
int origin)); |
||||
|
||||
int ZCALLBACK fclose_file_func OF(( |
||||
voidpf opaque, |
||||
voidpf stream)); |
||||
|
||||
int ZCALLBACK ferror_file_func OF(( |
||||
voidpf opaque, |
||||
voidpf stream)); |
||||
|
||||
|
||||
voidpf ZCALLBACK fopen_file_func (opaque, filename, mode) |
||||
voidpf opaque; |
||||
const char* filename; |
||||
int mode; |
||||
{ |
||||
FILE* file = NULL; |
||||
const char* mode_fopen = NULL; |
||||
if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ) |
||||
mode_fopen = "rb"; |
||||
else |
||||
if (mode & ZLIB_FILEFUNC_MODE_EXISTING) |
||||
mode_fopen = "r+b"; |
||||
else |
||||
if (mode & ZLIB_FILEFUNC_MODE_CREATE) |
||||
mode_fopen = "wb"; |
||||
|
||||
if ((filename!=NULL) && (mode_fopen != NULL)) |
||||
file = fopen(filename, mode_fopen); |
||||
return file; |
||||
} |
||||
|
||||
|
||||
uLong ZCALLBACK fread_file_func (opaque, stream, buf, size) |
||||
voidpf opaque; |
||||
voidpf stream; |
||||
void* buf; |
||||
uLong size; |
||||
{ |
||||
uLong ret; |
||||
ret = fread(buf, 1, (size_t)size, (FILE *)stream); |
||||
return ret; |
||||
} |
||||
|
||||
|
||||
uLong ZCALLBACK fwrite_file_func (opaque, stream, buf, size) |
||||
voidpf opaque; |
||||
voidpf stream; |
||||
const void* buf; |
||||
uLong size; |
||||
{ |
||||
uLong ret; |
||||
ret = fwrite(buf, 1, (size_t)size, (FILE *)stream); |
||||
return ret; |
||||
} |
||||
|
||||
long ZCALLBACK ftell_file_func (opaque, stream) |
||||
voidpf opaque; |
||||
voidpf stream; |
||||
{ |
||||
long ret; |
||||
ret = ftell((FILE *)stream); |
||||
return ret; |
||||
} |
||||
|
||||
long ZCALLBACK fseek_file_func (opaque, stream, offset, origin) |
||||
voidpf opaque; |
||||
voidpf stream; |
||||
uLong offset; |
||||
int origin; |
||||
{ |
||||
int fseek_origin=0; |
||||
long ret; |
||||
switch (origin) |
||||
{ |
||||
case ZLIB_FILEFUNC_SEEK_CUR : |
||||
fseek_origin = SEEK_CUR; |
||||
break; |
||||
case ZLIB_FILEFUNC_SEEK_END : |
||||
fseek_origin = SEEK_END; |
||||
break; |
||||
case ZLIB_FILEFUNC_SEEK_SET : |
||||
fseek_origin = SEEK_SET; |
||||
break; |
||||
default: return -1; |
||||
} |
||||
ret = 0; |
||||
fseek((FILE *)stream, offset, fseek_origin); |
||||
return ret; |
||||
} |
||||
|
||||
int ZCALLBACK fclose_file_func (opaque, stream) |
||||
voidpf opaque; |
||||
voidpf stream; |
||||
{ |
||||
int ret; |
||||
ret = fclose((FILE *)stream); |
||||
return ret; |
||||
} |
||||
|
||||
int ZCALLBACK ferror_file_func (opaque, stream) |
||||
voidpf opaque; |
||||
voidpf stream; |
||||
{ |
||||
int ret; |
||||
ret = ferror((FILE *)stream); |
||||
return ret; |
||||
} |
||||
|
||||
void fill_fopen_filefunc (pzlib_filefunc_def) |
||||
zlib_filefunc_def* pzlib_filefunc_def; |
||||
{ |
||||
pzlib_filefunc_def->zopen_file = fopen_file_func; |
||||
pzlib_filefunc_def->zread_file = fread_file_func; |
||||
pzlib_filefunc_def->zwrite_file = fwrite_file_func; |
||||
pzlib_filefunc_def->ztell_file = ftell_file_func; |
||||
pzlib_filefunc_def->zseek_file = fseek_file_func; |
||||
pzlib_filefunc_def->zclose_file = fclose_file_func; |
||||
pzlib_filefunc_def->zerror_file = ferror_file_func; |
||||
pzlib_filefunc_def->opaque = NULL; |
||||
} |
||||
|
||||
@ -1,75 +1,75 @@ |
||||
/* ioapi.h -- IO base function header for compress/uncompress .zip
|
||||
files using zlib + zip or unzip API |
||||
|
||||
Version 0.22, May 19th, 2003 |
||||
|
||||
Copyright (C) 1998-2003 Gilles Vollant |
||||
*/ |
||||
|
||||
#ifndef _ZLIBIOAPI_H |
||||
#define _ZLIBIOAPI_H |
||||
|
||||
|
||||
#define ZLIB_FILEFUNC_SEEK_CUR (1) |
||||
#define ZLIB_FILEFUNC_SEEK_END (2) |
||||
#define ZLIB_FILEFUNC_SEEK_SET (0) |
||||
|
||||
#define ZLIB_FILEFUNC_MODE_READ (1) |
||||
#define ZLIB_FILEFUNC_MODE_WRITE (2) |
||||
#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3) |
||||
|
||||
#define ZLIB_FILEFUNC_MODE_EXISTING (4) |
||||
#define ZLIB_FILEFUNC_MODE_CREATE (8) |
||||
|
||||
|
||||
#ifndef ZCALLBACK |
||||
|
||||
#if (defined(WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK) |
||||
#define ZCALLBACK CALLBACK |
||||
#else |
||||
#define ZCALLBACK |
||||
#endif |
||||
#endif |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
typedef voidpf (ZCALLBACK *open_file_func) OF((voidpf opaque, const char* filename, int mode)); |
||||
typedef uLong (ZCALLBACK *read_file_func) OF((voidpf opaque, voidpf stream, void* buf, uLong size)); |
||||
typedef uLong (ZCALLBACK *write_file_func) OF((voidpf opaque, voidpf stream, const void* buf, uLong size)); |
||||
typedef long (ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream)); |
||||
typedef long (ZCALLBACK *seek_file_func) OF((voidpf opaque, voidpf stream, uLong offset, int origin)); |
||||
typedef int (ZCALLBACK *close_file_func) OF((voidpf opaque, voidpf stream)); |
||||
typedef int (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream)); |
||||
|
||||
typedef struct zlib_filefunc_def_s |
||||
{ |
||||
open_file_func zopen_file; |
||||
read_file_func zread_file; |
||||
write_file_func zwrite_file; |
||||
tell_file_func ztell_file; |
||||
seek_file_func zseek_file; |
||||
close_file_func zclose_file; |
||||
testerror_file_func zerror_file; |
||||
voidpf opaque; |
||||
} zlib_filefunc_def; |
||||
|
||||
|
||||
|
||||
void fill_fopen_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def)); |
||||
|
||||
#define ZREAD(filefunc,filestream,buf,size) ((*((filefunc).zread_file))((filefunc).opaque,filestream,buf,size)) |
||||
#define ZWRITE(filefunc,filestream,buf,size) ((*((filefunc).zwrite_file))((filefunc).opaque,filestream,buf,size)) |
||||
#define ZTELL(filefunc,filestream) ((*((filefunc).ztell_file))((filefunc).opaque,filestream)) |
||||
#define ZSEEK(filefunc,filestream,pos,mode) ((*((filefunc).zseek_file))((filefunc).opaque,filestream,pos,mode)) |
||||
#define ZCLOSE(filefunc,filestream) ((*((filefunc).zclose_file))((filefunc).opaque,filestream)) |
||||
#define ZERROR(filefunc,filestream) ((*((filefunc).zerror_file))((filefunc).opaque,filestream)) |
||||
|
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
|
||||
#endif |
||||
|
||||
/* ioapi.h -- IO base function header for compress/uncompress .zip
|
||||
files using zlib + zip or unzip API |
||||
|
||||
Version 0.22, May 19th, 2003 |
||||
|
||||
Copyright (C) 1998-2003 Gilles Vollant |
||||
*/ |
||||
|
||||
#ifndef _ZLIBIOAPI_H |
||||
#define _ZLIBIOAPI_H |
||||
|
||||
|
||||
#define ZLIB_FILEFUNC_SEEK_CUR (1) |
||||
#define ZLIB_FILEFUNC_SEEK_END (2) |
||||
#define ZLIB_FILEFUNC_SEEK_SET (0) |
||||
|
||||
#define ZLIB_FILEFUNC_MODE_READ (1) |
||||
#define ZLIB_FILEFUNC_MODE_WRITE (2) |
||||
#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3) |
||||
|
||||
#define ZLIB_FILEFUNC_MODE_EXISTING (4) |
||||
#define ZLIB_FILEFUNC_MODE_CREATE (8) |
||||
|
||||
|
||||
#ifndef ZCALLBACK |
||||
|
||||
#if (defined(WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK) |
||||
#define ZCALLBACK CALLBACK |
||||
#else |
||||
#define ZCALLBACK |
||||
#endif |
||||
#endif |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
typedef voidpf (ZCALLBACK *open_file_func) OF((voidpf opaque, const char* filename, int mode)); |
||||
typedef uLong (ZCALLBACK *read_file_func) OF((voidpf opaque, voidpf stream, void* buf, uLong size)); |
||||
typedef uLong (ZCALLBACK *write_file_func) OF((voidpf opaque, voidpf stream, const void* buf, uLong size)); |
||||
typedef long (ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream)); |
||||
typedef long (ZCALLBACK *seek_file_func) OF((voidpf opaque, voidpf stream, uLong offset, int origin)); |
||||
typedef int (ZCALLBACK *close_file_func) OF((voidpf opaque, voidpf stream)); |
||||
typedef int (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream)); |
||||
|
||||
typedef struct zlib_filefunc_def_s |
||||
{ |
||||
open_file_func zopen_file; |
||||
read_file_func zread_file; |
||||
write_file_func zwrite_file; |
||||
tell_file_func ztell_file; |
||||
seek_file_func zseek_file; |
||||
close_file_func zclose_file; |
||||
testerror_file_func zerror_file; |
||||
voidpf opaque; |
||||
} zlib_filefunc_def; |
||||
|
||||
|
||||
|
||||
void fill_fopen_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def)); |
||||
|
||||
#define ZREAD(filefunc,filestream,buf,size) ((*((filefunc).zread_file))((filefunc).opaque,filestream,buf,size)) |
||||
#define ZWRITE(filefunc,filestream,buf,size) ((*((filefunc).zwrite_file))((filefunc).opaque,filestream,buf,size)) |
||||
#define ZTELL(filefunc,filestream) ((*((filefunc).ztell_file))((filefunc).opaque,filestream)) |
||||
#define ZSEEK(filefunc,filestream,pos,mode) ((*((filefunc).zseek_file))((filefunc).opaque,filestream,pos,mode)) |
||||
#define ZCLOSE(filefunc,filestream) ((*((filefunc).zclose_file))((filefunc).opaque,filestream)) |
||||
#define ZERROR(filefunc,filestream) ((*((filefunc).zerror_file))((filefunc).opaque,filestream)) |
||||
|
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
|
||||
#endif |
||||
|
||||
|
||||
@ -1,271 +1,270 @@ |
||||
/* iowin32.c -- IO base function header for compress/uncompress .zip
|
||||
files using zlib + zip or unzip API |
||||
This IO API version uses the Win32 API (for Microsoft Windows) |
||||
|
||||
Version 0.22, May 19th, 2003 |
||||
|
||||
Copyright (C) 1998-2003 Gilles Vollant |
||||
*/ |
||||
|
||||
#include <windows.h> |
||||
#include <stdlib.h> |
||||
|
||||
#include "zlib.h" |
||||
#include "ioapi.h" |
||||
#include "iowin32.h" |
||||
|
||||
#ifndef INVALID_HANDLE_VALUE |
||||
#define INVALID_HANDLE_VALUE (0xFFFFFFFF) |
||||
#endif |
||||
|
||||
#ifndef INVALID_SET_FILE_POINTER |
||||
#define INVALID_SET_FILE_POINTER ((DWORD)-1) |
||||
#endif |
||||
|
||||
voidpf ZCALLBACK win32_open_file_func OF(( |
||||
voidpf opaque, |
||||
const char* filename, |
||||
int mode)); |
||||
|
||||
uLong ZCALLBACK win32_read_file_func OF(( |
||||
voidpf opaque, |
||||
voidpf stream, |
||||
void* buf, |
||||
uLong size)); |
||||
|
||||
uLong ZCALLBACK win32_write_file_func OF(( |
||||
voidpf opaque, |
||||
voidpf stream, |
||||
const void* buf, |
||||
uLong size)); |
||||
|
||||
long ZCALLBACK win32_tell_file_func OF(( |
||||
voidpf opaque, |
||||
voidpf stream)); |
||||
|
||||
long ZCALLBACK win32_seek_file_func OF(( |
||||
voidpf opaque, |
||||
voidpf stream, |
||||
uLong offset, |
||||
int origin)); |
||||
|
||||
long ZCALLBACK win32_close_file_func OF(( |
||||
voidpf opaque, |
||||
voidpf stream)); |
||||
|
||||
int ZCALLBACK win32_error_file_func OF(( |
||||
voidpf opaque, |
||||
voidpf stream)); |
||||
|
||||
typedef struct |
||||
{ |
||||
HANDLE hf; |
||||
int error; |
||||
} WIN32FILE_IOWIN; |
||||
|
||||
voidpf ZCALLBACK win32_open_file_func (opaque, filename, mode) |
||||
voidpf opaque; |
||||
const char* filename; |
||||
int mode; |
||||
{ |
||||
const char* mode_fopen = NULL; |
||||
DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ; |
||||
HANDLE hFile = 0; |
||||
voidpf ret=NULL; |
||||
|
||||
dwDesiredAccess = dwShareMode = dwFlagsAndAttributes = 0; |
||||
|
||||
if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ) |
||||
{ |
||||
dwDesiredAccess = GENERIC_READ; |
||||
dwCreationDisposition = OPEN_EXISTING; |
||||
dwShareMode = FILE_SHARE_READ; |
||||
} |
||||
else |
||||
if (mode & ZLIB_FILEFUNC_MODE_EXISTING) |
||||
{ |
||||
dwDesiredAccess = GENERIC_WRITE | GENERIC_READ; |
||||
dwCreationDisposition = OPEN_EXISTING; |
||||
} |
||||
else |
||||
if (mode & ZLIB_FILEFUNC_MODE_CREATE) |
||||
{ |
||||
dwDesiredAccess = GENERIC_WRITE | GENERIC_READ; |
||||
dwCreationDisposition = CREATE_ALWAYS; |
||||
} |
||||
|
||||
if ((filename!=NULL) && (dwDesiredAccess != 0)) |
||||
hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, |
||||
dwCreationDisposition, dwFlagsAndAttributes, NULL); |
||||
|
||||
if (hFile == INVALID_HANDLE_VALUE) |
||||
hFile = NULL; |
||||
|
||||
if (hFile != NULL) |
||||
{ |
||||
WIN32FILE_IOWIN w32fiow; |
||||
w32fiow.hf = hFile; |
||||
w32fiow.error = 0; |
||||
ret = malloc(sizeof(WIN32FILE_IOWIN)); |
||||
if (ret==NULL) |
||||
CloseHandle(hFile); |
||||
else *((WIN32FILE_IOWIN*)ret) = w32fiow; |
||||
} |
||||
return ret; |
||||
} |
||||
|
||||
|
||||
uLong ZCALLBACK win32_read_file_func (opaque, stream, buf, size) |
||||
voidpf opaque; |
||||
voidpf stream; |
||||
void* buf; |
||||
uLong size; |
||||
{ |
||||
uLong ret=0; |
||||
HANDLE hFile = NULL; |
||||
if (stream!=NULL) |
||||
hFile = ((WIN32FILE_IOWIN*)stream) -> hf; |
||||
if (hFile != NULL) |
||||
if (!ReadFile(hFile, buf, size, &ret, NULL)) |
||||
{ |
||||
DWORD dwErr = GetLastError(); |
||||
if (dwErr == ERROR_HANDLE_EOF) |
||||
dwErr = 0; |
||||
((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; |
||||
} |
||||
|
||||
return ret; |
||||
} |
||||
|
||||
|
||||
uLong ZCALLBACK win32_write_file_func (opaque, stream, buf, size) |
||||
voidpf opaque; |
||||
voidpf stream; |
||||
const void* buf; |
||||
uLong size; |
||||
{ |
||||
uLong ret=0; |
||||
HANDLE hFile = NULL; |
||||
if (stream!=NULL) |
||||
hFile = ((WIN32FILE_IOWIN*)stream) -> hf; |
||||
|
||||
if (hFile !=NULL) |
||||
if (!WriteFile(hFile, buf, size, &ret, NULL)) |
||||
{ |
||||
DWORD dwErr = GetLastError(); |
||||
if (dwErr == ERROR_HANDLE_EOF) |
||||
dwErr = 0; |
||||
((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; |
||||
} |
||||
|
||||
return ret; |
||||
} |
||||
|
||||
long ZCALLBACK win32_tell_file_func (opaque, stream) |
||||
voidpf opaque; |
||||
voidpf stream; |
||||
{ |
||||
long ret=-1; |
||||
HANDLE hFile = NULL; |
||||
if (stream!=NULL) |
||||
hFile = ((WIN32FILE_IOWIN*)stream) -> hf; |
||||
if (hFile != NULL) |
||||
{ |
||||
DWORD dwSet = SetFilePointer(hFile, 0, NULL, FILE_CURRENT); |
||||
if (dwSet == INVALID_SET_FILE_POINTER) |
||||
{ |
||||
DWORD dwErr = GetLastError(); |
||||
((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; |
||||
ret = -1; |
||||
} |
||||
else |
||||
ret=(long)dwSet; |
||||
} |
||||
return ret; |
||||
} |
||||
|
||||
long ZCALLBACK win32_seek_file_func (opaque, stream, offset, origin) |
||||
voidpf opaque; |
||||
voidpf stream; |
||||
uLong offset; |
||||
int origin; |
||||
{ |
||||
DWORD dwMoveMethod=0xFFFFFFFF; |
||||
HANDLE hFile = NULL; |
||||
|
||||
long ret=-1; |
||||
if (stream!=NULL) |
||||
hFile = ((WIN32FILE_IOWIN*)stream) -> hf; |
||||
switch (origin) |
||||
{ |
||||
case ZLIB_FILEFUNC_SEEK_CUR : |
||||
dwMoveMethod = FILE_CURRENT; |
||||
break; |
||||
case ZLIB_FILEFUNC_SEEK_END : |
||||
dwMoveMethod = FILE_END; |
||||
break; |
||||
case ZLIB_FILEFUNC_SEEK_SET : |
||||
dwMoveMethod = FILE_BEGIN; |
||||
break; |
||||
default: return -1; |
||||
} |
||||
|
||||
if (hFile != NULL) |
||||
{ |
||||
DWORD dwSet = SetFilePointer(hFile, offset, NULL, dwMoveMethod); |
||||
if (dwSet == INVALID_SET_FILE_POINTER) |
||||
{ |
||||
DWORD dwErr = GetLastError(); |
||||
((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; |
||||
ret = -1; |
||||
} |
||||
else |
||||
ret=0; |
||||
} |
||||
return ret; |
||||
} |
||||
|
||||
long ZCALLBACK win32_close_file_func (opaque, stream) |
||||
voidpf opaque; |
||||
voidpf stream; |
||||
{ |
||||
long ret=-1; |
||||
|
||||
if (stream!=NULL) |
||||
{ |
||||
HANDLE hFile; |
||||
hFile = ((WIN32FILE_IOWIN*)stream) -> hf; |
||||
if (hFile != NULL) |
||||
{ |
||||
CloseHandle(hFile); |
||||
ret=0; |
||||
} |
||||
free(stream); |
||||
} |
||||
return ret; |
||||
} |
||||
|
||||
int ZCALLBACK win32_error_file_func (opaque, stream) |
||||
voidpf opaque; |
||||
voidpf stream; |
||||
{ |
||||
int ret=-1; |
||||
if (stream!=NULL) |
||||
{ |
||||
ret = ((WIN32FILE_IOWIN*)stream) -> error; |
||||
} |
||||
return ret; |
||||
} |
||||
|
||||
void fill_win32_filefunc (pzlib_filefunc_def) |
||||
zlib_filefunc_def* pzlib_filefunc_def; |
||||
{ |
||||
pzlib_filefunc_def->zopen_file = win32_open_file_func; |
||||
pzlib_filefunc_def->zread_file = win32_read_file_func; |
||||
pzlib_filefunc_def->zwrite_file = win32_write_file_func; |
||||
pzlib_filefunc_def->ztell_file = win32_tell_file_func; |
||||
pzlib_filefunc_def->zseek_file = win32_seek_file_func; |
||||
pzlib_filefunc_def->zclose_file = win32_close_file_func; |
||||
pzlib_filefunc_def->zerror_file = win32_error_file_func; |
||||
pzlib_filefunc_def->opaque=NULL; |
||||
} |
||||
/* iowin32.c -- IO base function header for compress/uncompress .zip
|
||||
files using zlib + zip or unzip API |
||||
This IO API version uses the Win32 API (for Microsoft Windows) |
||||
|
||||
Version 0.22, May 19th, 2003 |
||||
|
||||
Copyright (C) 1998-2003 Gilles Vollant |
||||
*/ |
||||
|
||||
#include <stdlib.h> |
||||
|
||||
#include "zlib.h" |
||||
#include "ioapi.h" |
||||
#include "iowin32.h" |
||||
|
||||
#ifndef INVALID_HANDLE_VALUE |
||||
#define INVALID_HANDLE_VALUE (0xFFFFFFFF) |
||||
#endif |
||||
|
||||
#ifndef INVALID_SET_FILE_POINTER |
||||
#define INVALID_SET_FILE_POINTER ((DWORD)-1) |
||||
#endif |
||||
|
||||
voidpf ZCALLBACK win32_open_file_func OF(( |
||||
voidpf opaque, |
||||
const char* filename, |
||||
int mode)); |
||||
|
||||
uLong ZCALLBACK win32_read_file_func OF(( |
||||
voidpf opaque, |
||||
voidpf stream, |
||||
void* buf, |
||||
uLong size)); |
||||
|
||||
uLong ZCALLBACK win32_write_file_func OF(( |
||||
voidpf opaque, |
||||
voidpf stream, |
||||
const void* buf, |
||||
uLong size)); |
||||
|
||||
long ZCALLBACK win32_tell_file_func OF(( |
||||
voidpf opaque, |
||||
voidpf stream)); |
||||
|
||||
long ZCALLBACK win32_seek_file_func OF(( |
||||
voidpf opaque, |
||||
voidpf stream, |
||||
uLong offset, |
||||
int origin)); |
||||
|
||||
int ZCALLBACK win32_close_file_func OF(( |
||||
voidpf opaque, |
||||
voidpf stream)); |
||||
|
||||
int ZCALLBACK win32_error_file_func OF(( |
||||
voidpf opaque, |
||||
voidpf stream)); |
||||
|
||||
typedef struct |
||||
{ |
||||
HANDLE hf; |
||||
int error; |
||||
} WIN32FILE_IOWIN; |
||||
|
||||
voidpf ZCALLBACK win32_open_file_func (opaque, filename, mode) |
||||
voidpf opaque; |
||||
const char* filename; |
||||
int mode; |
||||
{ |
||||
const char* mode_fopen = NULL; |
||||
DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ; |
||||
HANDLE hFile = 0; |
||||
voidpf ret=NULL; |
||||
|
||||
dwDesiredAccess = dwShareMode = dwFlagsAndAttributes = 0; |
||||
|
||||
if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ) |
||||
{ |
||||
dwDesiredAccess = GENERIC_READ; |
||||
dwCreationDisposition = OPEN_EXISTING; |
||||
dwShareMode = FILE_SHARE_READ; |
||||
} |
||||
else |
||||
if (mode & ZLIB_FILEFUNC_MODE_EXISTING) |
||||
{ |
||||
dwDesiredAccess = GENERIC_WRITE | GENERIC_READ; |
||||
dwCreationDisposition = OPEN_EXISTING; |
||||
} |
||||
else |
||||
if (mode & ZLIB_FILEFUNC_MODE_CREATE) |
||||
{ |
||||
dwDesiredAccess = GENERIC_WRITE | GENERIC_READ; |
||||
dwCreationDisposition = CREATE_ALWAYS; |
||||
} |
||||
|
||||
if ((filename!=NULL) && (dwDesiredAccess != 0)) |
||||
hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, |
||||
dwCreationDisposition, dwFlagsAndAttributes, NULL); |
||||
|
||||
if (hFile == INVALID_HANDLE_VALUE) |
||||
hFile = NULL; |
||||
|
||||
if (hFile != NULL) |
||||
{ |
||||
WIN32FILE_IOWIN w32fiow; |
||||
w32fiow.hf = hFile; |
||||
w32fiow.error = 0; |
||||
ret = malloc(sizeof(WIN32FILE_IOWIN)); |
||||
if (ret==NULL) |
||||
CloseHandle(hFile); |
||||
else *((WIN32FILE_IOWIN*)ret) = w32fiow; |
||||
} |
||||
return ret; |
||||
} |
||||
|
||||
|
||||
uLong ZCALLBACK win32_read_file_func (opaque, stream, buf, size) |
||||
voidpf opaque; |
||||
voidpf stream; |
||||
void* buf; |
||||
uLong size; |
||||
{ |
||||
uLong ret=0; |
||||
HANDLE hFile = NULL; |
||||
if (stream!=NULL) |
||||
hFile = ((WIN32FILE_IOWIN*)stream) -> hf; |
||||
if (hFile != NULL) |
||||
if (!ReadFile(hFile, buf, size, &ret, NULL)) |
||||
{ |
||||
DWORD dwErr = GetLastError(); |
||||
if (dwErr == ERROR_HANDLE_EOF) |
||||
dwErr = 0; |
||||
((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; |
||||
} |
||||
|
||||
return ret; |
||||
} |
||||
|
||||
|
||||
uLong ZCALLBACK win32_write_file_func (opaque, stream, buf, size) |
||||
voidpf opaque; |
||||
voidpf stream; |
||||
const void* buf; |
||||
uLong size; |
||||
{ |
||||
uLong ret=0; |
||||
HANDLE hFile = NULL; |
||||
if (stream!=NULL) |
||||
hFile = ((WIN32FILE_IOWIN*)stream) -> hf; |
||||
|
||||
if (hFile !=NULL) |
||||
if (!WriteFile(hFile, buf, size, &ret, NULL)) |
||||
{ |
||||
DWORD dwErr = GetLastError(); |
||||
if (dwErr == ERROR_HANDLE_EOF) |
||||
dwErr = 0; |
||||
((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; |
||||
} |
||||
|
||||
return ret; |
||||
} |
||||
|
||||
long ZCALLBACK win32_tell_file_func (opaque, stream) |
||||
voidpf opaque; |
||||
voidpf stream; |
||||
{ |
||||
long ret=-1; |
||||
HANDLE hFile = NULL; |
||||
if (stream!=NULL) |
||||
hFile = ((WIN32FILE_IOWIN*)stream) -> hf; |
||||
if (hFile != NULL) |
||||
{ |
||||
DWORD dwSet = SetFilePointer(hFile, 0, NULL, FILE_CURRENT); |
||||
if (dwSet == INVALID_SET_FILE_POINTER) |
||||
{ |
||||
DWORD dwErr = GetLastError(); |
||||
((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; |
||||
ret = -1; |
||||
} |
||||
else |
||||
ret=(long)dwSet; |
||||
} |
||||
return ret; |
||||
} |
||||
|
||||
long ZCALLBACK win32_seek_file_func (opaque, stream, offset, origin) |
||||
voidpf opaque; |
||||
voidpf stream; |
||||
uLong offset; |
||||
int origin; |
||||
{ |
||||
DWORD dwMoveMethod=0xFFFFFFFF; |
||||
HANDLE hFile = NULL; |
||||
|
||||
long ret=-1; |
||||
if (stream!=NULL) |
||||
hFile = ((WIN32FILE_IOWIN*)stream) -> hf; |
||||
switch (origin) |
||||
{ |
||||
case ZLIB_FILEFUNC_SEEK_CUR : |
||||
dwMoveMethod = FILE_CURRENT; |
||||
break; |
||||
case ZLIB_FILEFUNC_SEEK_END : |
||||
dwMoveMethod = FILE_END; |
||||
break; |
||||
case ZLIB_FILEFUNC_SEEK_SET : |
||||
dwMoveMethod = FILE_BEGIN; |
||||
break; |
||||
default: return -1; |
||||
} |
||||
|
||||
if (hFile != NULL) |
||||
{ |
||||
DWORD dwSet = SetFilePointer(hFile, offset, NULL, dwMoveMethod); |
||||
if (dwSet == INVALID_SET_FILE_POINTER) |
||||
{ |
||||
DWORD dwErr = GetLastError(); |
||||
((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; |
||||
ret = -1; |
||||
} |
||||
else |
||||
ret=0; |
||||
} |
||||
return ret; |
||||
} |
||||
|
||||
int ZCALLBACK win32_close_file_func (opaque, stream) |
||||
voidpf opaque; |
||||
voidpf stream; |
||||
{ |
||||
int ret=-1; |
||||
|
||||
if (stream!=NULL) |
||||
{ |
||||
HANDLE hFile; |
||||
hFile = ((WIN32FILE_IOWIN*)stream) -> hf; |
||||
if (hFile != NULL) |
||||
{ |
||||
CloseHandle(hFile); |
||||
ret=0; |
||||
} |
||||
free(stream); |
||||
} |
||||
return ret; |
||||
} |
||||
|
||||
int ZCALLBACK win32_error_file_func (opaque, stream) |
||||
voidpf opaque; |
||||
voidpf stream; |
||||
{ |
||||
int ret=-1; |
||||
if (stream!=NULL) |
||||
{ |
||||
ret = ((WIN32FILE_IOWIN*)stream) -> error; |
||||
} |
||||
return ret; |
||||
} |
||||
|
||||
void fill_win32_filefunc (pzlib_filefunc_def) |
||||
zlib_filefunc_def* pzlib_filefunc_def; |
||||
{ |
||||
pzlib_filefunc_def->zopen_file = win32_open_file_func; |
||||
pzlib_filefunc_def->zread_file = win32_read_file_func; |
||||
pzlib_filefunc_def->zwrite_file = win32_write_file_func; |
||||
pzlib_filefunc_def->ztell_file = win32_tell_file_func; |
||||
pzlib_filefunc_def->zseek_file = win32_seek_file_func; |
||||
pzlib_filefunc_def->zclose_file = win32_close_file_func; |
||||
pzlib_filefunc_def->zerror_file = win32_error_file_func; |
||||
pzlib_filefunc_def->opaque=NULL; |
||||
} |
||||
|
||||
@ -1,19 +1,21 @@ |
||||
/* iowin32.h -- IO base function header for compress/uncompress .zip
|
||||
files using zlib + zip or unzip API |
||||
This IO API version uses the Win32 API (for Microsoft Windows) |
||||
|
||||
Version 0.22, May 19th, 2003 |
||||
|
||||
Copyright (C) 1998-2003 Gilles Vollant |
||||
*/ |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
void fill_win32_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def)); |
||||
|
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
/* iowin32.h -- IO base function header for compress/uncompress .zip
|
||||
files using zlib + zip or unzip API |
||||
This IO API version uses the Win32 API (for Microsoft Windows) |
||||
|
||||
Version 0.22, May 19th, 2003 |
||||
|
||||
Copyright (C) 1998-2003 Gilles Vollant |
||||
*/ |
||||
|
||||
#include <windows.h> |
||||
|
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
void fill_win32_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def)); |
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,397 +1,397 @@ |
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <string.h> |
||||
#include <time.h> |
||||
#include <errno.h> |
||||
#include <fcntl.h> |
||||
|
||||
#ifdef unix |
||||
# include <unistd.h> |
||||
# include <utime.h> |
||||
# include <sys/types.h> |
||||
# include <sys/stat.h> |
||||
#else |
||||
# include <direct.h> |
||||
# include <io.h> |
||||
#endif |
||||
|
||||
#include "zip.h" |
||||
|
||||
#ifdef WIN32 |
||||
#define USEWIN32IOAPI |
||||
#include "iowin32.h" |
||||
#endif |
||||
|
||||
|
||||
|
||||
#define WRITEBUFFERSIZE (16384) |
||||
#define MAXFILENAME (256) |
||||
|
||||
#ifdef WIN32 |
||||
uLong filetime(f, tmzip, dt) |
||||
char *f; /* name of file to get info on */ |
||||
tm_zip *tmzip; /* return value: access, modific. and creation times */ |
||||
uLong *dt; /* dostime */ |
||||
{ |
||||
int ret = 0; |
||||
{ |
||||
FILETIME ftLocal; |
||||
HANDLE hFind; |
||||
WIN32_FIND_DATA ff32; |
||||
|
||||
hFind = FindFirstFile(f,&ff32); |
||||
if (hFind != INVALID_HANDLE_VALUE) |
||||
{ |
||||
FileTimeToLocalFileTime(&(ff32.ftLastWriteTime),&ftLocal); |
||||
FileTimeToDosDateTime(&ftLocal,((LPWORD)dt)+1,((LPWORD)dt)+0); |
||||
FindClose(hFind); |
||||
ret = 1; |
||||
} |
||||
} |
||||
return ret; |
||||
} |
||||
#else |
||||
#ifdef unix |
||||
uLong filetime(f, tmzip, dt) |
||||
char *f; /* name of file to get info on */ |
||||
tm_zip *tmzip; /* return value: access, modific. and creation times */ |
||||
uLong *dt; /* dostime */ |
||||
{ |
||||
int ret=0; |
||||
struct stat s; /* results of stat() */ |
||||
struct tm* filedate; |
||||
time_t tm_t=0; |
||||
|
||||
if (strcmp(f,"-")!=0) |
||||
{ |
||||
char name[MAXFILENAME+1]; |
||||
int len = strlen(f); |
||||
|
||||
strncpy(name, f,MAXFILENAME-1); |
||||
/* strncpy doesnt append the trailing NULL, of the string is too long. */ |
||||
name[ MAXFILENAME ] = '\0'; |
||||
|
||||
if (name[len - 1] == '/') |
||||
name[len - 1] = '\0'; |
||||
/* not all systems allow stat'ing a file with / appended */ |
||||
if (stat(name,&s)==0) |
||||
{ |
||||
tm_t = s.st_mtime; |
||||
ret = 1; |
||||
} |
||||
} |
||||
filedate = localtime(&tm_t); |
||||
|
||||
tmzip->tm_sec = filedate->tm_sec; |
||||
tmzip->tm_min = filedate->tm_min; |
||||
tmzip->tm_hour = filedate->tm_hour; |
||||
tmzip->tm_mday = filedate->tm_mday; |
||||
tmzip->tm_mon = filedate->tm_mon ; |
||||
tmzip->tm_year = filedate->tm_year; |
||||
|
||||
return ret; |
||||
} |
||||
#else |
||||
uLong filetime(f, tmzip, dt) |
||||
char *f; /* name of file to get info on */ |
||||
tm_zip *tmzip; /* return value: access, modific. and creation times */ |
||||
uLong *dt; /* dostime */ |
||||
{ |
||||
return 0; |
||||
} |
||||
#endif |
||||
#endif |
||||
|
||||
|
||||
|
||||
|
||||
int check_exist_file(filename) |
||||
const char* filename; |
||||
{ |
||||
FILE* ftestexist; |
||||
int ret = 1; |
||||
ftestexist = fopen(filename,"rb"); |
||||
if (ftestexist==NULL) |
||||
ret = 0; |
||||
else |
||||
fclose(ftestexist); |
||||
return ret; |
||||
} |
||||
|
||||
void do_banner() |
||||
{ |
||||
printf("MiniZip 0.22, demo of zLib + Zip package written by Gilles Vollant\n"); |
||||
printf("more info at http://www.winimage.com/zLibDll/unzip.html\n\n"); |
||||
} |
||||
|
||||
void do_help() |
||||
{ |
||||
printf("Usage : minizip [-o] [-a] [-0 to -9] [-p password] file.zip [files_to_add]\n\n" \
|
||||
" -o Overwrite existing file.zip\n" \
|
||||
" -a Append to existing file.zip\n" \
|
||||
" -0 Store only\n" \
|
||||
" -1 Compress faster\n" \
|
||||
" -9 Compress better\n\n"); |
||||
} |
||||
|
||||
/* calculate the CRC32 of a file,
|
||||
because to encrypt a file, we need known the CRC32 of the file before */ |
||||
int getFileCrc(const char* filenameinzip,void*buf,unsigned long size_buf,unsigned long* result_crc) |
||||
{ |
||||
unsigned long calculate_crc=0; |
||||
int err=ZIP_OK; |
||||
FILE * fin = fopen(filenameinzip,"rb"); |
||||
unsigned long size_read = 0; |
||||
unsigned long total_read = 0; |
||||
if (fin==NULL) |
||||
{ |
||||
err = ZIP_ERRNO; |
||||
} |
||||
|
||||
if (err == ZIP_OK) |
||||
do |
||||
{ |
||||
err = ZIP_OK; |
||||
size_read = (int)fread(buf,1,size_buf,fin); |
||||
if (size_read < size_buf) |
||||
if (feof(fin)==0) |
||||
{ |
||||
printf("error in reading %s\n",filenameinzip); |
||||
err = ZIP_ERRNO; |
||||
} |
||||
|
||||
if (size_read>0) |
||||
calculate_crc = crc32(calculate_crc,buf,size_read); |
||||
total_read += size_read; |
||||
|
||||
} while ((err == ZIP_OK) && (size_read>0)); |
||||
|
||||
if (fin) |
||||
fclose(fin); |
||||
|
||||
*result_crc=calculate_crc; |
||||
printf("file %s crc %x\n",filenameinzip,calculate_crc); |
||||
return err; |
||||
} |
||||
|
||||
int main(argc,argv) |
||||
int argc; |
||||
char *argv[]; |
||||
{ |
||||
int i; |
||||
int opt_overwrite=0; |
||||
int opt_compress_level=Z_DEFAULT_COMPRESSION; |
||||
int zipfilenamearg = 0; |
||||
char filename_try[MAXFILENAME+16]; |
||||
int zipok; |
||||
int err=0; |
||||
int size_buf=0; |
||||
void* buf=NULL; |
||||
const char* password=NULL; |
||||
|
||||
|
||||
do_banner(); |
||||
if (argc==1) |
||||
{ |
||||
do_help(); |
||||
return 0; |
||||
} |
||||
else |
||||
{ |
||||
for (i=1;i<argc;i++) |
||||
{ |
||||
if ((*argv[i])=='-') |
||||
{ |
||||
const char *p=argv[i]+1; |
||||
|
||||
while ((*p)!='\0') |
||||
{ |
||||
char c=*(p++);; |
||||
if ((c=='o') || (c=='O')) |
||||
opt_overwrite = 1; |
||||
if ((c=='a') || (c=='A')) |
||||
opt_overwrite = 2; |
||||
if ((c>='0') && (c<='9')) |
||||
opt_compress_level = c-'0'; |
||||
|
||||
if (((c=='p') || (c=='P')) && (i+1<argc)) |
||||
{ |
||||
password=argv[i+1]; |
||||
i++; |
||||
} |
||||
} |
||||
} |
||||
else |
||||
if (zipfilenamearg == 0) |
||||
zipfilenamearg = i ; |
||||
} |
||||
} |
||||
|
||||
size_buf = WRITEBUFFERSIZE; |
||||
buf = (void*)malloc(size_buf); |
||||
if (buf==NULL) |
||||
{ |
||||
printf("Error allocating memory\n"); |
||||
return ZIP_INTERNALERROR; |
||||
} |
||||
|
||||
if (zipfilenamearg==0) |
||||
zipok=0; |
||||
else |
||||
{ |
||||
int i,len; |
||||
int dot_found=0; |
||||
|
||||
zipok = 1 ; |
||||
strncpy(filename_try, argv[zipfilenamearg],MAXFILENAME-1); |
||||
/* strncpy doesnt append the trailing NULL, of the string is too long. */ |
||||
filename_try[ MAXFILENAME ] = '\0'; |
||||
|
||||
len=(int)strlen(filename_try); |
||||
for (i=0;i<len;i++) |
||||
if (filename_try[i]=='.') |
||||
dot_found=1; |
||||
|
||||
if (dot_found==0) |
||||
strcat(filename_try,".zip"); |
||||
|
||||
if (opt_overwrite==2) |
||||
{ |
||||
/* if the file don't exist, we not append file */ |
||||
if (check_exist_file(filename_try)==0) |
||||
opt_overwrite=1; |
||||
} |
||||
else |
||||
if (opt_overwrite==0) |
||||
if (check_exist_file(filename_try)!=0) |
||||
{ |
||||
char rep=0; |
||||
do |
||||
{ |
||||
char answer[128]; |
||||
printf("The file %s exist. Overwrite ? [y]es, [n]o, [a]ppend : ",filename_try); |
||||
scanf("%1s",answer); |
||||
rep = answer[0] ; |
||||
if ((rep>='a') && (rep<='z')) |
||||
rep -= 0x20; |
||||
} |
||||
while ((rep!='Y') && (rep!='N') && (rep!='A')); |
||||
if (rep=='N') |
||||
zipok = 0; |
||||
if (rep=='A') |
||||
opt_overwrite = 2; |
||||
} |
||||
} |
||||
|
||||
if (zipok==1) |
||||
{ |
||||
zipFile zf; |
||||
int errclose; |
||||
#ifdef USEWIN32IOAPI |
||||
zlib_filefunc_def ffunc; |
||||
fill_win32_filefunc(&ffunc); |
||||
zf = zipOpen2(filename_try,(opt_overwrite==2) ? 2 : 0,NULL,&ffunc); |
||||
#else |
||||
zf = zipOpen(filename_try,(opt_overwrite==2) ? 2 : 0); |
||||
#endif |
||||
|
||||
if (zf == NULL) |
||||
{ |
||||
printf("error opening %s\n",filename_try); |
||||
err= ZIP_ERRNO; |
||||
} |
||||
else |
||||
printf("creating %s\n",filename_try); |
||||
|
||||
for (i=zipfilenamearg+1;(i<argc) && (err==ZIP_OK);i++) |
||||
{ |
||||
if (((*(argv[i]))!='-') && ((*(argv[i]))!='/')) |
||||
{ |
||||
FILE * fin; |
||||
int size_read; |
||||
const char* filenameinzip = argv[i]; |
||||
zip_fileinfo zi; |
||||
unsigned long crcFile=0; |
||||
|
||||
zi.tmz_date.tm_sec = zi.tmz_date.tm_min = zi.tmz_date.tm_hour = |
||||
zi.tmz_date.tm_mday = zi.tmz_date.tm_mon = zi.tmz_date.tm_year = 0; |
||||
zi.dosDate = 0; |
||||
zi.internal_fa = 0; |
||||
zi.external_fa = 0; |
||||
filetime(filenameinzip,&zi.tmz_date,&zi.dosDate); |
||||
|
||||
/*
|
||||
err = zipOpenNewFileInZip(zf,filenameinzip,&zi, |
||||
NULL,0,NULL,0,NULL / * comment * /, |
||||
(opt_compress_level != 0) ? Z_DEFLATED : 0, |
||||
opt_compress_level); |
||||
*/ |
||||
if ((password != NULL) && (err==ZIP_OK)) |
||||
err = getFileCrc(filenameinzip,buf,size_buf,&crcFile); |
||||
|
||||
err = zipOpenNewFileInZip3(zf,filenameinzip,&zi, |
||||
NULL,0,NULL,0,NULL /* comment*/, |
||||
(opt_compress_level != 0) ? Z_DEFLATED : 0, |
||||
opt_compress_level,0, |
||||
/* -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, */ |
||||
-MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, |
||||
password,crcFile); |
||||
|
||||
if (err != ZIP_OK) |
||||
printf("error in opening %s in zipfile\n",filenameinzip); |
||||
else |
||||
{ |
||||
fin = fopen(filenameinzip,"rb"); |
||||
if (fin==NULL) |
||||
{ |
||||
err=ZIP_ERRNO; |
||||
printf("error in opening %s for reading\n",filenameinzip); |
||||
} |
||||
} |
||||
|
||||
if (err == ZIP_OK) |
||||
do |
||||
{ |
||||
err = ZIP_OK; |
||||
size_read = (int)fread(buf,1,size_buf,fin); |
||||
if (size_read < size_buf) |
||||
if (feof(fin)==0) |
||||
{ |
||||
printf("error in reading %s\n",filenameinzip); |
||||
err = ZIP_ERRNO; |
||||
} |
||||
|
||||
if (size_read>0) |
||||
{ |
||||
err = zipWriteInFileInZip (zf,buf,size_read); |
||||
if (err<0) |
||||
{ |
||||
printf("error in writing %s in the zipfile\n", |
||||
filenameinzip); |
||||
} |
||||
|
||||
} |
||||
} while ((err == ZIP_OK) && (size_read>0)); |
||||
|
||||
if (fin) |
||||
fclose(fin); |
||||
|
||||
if (err<0) |
||||
err=ZIP_ERRNO; |
||||
else |
||||
{ |
||||
err = zipCloseFileInZip(zf); |
||||
if (err!=ZIP_OK) |
||||
printf("error in closing %s in the zipfile\n", |
||||
filenameinzip); |
||||
} |
||||
} |
||||
} |
||||
errclose = zipClose(zf,NULL); |
||||
if (errclose != ZIP_OK) |
||||
printf("error in closing %s\n",filename_try); |
||||
} |
||||
|
||||
free(buf); |
||||
return 0; |
||||
} |
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <string.h> |
||||
#include <time.h> |
||||
#include <errno.h> |
||||
#include <fcntl.h> |
||||
|
||||
#ifdef unix |
||||
# include <unistd.h> |
||||
# include <utime.h> |
||||
# include <sys/types.h> |
||||
# include <sys/stat.h> |
||||
#else |
||||
# include <direct.h> |
||||
# include <io.h> |
||||
#endif |
||||
|
||||
#include "zip.h" |
||||
|
||||
#ifdef WIN32 |
||||
#define USEWIN32IOAPI |
||||
#include "iowin32.h" |
||||
#endif |
||||
|
||||
|
||||
|
||||
#define WRITEBUFFERSIZE (16384) |
||||
#define MAXFILENAME (256) |
||||
|
||||
#ifdef WIN32 |
||||
uLong filetime(f, tmzip, dt) |
||||
char *f; /* name of file to get info on */ |
||||
tm_zip *tmzip; /* return value: access, modific. and creation times */ |
||||
uLong *dt; /* dostime */ |
||||
{ |
||||
int ret = 0; |
||||
{ |
||||
FILETIME ftLocal; |
||||
HANDLE hFind; |
||||
WIN32_FIND_DATA ff32; |
||||
|
||||
hFind = FindFirstFile(f,&ff32); |
||||
if (hFind != INVALID_HANDLE_VALUE) |
||||
{ |
||||
FileTimeToLocalFileTime(&(ff32.ftLastWriteTime),&ftLocal); |
||||
FileTimeToDosDateTime(&ftLocal,((LPWORD)dt)+1,((LPWORD)dt)+0); |
||||
FindClose(hFind); |
||||
ret = 1; |
||||
} |
||||
} |
||||
return ret; |
||||
} |
||||
#else |
||||
#ifdef unix |
||||
uLong filetime(f, tmzip, dt) |
||||
char *f; /* name of file to get info on */ |
||||
tm_zip *tmzip; /* return value: access, modific. and creation times */ |
||||
uLong *dt; /* dostime */ |
||||
{ |
||||
int ret=0; |
||||
struct stat s; /* results of stat() */ |
||||
struct tm* filedate; |
||||
time_t tm_t=0; |
||||
|
||||
if (strcmp(f,"-")!=0) |
||||
{ |
||||
char name[MAXFILENAME+1]; |
||||
int len = strlen(f); |
||||
|
||||
strncpy(name, f,MAXFILENAME-1); |
||||
/* strncpy doesnt append the trailing NULL, of the string is too long. */ |
||||
name[ MAXFILENAME ] = '\0'; |
||||
|
||||
if (name[len - 1] == '/') |
||||
name[len - 1] = '\0'; |
||||
/* not all systems allow stat'ing a file with / appended */ |
||||
if (stat(name,&s)==0) |
||||
{ |
||||
tm_t = s.st_mtime; |
||||
ret = 1; |
||||
} |
||||
} |
||||
filedate = localtime(&tm_t); |
||||
|
||||
tmzip->tm_sec = filedate->tm_sec; |
||||
tmzip->tm_min = filedate->tm_min; |
||||
tmzip->tm_hour = filedate->tm_hour; |
||||
tmzip->tm_mday = filedate->tm_mday; |
||||
tmzip->tm_mon = filedate->tm_mon ; |
||||
tmzip->tm_year = filedate->tm_year; |
||||
|
||||
return ret; |
||||
} |
||||
#else |
||||
uLong filetime(f, tmzip, dt) |
||||
char *f; /* name of file to get info on */ |
||||
tm_zip *tmzip; /* return value: access, modific. and creation times */ |
||||
uLong *dt; /* dostime */ |
||||
{ |
||||
return 0; |
||||
} |
||||
#endif |
||||
#endif |
||||
|
||||
|
||||
|
||||
|
||||
int check_exist_file(filename) |
||||
const char* filename; |
||||
{ |
||||
FILE* ftestexist; |
||||
int ret = 1; |
||||
ftestexist = fopen(filename,"rb"); |
||||
if (ftestexist==NULL) |
||||
ret = 0; |
||||
else |
||||
fclose(ftestexist); |
||||
return ret; |
||||
} |
||||
|
||||
void do_banner() |
||||
{ |
||||
printf("MiniZip 0.22, demo of zLib + Zip package written by Gilles Vollant\n"); |
||||
printf("more info at http://www.winimage.com/zLibDll/unzip.html\n\n"); |
||||
} |
||||
|
||||
void do_help() |
||||
{ |
||||
printf("Usage : minizip [-o] [-a] [-0 to -9] [-p password] file.zip [files_to_add]\n\n" \
|
||||
" -o Overwrite existing file.zip\n" \
|
||||
" -a Append to existing file.zip\n" \
|
||||
" -0 Store only\n" \
|
||||
" -1 Compress faster\n" \
|
||||
" -9 Compress better\n\n"); |
||||
} |
||||
|
||||
/* calculate the CRC32 of a file,
|
||||
because to encrypt a file, we need known the CRC32 of the file before */ |
||||
int getFileCrc(const char* filenameinzip,void*buf,unsigned long size_buf,unsigned long* result_crc) |
||||
{ |
||||
unsigned long calculate_crc=0; |
||||
int err=ZIP_OK; |
||||
FILE * fin = fopen(filenameinzip,"rb"); |
||||
unsigned long size_read = 0; |
||||
unsigned long total_read = 0; |
||||
if (fin==NULL) |
||||
{ |
||||
err = ZIP_ERRNO; |
||||
} |
||||
|
||||
if (err == ZIP_OK) |
||||
do |
||||
{ |
||||
err = ZIP_OK; |
||||
size_read = (int)fread(buf,1,size_buf,fin); |
||||
if (size_read < size_buf) |
||||
if (feof(fin)==0) |
||||
{ |
||||
printf("error in reading %s\n",filenameinzip); |
||||
err = ZIP_ERRNO; |
||||
} |
||||
|
||||
if (size_read>0) |
||||
calculate_crc = crc32(calculate_crc,buf,size_read); |
||||
total_read += size_read; |
||||
|
||||
} while ((err == ZIP_OK) && (size_read>0)); |
||||
|
||||
if (fin) |
||||
fclose(fin); |
||||
|
||||
*result_crc=calculate_crc; |
||||
printf("file %s crc %x\n",filenameinzip,calculate_crc); |
||||
return err; |
||||
} |
||||
|
||||
int main(argc,argv) |
||||
int argc; |
||||
char *argv[]; |
||||
{ |
||||
int i; |
||||
int opt_overwrite=0; |
||||
int opt_compress_level=Z_DEFAULT_COMPRESSION; |
||||
int zipfilenamearg = 0; |
||||
char filename_try[MAXFILENAME+16]; |
||||
int zipok; |
||||
int err=0; |
||||
int size_buf=0; |
||||
void* buf=NULL; |
||||
const char* password=NULL; |
||||
|
||||
|
||||
do_banner(); |
||||
if (argc==1) |
||||
{ |
||||
do_help(); |
||||
return 0; |
||||
} |
||||
else |
||||
{ |
||||
for (i=1;i<argc;i++) |
||||
{ |
||||
if ((*argv[i])=='-') |
||||
{ |
||||
const char *p=argv[i]+1; |
||||
|
||||
while ((*p)!='\0') |
||||
{ |
||||
char c=*(p++);; |
||||
if ((c=='o') || (c=='O')) |
||||
opt_overwrite = 1; |
||||
if ((c=='a') || (c=='A')) |
||||
opt_overwrite = 2; |
||||
if ((c>='0') && (c<='9')) |
||||
opt_compress_level = c-'0'; |
||||
|
||||
if (((c=='p') || (c=='P')) && (i+1<argc)) |
||||
{ |
||||
password=argv[i+1]; |
||||
i++; |
||||
} |
||||
} |
||||
} |
||||
else |
||||
if (zipfilenamearg == 0) |
||||
zipfilenamearg = i ; |
||||
} |
||||
} |
||||
|
||||
size_buf = WRITEBUFFERSIZE; |
||||
buf = (void*)malloc(size_buf); |
||||
if (buf==NULL) |
||||
{ |
||||
printf("Error allocating memory\n"); |
||||
return ZIP_INTERNALERROR; |
||||
} |
||||
|
||||
if (zipfilenamearg==0) |
||||
zipok=0; |
||||
else |
||||
{ |
||||
int i,len; |
||||
int dot_found=0; |
||||
|
||||
zipok = 1 ; |
||||
strncpy(filename_try, argv[zipfilenamearg],MAXFILENAME-1); |
||||
/* strncpy doesnt append the trailing NULL, of the string is too long. */ |
||||
filename_try[ MAXFILENAME ] = '\0'; |
||||
|
||||
len=(int)strlen(filename_try); |
||||
for (i=0;i<len;i++) |
||||
if (filename_try[i]=='.') |
||||
dot_found=1; |
||||
|
||||
if (dot_found==0) |
||||
strcat(filename_try,".zip"); |
||||
|
||||
if (opt_overwrite==2) |
||||
{ |
||||
/* if the file don't exist, we not append file */ |
||||
if (check_exist_file(filename_try)==0) |
||||
opt_overwrite=1; |
||||
} |
||||
else |
||||
if (opt_overwrite==0) |
||||
if (check_exist_file(filename_try)!=0) |
||||
{ |
||||
char rep=0; |
||||
do |
||||
{ |
||||
char answer[128]; |
||||
printf("The file %s exist. Overwrite ? [y]es, [n]o, [a]ppend : ",filename_try); |
||||
scanf("%1s",answer); |
||||
rep = answer[0] ; |
||||
if ((rep>='a') && (rep<='z')) |
||||
rep -= 0x20; |
||||
} |
||||
while ((rep!='Y') && (rep!='N') && (rep!='A')); |
||||
if (rep=='N') |
||||
zipok = 0; |
||||
if (rep=='A') |
||||
opt_overwrite = 2; |
||||
} |
||||
} |
||||
|
||||
if (zipok==1) |
||||
{ |
||||
zipFile zf; |
||||
int errclose; |
||||
# ifdef USEWIN32IOAPI |
||||
zlib_filefunc_def ffunc; |
||||
fill_win32_filefunc(&ffunc); |
||||
zf = zipOpen2(filename_try,(opt_overwrite==2) ? 2 : 0,NULL,&ffunc); |
||||
# else |
||||
zf = zipOpen(filename_try,(opt_overwrite==2) ? 2 : 0); |
||||
# endif |
||||
|
||||
if (zf == NULL) |
||||
{ |
||||
printf("error opening %s\n",filename_try); |
||||
err= ZIP_ERRNO; |
||||
} |
||||
else |
||||
printf("creating %s\n",filename_try); |
||||
|
||||
for (i=zipfilenamearg+1;(i<argc) && (err==ZIP_OK);i++) |
||||
{ |
||||
if (((*(argv[i]))!='-') && ((*(argv[i]))!='/')) |
||||
{ |
||||
FILE * fin; |
||||
int size_read; |
||||
const char* filenameinzip = argv[i]; |
||||
zip_fileinfo zi; |
||||
unsigned long crcFile=0; |
||||
|
||||
zi.tmz_date.tm_sec = zi.tmz_date.tm_min = zi.tmz_date.tm_hour = |
||||
zi.tmz_date.tm_mday = zi.tmz_date.tm_mon = zi.tmz_date.tm_year = 0; |
||||
zi.dosDate = 0; |
||||
zi.internal_fa = 0; |
||||
zi.external_fa = 0; |
||||
filetime(filenameinzip,&zi.tmz_date,&zi.dosDate); |
||||
|
||||
/*
|
||||
err = zipOpenNewFileInZip(zf,filenameinzip,&zi, |
||||
NULL,0,NULL,0,NULL / * comment * /, |
||||
(opt_compress_level != 0) ? Z_DEFLATED : 0, |
||||
opt_compress_level); |
||||
*/ |
||||
if ((password != NULL) && (err==ZIP_OK)) |
||||
err = getFileCrc(filenameinzip,buf,size_buf,&crcFile); |
||||
|
||||
err = zipOpenNewFileInZip3(zf,filenameinzip,&zi, |
||||
NULL,0,NULL,0,NULL /* comment*/, |
||||
(opt_compress_level != 0) ? Z_DEFLATED : 0, |
||||
opt_compress_level,0, |
||||
/* -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, */ |
||||
-MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, |
||||
password,crcFile); |
||||
|
||||
if (err != ZIP_OK) |
||||
printf("error in opening %s in zipfile\n",filenameinzip); |
||||
else |
||||
{ |
||||
fin = fopen(filenameinzip,"rb"); |
||||
if (fin==NULL) |
||||
{ |
||||
err=ZIP_ERRNO; |
||||
printf("error in opening %s for reading\n",filenameinzip); |
||||
} |
||||
} |
||||
|
||||
if (err == ZIP_OK) |
||||
do |
||||
{ |
||||
err = ZIP_OK; |
||||
size_read = (int)fread(buf,1,size_buf,fin); |
||||
if (size_read < size_buf) |
||||
if (feof(fin)==0) |
||||
{ |
||||
printf("error in reading %s\n",filenameinzip); |
||||
err = ZIP_ERRNO; |
||||
} |
||||
|
||||
if (size_read>0) |
||||
{ |
||||
err = zipWriteInFileInZip (zf,buf,size_read); |
||||
if (err<0) |
||||
{ |
||||
printf("error in writing %s in the zipfile\n", |
||||
filenameinzip); |
||||
} |
||||
|
||||
} |
||||
} while ((err == ZIP_OK) && (size_read>0)); |
||||
|
||||
if (fin) |
||||
fclose(fin); |
||||
|
||||
if (err<0) |
||||
err=ZIP_ERRNO; |
||||
else |
||||
{ |
||||
err = zipCloseFileInZip(zf); |
||||
if (err!=ZIP_OK) |
||||
printf("error in closing %s in the zipfile\n", |
||||
filenameinzip); |
||||
} |
||||
} |
||||
} |
||||
errclose = zipClose(zf,NULL); |
||||
if (errclose != ZIP_OK) |
||||
printf("error in closing %s\n",filename_try); |
||||
} |
||||
|
||||
free(buf); |
||||
return 0; |
||||
} |
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,342 +1,342 @@ |
||||
/* unzip.h -- IO for uncompress .zip files using zlib
|
||||
Version 0.22, May 19th, 2003 |
||||
|
||||
Copyright (C) 1998-2003 Gilles Vollant |
||||
|
||||
This unzip package allow extract file from .ZIP file, compatible with PKZip 2.04g |
||||
WinZip, InfoZip tools and compatible. |
||||
Encryption and multi volume ZipFile (span) are not supported. |
||||
Old compressions used by old PKZip 1.x are not supported |
||||
|
||||
|
||||
I WAIT FEEDBACK at mail info@winimage.com |
||||
Visit also http://www.winimage.com/zLibDll/unzip.htm for evolution
|
||||
|
||||
Condition of use and distribution are the same than zlib : |
||||
|
||||
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. |
||||
|
||||
|
||||
*/ |
||||
|
||||
/* for more info about .ZIP format, see
|
||||
http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip
|
||||
http://www.info-zip.org/pub/infozip/doc/
|
||||
PkWare has also a specification at : |
||||
ftp://ftp.pkware.com/probdesc.zip
|
||||
*/ |
||||
|
||||
#ifndef _unz_H |
||||
#define _unz_H |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
#ifndef _ZLIB_H |
||||
#include "zlib.h" |
||||
#endif |
||||
|
||||
#ifndef _ZLIBIOAPI_H |
||||
#include "ioapi.h" |
||||
#endif |
||||
|
||||
#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP) |
||||
/* like the STRICT of WIN32, we define a pointer that cannot be converted
|
||||
from (void*) without cast */ |
||||
typedef struct TagunzFile__ { int unused; } unzFile__; |
||||
typedef unzFile__ *unzFile; |
||||
#else |
||||
typedef voidp unzFile; |
||||
#endif |
||||
|
||||
|
||||
#define UNZ_OK (0) |
||||
#define UNZ_END_OF_LIST_OF_FILE (-100) |
||||
#define UNZ_ERRNO (Z_ERRNO) |
||||
#define UNZ_EOF (0) |
||||
#define UNZ_PARAMERROR (-102) |
||||
#define UNZ_BADZIPFILE (-103) |
||||
#define UNZ_INTERNALERROR (-104) |
||||
#define UNZ_CRCERROR (-105) |
||||
|
||||
/* tm_unz contain date/time info */ |
||||
typedef struct tm_unz_s |
||||
{ |
||||
uInt tm_sec; /* seconds after the minute - [0,59] */ |
||||
uInt tm_min; /* minutes after the hour - [0,59] */ |
||||
uInt tm_hour; /* hours since midnight - [0,23] */ |
||||
uInt tm_mday; /* day of the month - [1,31] */ |
||||
uInt tm_mon; /* months since January - [0,11] */ |
||||
uInt tm_year; /* years - [1980..2044] */ |
||||
} tm_unz; |
||||
|
||||
/* unz_global_info structure contain global data about the ZIPfile
|
||||
These data comes from the end of central dir */ |
||||
typedef struct unz_global_info_s |
||||
{ |
||||
uLong number_entry; /* total number of entries in
|
||||
the central dir on this disk */ |
||||
uLong size_comment; /* size of the global comment of the zipfile */ |
||||
} unz_global_info; |
||||
|
||||
|
||||
/* unz_file_info contain information about a file in the zipfile */ |
||||
typedef struct unz_file_info_s |
||||
{ |
||||
uLong version; /* version made by 2 bytes */ |
||||
uLong version_needed; /* version needed to extract 2 bytes */ |
||||
uLong flag; /* general purpose bit flag 2 bytes */ |
||||
uLong compression_method; /* compression method 2 bytes */ |
||||
uLong dosDate; /* last mod file date in Dos fmt 4 bytes */ |
||||
uLong crc; /* crc-32 4 bytes */ |
||||
uLong compressed_size; /* compressed size 4 bytes */ |
||||
uLong uncompressed_size; /* uncompressed size 4 bytes */ |
||||
uLong size_filename; /* filename length 2 bytes */ |
||||
uLong size_file_extra; /* extra field length 2 bytes */ |
||||
uLong size_file_comment; /* file comment length 2 bytes */ |
||||
|
||||
uLong disk_num_start; /* disk number start 2 bytes */ |
||||
uLong internal_fa; /* internal file attributes 2 bytes */ |
||||
uLong external_fa; /* external file attributes 4 bytes */ |
||||
|
||||
tm_unz tmu_date; |
||||
} unz_file_info; |
||||
|
||||
extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1, |
||||
const char* fileName2, |
||||
int iCaseSensitivity)); |
||||
/*
|
||||
Compare two filename (fileName1,fileName2). |
||||
If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp) |
||||
If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi |
||||
or strcasecmp) |
||||
If iCaseSenisivity = 0, case sensitivity is defaut of your operating system |
||||
(like 1 on Unix, 2 on Windows) |
||||
*/ |
||||
|
||||
|
||||
extern unzFile ZEXPORT unzOpen OF((const char *path)); |
||||
/*
|
||||
Open a Zip file. path contain the full pathname (by example, |
||||
on a Windows XP computer "c:\\zlib\\zlib113.zip" or on an Unix computer |
||||
"zlib/zlib113.zip". |
||||
If the zipfile cannot be opened (file don't exist or in not valid), the |
||||
return value is NULL. |
||||
Else, the return value is a unzFile Handle, usable with other function |
||||
of this unzip package. |
||||
*/ |
||||
|
||||
extern unzFile ZEXPORT unzOpen2 OF((const char *path, |
||||
zlib_filefunc_def* pzlib_filefunc_def)); |
||||
/*
|
||||
Open a Zip file, like unzOpen, but provide a set of file low level API |
||||
for read/write the zip file (see ioapi.h) |
||||
*/ |
||||
|
||||
extern int ZEXPORT unzClose OF((unzFile file)); |
||||
/*
|
||||
Close a ZipFile opened with unzipOpen. |
||||
If there is files inside the .Zip opened with unzOpenCurrentFile (see later), |
||||
these files MUST be closed with unzipCloseCurrentFile before call unzipClose. |
||||
return UNZ_OK if there is no problem. */ |
||||
|
||||
extern int ZEXPORT unzGetGlobalInfo OF((unzFile file, |
||||
unz_global_info *pglobal_info)); |
||||
/*
|
||||
Write info about the ZipFile in the *pglobal_info structure. |
||||
No preparation of the structure is needed |
||||
return UNZ_OK if there is no problem. */ |
||||
|
||||
|
||||
extern int ZEXPORT unzGetGlobalComment OF((unzFile file, |
||||
char *szComment, |
||||
uLong uSizeBuf)); |
||||
/*
|
||||
Get the global comment string of the ZipFile, in the szComment buffer. |
||||
uSizeBuf is the size of the szComment buffer. |
||||
return the number of byte copied or an error code <0 |
||||
*/ |
||||
|
||||
|
||||
/***************************************************************************/ |
||||
/* Unzip package allow you browse the directory of the zipfile */ |
||||
|
||||
extern int ZEXPORT unzGoToFirstFile OF((unzFile file)); |
||||
/*
|
||||
Set the current file of the zipfile to the first file. |
||||
return UNZ_OK if there is no problem |
||||
*/ |
||||
|
||||
extern int ZEXPORT unzGoToNextFile OF((unzFile file)); |
||||
/*
|
||||
Set the current file of the zipfile to the next file. |
||||
return UNZ_OK if there is no problem |
||||
return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest. |
||||
*/ |
||||
|
||||
extern int ZEXPORT unzLocateFile OF((unzFile file, |
||||
const char *szFileName, |
||||
int iCaseSensitivity)); |
||||
/*
|
||||
Try locate the file szFileName in the zipfile. |
||||
For the iCaseSensitivity signification, see unzStringFileNameCompare |
||||
|
||||
return value : |
||||
UNZ_OK if the file is found. It becomes the current file. |
||||
UNZ_END_OF_LIST_OF_FILE if the file is not found |
||||
*/ |
||||
|
||||
|
||||
/* ****************************************** */ |
||||
/* Ryan supplied functions */ |
||||
/* unz_file_info contain information about a file in the zipfile */ |
||||
typedef struct unz_file_pos_s |
||||
{ |
||||
uLong pos_in_zip_directory; /* offset in zip file directory */ |
||||
uLong num_of_file; /* # of file */ |
||||
} unz_file_pos; |
||||
|
||||
extern int ZEXPORT unzGetFilePos( |
||||
unzFile file, |
||||
unz_file_pos* file_pos); |
||||
|
||||
extern int ZEXPORT unzGoToFilePos( |
||||
unzFile file, |
||||
unz_file_pos* file_pos); |
||||
|
||||
/* ****************************************** */ |
||||
|
||||
extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file, |
||||
unz_file_info *pfile_info, |
||||
char *szFileName, |
||||
uLong fileNameBufferSize, |
||||
void *extraField, |
||||
uLong extraFieldBufferSize, |
||||
char *szComment, |
||||
uLong commentBufferSize)); |
||||
/*
|
||||
Get Info about the current file |
||||
if pfile_info!=NULL, the *pfile_info structure will contain somes info about |
||||
the current file |
||||
if szFileName!=NULL, the filemane string will be copied in szFileName |
||||
(fileNameBufferSize is the size of the buffer) |
||||
if extraField!=NULL, the extra field information will be copied in extraField |
||||
(extraFieldBufferSize is the size of the buffer). |
||||
This is the Central-header version of the extra field |
||||
if szComment!=NULL, the comment string of the file will be copied in szComment |
||||
(commentBufferSize is the size of the buffer) |
||||
*/ |
||||
|
||||
/***************************************************************************/ |
||||
/* for reading the content of the current zipfile, you can open it, read data
|
||||
from it, and close it (you can close it before reading all the file) |
||||
*/ |
||||
|
||||
extern int ZEXPORT unzOpenCurrentFile OF((unzFile file)); |
||||
/*
|
||||
Open for reading data the current file in the zipfile. |
||||
If there is no error, the return value is UNZ_OK. |
||||
*/ |
||||
|
||||
extern int ZEXPORT unzOpenCurrentFilePassword OF((unzFile file, |
||||
const char* password)); |
||||
/*
|
||||
Open for reading data the current file in the zipfile. |
||||
password is a crypting password |
||||
If there is no error, the return value is UNZ_OK. |
||||
*/ |
||||
|
||||
extern int ZEXPORT unzOpenCurrentFile2 OF((unzFile file, |
||||
int* method, |
||||
int* level, |
||||
int raw)); |
||||
/*
|
||||
Same than unzOpenCurrentFile, but open for read raw the file (not uncompress) |
||||
if raw==1 |
||||
*method will receive method of compression, *level will receive level of |
||||
compression |
||||
note : you can set level parameter as NULL (if you did not want known level, |
||||
but you CANNOT set method parameter as NULL |
||||
*/ |
||||
|
||||
extern int ZEXPORT unzOpenCurrentFile3 OF((unzFile file, |
||||
int* method, |
||||
int* level, |
||||
int raw, |
||||
const char* password)); |
||||
/*
|
||||
Same than unzOpenCurrentFile, but open for read raw the file (not uncompress) |
||||
if raw==1 |
||||
*method will receive method of compression, *level will receive level of |
||||
compression |
||||
note : you can set level parameter as NULL (if you did not want known level, |
||||
but you CANNOT set method parameter as NULL |
||||
*/ |
||||
|
||||
|
||||
extern int ZEXPORT unzCloseCurrentFile OF((unzFile file)); |
||||
/*
|
||||
Close the file in zip opened with unzOpenCurrentFile |
||||
Return UNZ_CRCERROR if all the file was read but the CRC is not good |
||||
*/ |
||||
|
||||
extern int ZEXPORT unzReadCurrentFile OF((unzFile file, |
||||
voidp buf, |
||||
unsigned len)); |
||||
/*
|
||||
Read bytes from the current file (opened by unzOpenCurrentFile) |
||||
buf contain buffer where data must be copied |
||||
len the size of buf. |
||||
|
||||
return the number of byte copied if somes bytes are copied |
||||
return 0 if the end of file was reached |
||||
return <0 with error code if there is an error |
||||
(UNZ_ERRNO for IO error, or zLib error for uncompress error) |
||||
*/ |
||||
|
||||
extern z_off_t ZEXPORT unztell OF((unzFile file)); |
||||
/*
|
||||
Give the current position in uncompressed data |
||||
*/ |
||||
|
||||
extern int ZEXPORT unzeof OF((unzFile file)); |
||||
/*
|
||||
return 1 if the end of file was reached, 0 elsewhere |
||||
*/ |
||||
|
||||
extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file, |
||||
voidp buf, |
||||
unsigned len)); |
||||
/*
|
||||
Read extra field from the current file (opened by unzOpenCurrentFile) |
||||
This is the local-header version of the extra field (sometimes, there is |
||||
more info in the local-header version than in the central-header) |
||||
|
||||
if buf==NULL, it return the size of the local extra field |
||||
|
||||
if buf!=NULL, len is the size of the buffer, the extra header is copied in |
||||
buf. |
||||
the return value is the number of bytes copied in buf, or (if <0) |
||||
the error code |
||||
*/ |
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
|
||||
#endif /* _unz_H */ |
||||
/* unzip.h -- IO for uncompress .zip files using zlib
|
||||
Version 0.22, May 19th, 2003 |
||||
|
||||
Copyright (C) 1998-2003 Gilles Vollant |
||||
|
||||
This unzip package allow extract file from .ZIP file, compatible with PKZip 2.04g |
||||
WinZip, InfoZip tools and compatible. |
||||
Encryption and multi volume ZipFile (span) are not supported. |
||||
Old compressions used by old PKZip 1.x are not supported |
||||
|
||||
|
||||
I WAIT FEEDBACK at mail info@winimage.com |
||||
Visit also http://www.winimage.com/zLibDll/unzip.htm for evolution
|
||||
|
||||
Condition of use and distribution are the same than zlib : |
||||
|
||||
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. |
||||
|
||||
|
||||
*/ |
||||
|
||||
/* for more info about .ZIP format, see
|
||||
http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip
|
||||
http://www.info-zip.org/pub/infozip/doc/
|
||||
PkWare has also a specification at : |
||||
ftp://ftp.pkware.com/probdesc.zip
|
||||
*/ |
||||
|
||||
#ifndef _unz_H |
||||
#define _unz_H |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
#ifndef _ZLIB_H |
||||
#include "zlib.h" |
||||
#endif |
||||
|
||||
#ifndef _ZLIBIOAPI_H |
||||
#include "ioapi.h" |
||||
#endif |
||||
|
||||
#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP) |
||||
/* like the STRICT of WIN32, we define a pointer that cannot be converted
|
||||
from (void*) without cast */ |
||||
typedef struct TagunzFile__ { int unused; } unzFile__; |
||||
typedef unzFile__ *unzFile; |
||||
#else |
||||
typedef voidp unzFile; |
||||
#endif |
||||
|
||||
|
||||
#define UNZ_OK (0) |
||||
#define UNZ_END_OF_LIST_OF_FILE (-100) |
||||
#define UNZ_ERRNO (Z_ERRNO) |
||||
#define UNZ_EOF (0) |
||||
#define UNZ_PARAMERROR (-102) |
||||
#define UNZ_BADZIPFILE (-103) |
||||
#define UNZ_INTERNALERROR (-104) |
||||
#define UNZ_CRCERROR (-105) |
||||
|
||||
/* tm_unz contain date/time info */ |
||||
typedef struct tm_unz_s |
||||
{ |
||||
uInt tm_sec; /* seconds after the minute - [0,59] */ |
||||
uInt tm_min; /* minutes after the hour - [0,59] */ |
||||
uInt tm_hour; /* hours since midnight - [0,23] */ |
||||
uInt tm_mday; /* day of the month - [1,31] */ |
||||
uInt tm_mon; /* months since January - [0,11] */ |
||||
uInt tm_year; /* years - [1980..2044] */ |
||||
} tm_unz; |
||||
|
||||
/* unz_global_info structure contain global data about the ZIPfile
|
||||
These data comes from the end of central dir */ |
||||
typedef struct unz_global_info_s |
||||
{ |
||||
uLong number_entry; /* total number of entries in
|
||||
the central dir on this disk */ |
||||
uLong size_comment; /* size of the global comment of the zipfile */ |
||||
} unz_global_info; |
||||
|
||||
|
||||
/* unz_file_info contain information about a file in the zipfile */ |
||||
typedef struct unz_file_info_s |
||||
{ |
||||
uLong version; /* version made by 2 bytes */ |
||||
uLong version_needed; /* version needed to extract 2 bytes */ |
||||
uLong flag; /* general purpose bit flag 2 bytes */ |
||||
uLong compression_method; /* compression method 2 bytes */ |
||||
uLong dosDate; /* last mod file date in Dos fmt 4 bytes */ |
||||
uLong crc; /* crc-32 4 bytes */ |
||||
uLong compressed_size; /* compressed size 4 bytes */ |
||||
uLong uncompressed_size; /* uncompressed size 4 bytes */ |
||||
uLong size_filename; /* filename length 2 bytes */ |
||||
uLong size_file_extra; /* extra field length 2 bytes */ |
||||
uLong size_file_comment; /* file comment length 2 bytes */ |
||||
|
||||
uLong disk_num_start; /* disk number start 2 bytes */ |
||||
uLong internal_fa; /* internal file attributes 2 bytes */ |
||||
uLong external_fa; /* external file attributes 4 bytes */ |
||||
|
||||
tm_unz tmu_date; |
||||
} unz_file_info; |
||||
|
||||
extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1, |
||||
const char* fileName2, |
||||
int iCaseSensitivity)); |
||||
/*
|
||||
Compare two filename (fileName1,fileName2). |
||||
If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp) |
||||
If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi |
||||
or strcasecmp) |
||||
If iCaseSenisivity = 0, case sensitivity is defaut of your operating system |
||||
(like 1 on Unix, 2 on Windows) |
||||
*/ |
||||
|
||||
|
||||
extern unzFile ZEXPORT unzOpen OF((const char *path)); |
||||
/*
|
||||
Open a Zip file. path contain the full pathname (by example, |
||||
on a Windows XP computer "c:\\zlib\\zlib113.zip" or on an Unix computer |
||||
"zlib/zlib113.zip". |
||||
If the zipfile cannot be opened (file don't exist or in not valid), the |
||||
return value is NULL. |
||||
Else, the return value is a unzFile Handle, usable with other function |
||||
of this unzip package. |
||||
*/ |
||||
|
||||
extern unzFile ZEXPORT unzOpen2 OF((const char *path, |
||||
zlib_filefunc_def* pzlib_filefunc_def)); |
||||
/*
|
||||
Open a Zip file, like unzOpen, but provide a set of file low level API |
||||
for read/write the zip file (see ioapi.h) |
||||
*/ |
||||
|
||||
extern int ZEXPORT unzClose OF((unzFile file)); |
||||
/*
|
||||
Close a ZipFile opened with unzipOpen. |
||||
If there is files inside the .Zip opened with unzOpenCurrentFile (see later), |
||||
these files MUST be closed with unzipCloseCurrentFile before call unzipClose. |
||||
return UNZ_OK if there is no problem. */ |
||||
|
||||
extern int ZEXPORT unzGetGlobalInfo OF((unzFile file, |
||||
unz_global_info *pglobal_info)); |
||||
/*
|
||||
Write info about the ZipFile in the *pglobal_info structure. |
||||
No preparation of the structure is needed |
||||
return UNZ_OK if there is no problem. */ |
||||
|
||||
|
||||
extern int ZEXPORT unzGetGlobalComment OF((unzFile file, |
||||
char *szComment, |
||||
uLong uSizeBuf)); |
||||
/*
|
||||
Get the global comment string of the ZipFile, in the szComment buffer. |
||||
uSizeBuf is the size of the szComment buffer. |
||||
return the number of byte copied or an error code <0 |
||||
*/ |
||||
|
||||
|
||||
/***************************************************************************/ |
||||
/* Unzip package allow you browse the directory of the zipfile */ |
||||
|
||||
extern int ZEXPORT unzGoToFirstFile OF((unzFile file)); |
||||
/*
|
||||
Set the current file of the zipfile to the first file. |
||||
return UNZ_OK if there is no problem |
||||
*/ |
||||
|
||||
extern int ZEXPORT unzGoToNextFile OF((unzFile file)); |
||||
/*
|
||||
Set the current file of the zipfile to the next file. |
||||
return UNZ_OK if there is no problem |
||||
return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest. |
||||
*/ |
||||
|
||||
extern int ZEXPORT unzLocateFile OF((unzFile file, |
||||
const char *szFileName, |
||||
int iCaseSensitivity)); |
||||
/*
|
||||
Try locate the file szFileName in the zipfile. |
||||
For the iCaseSensitivity signification, see unzStringFileNameCompare |
||||
|
||||
return value : |
||||
UNZ_OK if the file is found. It becomes the current file. |
||||
UNZ_END_OF_LIST_OF_FILE if the file is not found |
||||
*/ |
||||
|
||||
|
||||
/* ****************************************** */ |
||||
/* Ryan supplied functions */ |
||||
/* unz_file_info contain information about a file in the zipfile */ |
||||
typedef struct unz_file_pos_s |
||||
{ |
||||
uLong pos_in_zip_directory; /* offset in zip file directory */ |
||||
uLong num_of_file; /* # of file */ |
||||
} unz_file_pos; |
||||
|
||||
extern int ZEXPORT unzGetFilePos( |
||||
unzFile file, |
||||
unz_file_pos* file_pos); |
||||
|
||||
extern int ZEXPORT unzGoToFilePos( |
||||
unzFile file, |
||||
unz_file_pos* file_pos); |
||||
|
||||
/* ****************************************** */ |
||||
|
||||
extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file, |
||||
unz_file_info *pfile_info, |
||||
char *szFileName, |
||||
uLong fileNameBufferSize, |
||||
void *extraField, |
||||
uLong extraFieldBufferSize, |
||||
char *szComment, |
||||
uLong commentBufferSize)); |
||||
/*
|
||||
Get Info about the current file |
||||
if pfile_info!=NULL, the *pfile_info structure will contain somes info about |
||||
the current file |
||||
if szFileName!=NULL, the filemane string will be copied in szFileName |
||||
(fileNameBufferSize is the size of the buffer) |
||||
if extraField!=NULL, the extra field information will be copied in extraField |
||||
(extraFieldBufferSize is the size of the buffer). |
||||
This is the Central-header version of the extra field |
||||
if szComment!=NULL, the comment string of the file will be copied in szComment |
||||
(commentBufferSize is the size of the buffer) |
||||
*/ |
||||
|
||||
/***************************************************************************/ |
||||
/* for reading the content of the current zipfile, you can open it, read data
|
||||
from it, and close it (you can close it before reading all the file) |
||||
*/ |
||||
|
||||
extern int ZEXPORT unzOpenCurrentFile OF((unzFile file)); |
||||
/*
|
||||
Open for reading data the current file in the zipfile. |
||||
If there is no error, the return value is UNZ_OK. |
||||
*/ |
||||
|
||||
extern int ZEXPORT unzOpenCurrentFilePassword OF((unzFile file, |
||||
const char* password)); |
||||
/*
|
||||
Open for reading data the current file in the zipfile. |
||||
password is a crypting password |
||||
If there is no error, the return value is UNZ_OK. |
||||
*/ |
||||
|
||||
extern int ZEXPORT unzOpenCurrentFile2 OF((unzFile file, |
||||
int* method, |
||||
int* level, |
||||
int raw)); |
||||
/*
|
||||
Same than unzOpenCurrentFile, but open for read raw the file (not uncompress) |
||||
if raw==1 |
||||
*method will receive method of compression, *level will receive level of |
||||
compression |
||||
note : you can set level parameter as NULL (if you did not want known level, |
||||
but you CANNOT set method parameter as NULL |
||||
*/ |
||||
|
||||
extern int ZEXPORT unzOpenCurrentFile3 OF((unzFile file, |
||||
int* method, |
||||
int* level, |
||||
int raw, |
||||
const char* password)); |
||||
/*
|
||||
Same than unzOpenCurrentFile, but open for read raw the file (not uncompress) |
||||
if raw==1 |
||||
*method will receive method of compression, *level will receive level of |
||||
compression |
||||
note : you can set level parameter as NULL (if you did not want known level, |
||||
but you CANNOT set method parameter as NULL |
||||
*/ |
||||
|
||||
|
||||
extern int ZEXPORT unzCloseCurrentFile OF((unzFile file)); |
||||
/*
|
||||
Close the file in zip opened with unzOpenCurrentFile |
||||
Return UNZ_CRCERROR if all the file was read but the CRC is not good |
||||
*/ |
||||
|
||||
extern int ZEXPORT unzReadCurrentFile OF((unzFile file, |
||||
voidp buf, |
||||
unsigned len)); |
||||
/*
|
||||
Read bytes from the current file (opened by unzOpenCurrentFile) |
||||
buf contain buffer where data must be copied |
||||
len the size of buf. |
||||
|
||||
return the number of byte copied if somes bytes are copied |
||||
return 0 if the end of file was reached |
||||
return <0 with error code if there is an error |
||||
(UNZ_ERRNO for IO error, or zLib error for uncompress error) |
||||
*/ |
||||
|
||||
extern z_off_t ZEXPORT unztell OF((unzFile file)); |
||||
/*
|
||||
Give the current position in uncompressed data |
||||
*/ |
||||
|
||||
extern int ZEXPORT unzeof OF((unzFile file)); |
||||
/*
|
||||
return 1 if the end of file was reached, 0 elsewhere |
||||
*/ |
||||
|
||||
extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file, |
||||
voidp buf, |
||||
unsigned len)); |
||||
/*
|
||||
Read extra field from the current file (opened by unzOpenCurrentFile) |
||||
This is the local-header version of the extra field (sometimes, there is |
||||
more info in the local-header version than in the central-header) |
||||
|
||||
if buf==NULL, it return the size of the local extra field |
||||
|
||||
if buf!=NULL, len is the size of the buffer, the extra header is copied in |
||||
buf. |
||||
the return value is the number of bytes copied in buf, or (if <0) |
||||
the error code |
||||
*/ |
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
|
||||
#endif /* _unz_H */ |
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,235 +1,235 @@ |
||||
/* zip.h -- IO for compress .zip files using zlib
|
||||
Version 0.22, May 19th, 2003 |
||||
|
||||
Copyright (C) 1998-2003 Gilles Vollant |
||||
|
||||
This unzip package allow creates .ZIP file, compatible with PKZip 2.04g |
||||
WinZip, InfoZip tools and compatible. |
||||
Encryption and multi volume ZipFile (span) are not supported. |
||||
Old compressions used by old PKZip 1.x are not supported |
||||
|
||||
For uncompress .zip file, look at unzip.h |
||||
|
||||
|
||||
I WAIT FEEDBACK at mail info@winimage.com |
||||
Visit also http://www.winimage.com/zLibDll/unzip.html for evolution
|
||||
|
||||
Condition of use and distribution are the same than zlib : |
||||
|
||||
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. |
||||
|
||||
|
||||
*/ |
||||
|
||||
/* for more info about .ZIP format, see
|
||||
http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip
|
||||
http://www.info-zip.org/pub/infozip/doc/
|
||||
PkWare has also a specification at : |
||||
ftp://ftp.pkware.com/probdesc.zip
|
||||
*/ |
||||
|
||||
#ifndef _zip_H |
||||
#define _zip_H |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
#ifndef _ZLIB_H |
||||
#include "zlib.h" |
||||
#endif |
||||
|
||||
#ifndef _ZLIBIOAPI_H |
||||
#include "ioapi.h" |
||||
#endif |
||||
|
||||
#if defined(STRICTZIP) || defined(STRICTZIPUNZIP) |
||||
/* like the STRICT of WIN32, we define a pointer that cannot be converted
|
||||
from (void*) without cast */ |
||||
typedef struct TagzipFile__ { int unused; } zipFile__; |
||||
typedef zipFile__ *zipFile; |
||||
#else |
||||
typedef voidp zipFile; |
||||
#endif |
||||
|
||||
#define ZIP_OK (0) |
||||
#define ZIP_EOF (0) |
||||
#define ZIP_ERRNO (Z_ERRNO) |
||||
#define ZIP_PARAMERROR (-102) |
||||
#define ZIP_BADZIPFILE (-103) |
||||
#define ZIP_INTERNALERROR (-104) |
||||
|
||||
#ifndef DEF_MEM_LEVEL |
||||
# if MAX_MEM_LEVEL >= 8 |
||||
# define DEF_MEM_LEVEL 8 |
||||
# else |
||||
# define DEF_MEM_LEVEL MAX_MEM_LEVEL |
||||
# endif |
||||
#endif |
||||
/* default memLevel */ |
||||
|
||||
/* tm_zip contain date/time info */ |
||||
typedef struct tm_zip_s |
||||
{ |
||||
uInt tm_sec; /* seconds after the minute - [0,59] */ |
||||
uInt tm_min; /* minutes after the hour - [0,59] */ |
||||
uInt tm_hour; /* hours since midnight - [0,23] */ |
||||
uInt tm_mday; /* day of the month - [1,31] */ |
||||
uInt tm_mon; /* months since January - [0,11] */ |
||||
uInt tm_year; /* years - [1980..2044] */ |
||||
} tm_zip; |
||||
|
||||
typedef struct |
||||
{ |
||||
tm_zip tmz_date; /* date in understandable format */ |
||||
uLong dosDate; /* if dos_date == 0, tmu_date is used */ |
||||
/* uLong flag; */ /* general purpose bit flag 2 bytes */ |
||||
|
||||
uLong internal_fa; /* internal file attributes 2 bytes */ |
||||
uLong external_fa; /* external file attributes 4 bytes */ |
||||
} zip_fileinfo; |
||||
|
||||
typedef const char* zipcharpc; |
||||
|
||||
|
||||
#define APPEND_STATUS_CREATE (0) |
||||
#define APPEND_STATUS_CREATEAFTER (1) |
||||
#define APPEND_STATUS_ADDINZIP (2) |
||||
|
||||
extern zipFile ZEXPORT zipOpen OF((const char *pathname, int append)); |
||||
/*
|
||||
Create a zipfile. |
||||
pathname contain on Windows XP a filename like "c:\\zlib\\zlib113.zip" or on |
||||
an Unix computer "zlib/zlib113.zip". |
||||
if the file pathname exist and append==APPEND_STATUS_CREATEAFTER, the zip |
||||
will be created at the end of the file. |
||||
(useful if the file contain a self extractor code) |
||||
if the file pathname exist and append==APPEND_STATUS_ADDINZIP, we will |
||||
add files in existing zip (be sure you don't add file that doesn't exist) |
||||
If the zipfile cannot be opened, the return value is NULL. |
||||
Else, the return value is a zipFile Handle, usable with other function |
||||
of this zip package. |
||||
*/ |
||||
|
||||
/* Note : there is no delete function into a zipfile.
|
||||
If you want delete file into a zipfile, you must open a zipfile, and create another |
||||
Of couse, you can use RAW reading and writing to copy the file you did not want delte |
||||
*/ |
||||
|
||||
extern zipFile ZEXPORT zipOpen2 OF((const char *pathname, |
||||
int append, |
||||
zipcharpc* globalcomment, |
||||
zlib_filefunc_def* pzlib_filefunc_def)); |
||||
|
||||
extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file, |
||||
const char* filename, |
||||
const zip_fileinfo* zipfi, |
||||
const void* extrafield_local, |
||||
uInt size_extrafield_local, |
||||
const void* extrafield_global, |
||||
uInt size_extrafield_global, |
||||
const char* comment, |
||||
int method, |
||||
int level)); |
||||
/*
|
||||
Open a file in the ZIP for writing. |
||||
filename : the filename in zip (if NULL, '-' without quote will be used |
||||
*zipfi contain supplemental information |
||||
if extrafield_local!=NULL and size_extrafield_local>0, extrafield_local |
||||
contains the extrafield data the the local header |
||||
if extrafield_global!=NULL and size_extrafield_global>0, extrafield_global |
||||
contains the extrafield data the the local header |
||||
if comment != NULL, comment contain the comment string |
||||
method contain the compression method (0 for store, Z_DEFLATED for deflate) |
||||
level contain the level of compression (can be Z_DEFAULT_COMPRESSION) |
||||
*/ |
||||
|
||||
|
||||
extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file, |
||||
const char* filename, |
||||
const zip_fileinfo* zipfi, |
||||
const void* extrafield_local, |
||||
uInt size_extrafield_local, |
||||
const void* extrafield_global, |
||||
uInt size_extrafield_global, |
||||
const char* comment, |
||||
int method, |
||||
int level, |
||||
int raw)); |
||||
|
||||
/*
|
||||
Same than zipOpenNewFileInZip, except if raw=1, we write raw file |
||||
*/ |
||||
|
||||
extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file, |
||||
const char* filename, |
||||
const zip_fileinfo* zipfi, |
||||
const void* extrafield_local, |
||||
uInt size_extrafield_local, |
||||
const void* extrafield_global, |
||||
uInt size_extrafield_global, |
||||
const char* comment, |
||||
int method, |
||||
int level, |
||||
int raw, |
||||
int windowBits, |
||||
int memLevel, |
||||
int strategy, |
||||
const char* password, |
||||
uLong crcForCtypting)); |
||||
|
||||
/*
|
||||
Same than zipOpenNewFileInZip2, except |
||||
windowBits,memLevel,,strategy : see parameter strategy in deflateInit2 |
||||
password : crypting password (NULL for no crypting) |
||||
crcForCtypting : crc of file to compress (needed for crypting) |
||||
*/ |
||||
|
||||
|
||||
extern int ZEXPORT zipWriteInFileInZip OF((zipFile file, |
||||
const void* buf, |
||||
unsigned len)); |
||||
/*
|
||||
Write data in the zipfile |
||||
*/ |
||||
|
||||
extern int ZEXPORT zipCloseFileInZip OF((zipFile file)); |
||||
/*
|
||||
Close the current file in the zipfile |
||||
*/ |
||||
|
||||
|
||||
extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file, |
||||
uLong uncompressed_size, |
||||
uLong crc32)); |
||||
/*
|
||||
Close the current file in the zipfile, for fiel opened with |
||||
parameter raw=1 in zipOpenNewFileInZip2 |
||||
uncompressed_size and crc32 are value for the uncompressed size |
||||
*/ |
||||
|
||||
extern int ZEXPORT zipClose OF((zipFile file, |
||||
const char* global_comment)); |
||||
/*
|
||||
Close the zipfile |
||||
*/ |
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
|
||||
#endif /* _zip_H */ |
||||
/* zip.h -- IO for compress .zip files using zlib
|
||||
Version 0.22, May 19th, 2003 |
||||
|
||||
Copyright (C) 1998-2003 Gilles Vollant |
||||
|
||||
This unzip package allow creates .ZIP file, compatible with PKZip 2.04g |
||||
WinZip, InfoZip tools and compatible. |
||||
Encryption and multi volume ZipFile (span) are not supported. |
||||
Old compressions used by old PKZip 1.x are not supported |
||||
|
||||
For uncompress .zip file, look at unzip.h |
||||
|
||||
|
||||
I WAIT FEEDBACK at mail info@winimage.com |
||||
Visit also http://www.winimage.com/zLibDll/unzip.html for evolution
|
||||
|
||||
Condition of use and distribution are the same than zlib : |
||||
|
||||
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. |
||||
|
||||
|
||||
*/ |
||||
|
||||
/* for more info about .ZIP format, see
|
||||
http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip
|
||||
http://www.info-zip.org/pub/infozip/doc/
|
||||
PkWare has also a specification at : |
||||
ftp://ftp.pkware.com/probdesc.zip
|
||||
*/ |
||||
|
||||
#ifndef _zip_H |
||||
#define _zip_H |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
#ifndef _ZLIB_H |
||||
#include "zlib.h" |
||||
#endif |
||||
|
||||
#ifndef _ZLIBIOAPI_H |
||||
#include "ioapi.h" |
||||
#endif |
||||
|
||||
#if defined(STRICTZIP) || defined(STRICTZIPUNZIP) |
||||
/* like the STRICT of WIN32, we define a pointer that cannot be converted
|
||||
from (void*) without cast */ |
||||
typedef struct TagzipFile__ { int unused; } zipFile__; |
||||
typedef zipFile__ *zipFile; |
||||
#else |
||||
typedef voidp zipFile; |
||||
#endif |
||||
|
||||
#define ZIP_OK (0) |
||||
#define ZIP_EOF (0) |
||||
#define ZIP_ERRNO (Z_ERRNO) |
||||
#define ZIP_PARAMERROR (-102) |
||||
#define ZIP_BADZIPFILE (-103) |
||||
#define ZIP_INTERNALERROR (-104) |
||||
|
||||
#ifndef DEF_MEM_LEVEL |
||||
# if MAX_MEM_LEVEL >= 8 |
||||
# define DEF_MEM_LEVEL 8 |
||||
# else |
||||
# define DEF_MEM_LEVEL MAX_MEM_LEVEL |
||||
# endif |
||||
#endif |
||||
/* default memLevel */ |
||||
|
||||
/* tm_zip contain date/time info */ |
||||
typedef struct tm_zip_s |
||||
{ |
||||
uInt tm_sec; /* seconds after the minute - [0,59] */ |
||||
uInt tm_min; /* minutes after the hour - [0,59] */ |
||||
uInt tm_hour; /* hours since midnight - [0,23] */ |
||||
uInt tm_mday; /* day of the month - [1,31] */ |
||||
uInt tm_mon; /* months since January - [0,11] */ |
||||
uInt tm_year; /* years - [1980..2044] */ |
||||
} tm_zip; |
||||
|
||||
typedef struct |
||||
{ |
||||
tm_zip tmz_date; /* date in understandable format */ |
||||
uLong dosDate; /* if dos_date == 0, tmu_date is used */ |
||||
/* uLong flag; */ /* general purpose bit flag 2 bytes */ |
||||
|
||||
uLong internal_fa; /* internal file attributes 2 bytes */ |
||||
uLong external_fa; /* external file attributes 4 bytes */ |
||||
} zip_fileinfo; |
||||
|
||||
typedef const char* zipcharpc; |
||||
|
||||
|
||||
#define APPEND_STATUS_CREATE (0) |
||||
#define APPEND_STATUS_CREATEAFTER (1) |
||||
#define APPEND_STATUS_ADDINZIP (2) |
||||
|
||||
extern zipFile ZEXPORT zipOpen OF((const char *pathname, int append)); |
||||
/*
|
||||
Create a zipfile. |
||||
pathname contain on Windows XP a filename like "c:\\zlib\\zlib113.zip" or on |
||||
an Unix computer "zlib/zlib113.zip". |
||||
if the file pathname exist and append==APPEND_STATUS_CREATEAFTER, the zip |
||||
will be created at the end of the file. |
||||
(useful if the file contain a self extractor code) |
||||
if the file pathname exist and append==APPEND_STATUS_ADDINZIP, we will |
||||
add files in existing zip (be sure you don't add file that doesn't exist) |
||||
If the zipfile cannot be opened, the return value is NULL. |
||||
Else, the return value is a zipFile Handle, usable with other function |
||||
of this zip package. |
||||
*/ |
||||
|
||||
/* Note : there is no delete function into a zipfile.
|
||||
If you want delete file into a zipfile, you must open a zipfile, and create another |
||||
Of couse, you can use RAW reading and writing to copy the file you did not want delte |
||||
*/ |
||||
|
||||
extern zipFile ZEXPORT zipOpen2 OF((const char *pathname, |
||||
int append, |
||||
zipcharpc* globalcomment, |
||||
zlib_filefunc_def* pzlib_filefunc_def)); |
||||
|
||||
extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file, |
||||
const char* filename, |
||||
const zip_fileinfo* zipfi, |
||||
const void* extrafield_local, |
||||
uInt size_extrafield_local, |
||||
const void* extrafield_global, |
||||
uInt size_extrafield_global, |
||||
const char* comment, |
||||
int method, |
||||
int level)); |
||||
/*
|
||||
Open a file in the ZIP for writing. |
||||
filename : the filename in zip (if NULL, '-' without quote will be used |
||||
*zipfi contain supplemental information |
||||
if extrafield_local!=NULL and size_extrafield_local>0, extrafield_local |
||||
contains the extrafield data the the local header |
||||
if extrafield_global!=NULL and size_extrafield_global>0, extrafield_global |
||||
contains the extrafield data the the local header |
||||
if comment != NULL, comment contain the comment string |
||||
method contain the compression method (0 for store, Z_DEFLATED for deflate) |
||||
level contain the level of compression (can be Z_DEFAULT_COMPRESSION) |
||||
*/ |
||||
|
||||
|
||||
extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file, |
||||
const char* filename, |
||||
const zip_fileinfo* zipfi, |
||||
const void* extrafield_local, |
||||
uInt size_extrafield_local, |
||||
const void* extrafield_global, |
||||
uInt size_extrafield_global, |
||||
const char* comment, |
||||
int method, |
||||
int level, |
||||
int raw)); |
||||
|
||||
/*
|
||||
Same than zipOpenNewFileInZip, except if raw=1, we write raw file |
||||
*/ |
||||
|
||||
extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file, |
||||
const char* filename, |
||||
const zip_fileinfo* zipfi, |
||||
const void* extrafield_local, |
||||
uInt size_extrafield_local, |
||||
const void* extrafield_global, |
||||
uInt size_extrafield_global, |
||||
const char* comment, |
||||
int method, |
||||
int level, |
||||
int raw, |
||||
int windowBits, |
||||
int memLevel, |
||||
int strategy, |
||||
const char* password, |
||||
uLong crcForCtypting)); |
||||
|
||||
/*
|
||||
Same than zipOpenNewFileInZip2, except |
||||
windowBits,memLevel,,strategy : see parameter strategy in deflateInit2 |
||||
password : crypting password (NULL for no crypting) |
||||
crcForCtypting : crc of file to compress (needed for crypting) |
||||
*/ |
||||
|
||||
|
||||
extern int ZEXPORT zipWriteInFileInZip OF((zipFile file, |
||||
const void* buf, |
||||
unsigned len)); |
||||
/*
|
||||
Write data in the zipfile |
||||
*/ |
||||
|
||||
extern int ZEXPORT zipCloseFileInZip OF((zipFile file)); |
||||
/*
|
||||
Close the current file in the zipfile |
||||
*/ |
||||
|
||||
|
||||
extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file, |
||||
uLong uncompressed_size, |
||||
uLong crc32)); |
||||
/*
|
||||
Close the current file in the zipfile, for fiel opened with |
||||
parameter raw=1 in zipOpenNewFileInZip2 |
||||
uncompressed_size and crc32 are value for the uncompressed size |
||||
*/ |
||||
|
||||
extern int ZEXPORT zipClose OF((zipFile file, |
||||
const char* global_comment)); |
||||
/*
|
||||
Close the zipfile |
||||
*/ |
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
|
||||
#endif /* _zip_H */ |
||||
|
||||
@ -0,0 +1,599 @@ |
||||
(* example.c -- usage example of the zlib compression library |
||||
* Copyright (C) 1995-2003 Jean-loup Gailly. |
||||
* For conditions of distribution and use, see copyright notice in zlib.h |
||||
* |
||||
* Pascal translation |
||||
* Copyright (C) 1998 by Jacques Nomssi Nzali. |
||||
* For conditions of distribution and use, see copyright notice in readme.txt |
||||
* |
||||
* Adaptation to the zlibpas interface |
||||
* Copyright (C) 2003 by Cosmin Truta. |
||||
* For conditions of distribution and use, see copyright notice in readme.txt |
||||
*) |
||||
|
||||
program example; |
||||
|
||||
{$DEFINE TEST_COMPRESS} |
||||
{DO NOT $DEFINE TEST_GZIO} |
||||
{$DEFINE TEST_DEFLATE} |
||||
{$DEFINE TEST_INFLATE} |
||||
{$DEFINE TEST_FLUSH} |
||||
{$DEFINE TEST_SYNC} |
||||
{$DEFINE TEST_DICT} |
||||
|
||||
uses SysUtils, zlibpas; |
||||
|
||||
const TESTFILE = 'foo.gz'; |
||||
|
||||
(* "hello world" would be more standard, but the repeated "hello" |
||||
* stresses the compression code better, sorry... |
||||
*) |
||||
const hello: PChar = 'hello, hello!'; |
||||
|
||||
const dictionary: PChar = 'hello'; |
||||
|
||||
var dictId: LongInt; (* Adler32 value of the dictionary *) |
||||
|
||||
procedure CHECK_ERR(err: Integer; msg: String); |
||||
begin |
||||
if err <> Z_OK then |
||||
begin |
||||
WriteLn(msg, ' error: ', err); |
||||
Halt(1); |
||||
end; |
||||
end; |
||||
|
||||
procedure EXIT_ERR(const msg: String); |
||||
begin |
||||
WriteLn('Error: ', msg); |
||||
Halt(1); |
||||
end; |
||||
|
||||
(* =========================================================================== |
||||
* Test compress and uncompress |
||||
*) |
||||
{$IFDEF TEST_COMPRESS} |
||||
procedure test_compress(compr: Pointer; comprLen: LongInt; |
||||
uncompr: Pointer; uncomprLen: LongInt); |
||||
var err: Integer; |
||||
len: LongInt; |
||||
begin |
||||
len := StrLen(hello)+1; |
||||
|
||||
err := compress(compr, comprLen, hello, len); |
||||
CHECK_ERR(err, 'compress'); |
||||
|
||||
StrCopy(PChar(uncompr), 'garbage'); |
||||
|
||||
err := uncompress(uncompr, uncomprLen, compr, comprLen); |
||||
CHECK_ERR(err, 'uncompress'); |
||||
|
||||
if StrComp(PChar(uncompr), hello) <> 0 then |
||||
EXIT_ERR('bad uncompress') |
||||
else |
||||
WriteLn('uncompress(): ', PChar(uncompr)); |
||||
end; |
||||
{$ENDIF} |
||||
|
||||
(* =========================================================================== |
||||
* Test read/write of .gz files |
||||
*) |
||||
{$IFDEF TEST_GZIO} |
||||
procedure test_gzio(const fname: PChar; (* compressed file name *) |
||||
uncompr: Pointer; |
||||
uncomprLen: LongInt); |
||||
var err: Integer; |
||||
len: Integer; |
||||
zfile: gzFile; |
||||
pos: LongInt; |
||||
begin |
||||
len := StrLen(hello)+1; |
||||
|
||||
zfile := gzopen(fname, 'wb'); |
||||
if zfile = NIL then |
||||
begin |
||||
WriteLn('gzopen error'); |
||||
Halt(1); |
||||
end; |
||||
gzputc(zfile, 'h'); |
||||
if gzputs(zfile, 'ello') <> 4 then |
||||
begin |
||||
WriteLn('gzputs err: ', gzerror(zfile, err)); |
||||
Halt(1); |
||||
end; |
||||
{$IFDEF GZ_FORMAT_STRING} |
||||
if gzprintf(zfile, ', %s!', 'hello') <> 8 then |
||||
begin |
||||
WriteLn('gzprintf err: ', gzerror(zfile, err)); |
||||
Halt(1); |
||||
end; |
||||
{$ELSE} |
||||
if gzputs(zfile, ', hello!') <> 8 then |
||||
begin |
||||
WriteLn('gzputs err: ', gzerror(zfile, err)); |
||||
Halt(1); |
||||
end; |
||||
{$ENDIF} |
||||
gzseek(zfile, 1, SEEK_CUR); (* add one zero byte *) |
||||
gzclose(zfile); |
||||
|
||||
zfile := gzopen(fname, 'rb'); |
||||
if zfile = NIL then |
||||
begin |
||||
WriteLn('gzopen error'); |
||||
Halt(1); |
||||
end; |
||||
|
||||
StrCopy(PChar(uncompr), 'garbage'); |
||||
|
||||
if gzread(zfile, uncompr, uncomprLen) <> len then |
||||
begin |
||||
WriteLn('gzread err: ', gzerror(zfile, err)); |
||||
Halt(1); |
||||
end; |
||||
if StrComp(PChar(uncompr), hello) <> 0 then |
||||
begin |
||||
WriteLn('bad gzread: ', PChar(uncompr)); |
||||
Halt(1); |
||||
end |
||||
else |
||||
WriteLn('gzread(): ', PChar(uncompr)); |
||||
|
||||
pos := gzseek(zfile, -8, SEEK_CUR); |
||||
if (pos <> 6) or (gztell(zfile) <> pos) then |
||||
begin |
||||
WriteLn('gzseek error, pos=', pos, ', gztell=', gztell(zfile)); |
||||
Halt(1); |
||||
end; |
||||
|
||||
if gzgetc(zfile) <> ' ' then |
||||
begin |
||||
WriteLn('gzgetc error'); |
||||
Halt(1); |
||||
end; |
||||
|
||||
if gzungetc(' ', zfile) <> ' ' then |
||||
begin |
||||
WriteLn('gzungetc error'); |
||||
Halt(1); |
||||
end; |
||||
|
||||
gzgets(zfile, PChar(uncompr), uncomprLen); |
||||
uncomprLen := StrLen(PChar(uncompr)); |
||||
if uncomprLen <> 7 then (* " hello!" *) |
||||
begin |
||||
WriteLn('gzgets err after gzseek: ', gzerror(zfile, err)); |
||||
Halt(1); |
||||
end; |
||||
if StrComp(PChar(uncompr), hello + 6) <> 0 then |
||||
begin |
||||
WriteLn('bad gzgets after gzseek'); |
||||
Halt(1); |
||||
end |
||||
else |
||||
WriteLn('gzgets() after gzseek: ', PChar(uncompr)); |
||||
|
||||
gzclose(zfile); |
||||
end; |
||||
{$ENDIF} |
||||
|
||||
(* =========================================================================== |
||||
* Test deflate with small buffers |
||||
*) |
||||
{$IFDEF TEST_DEFLATE} |
||||
procedure test_deflate(compr: Pointer; comprLen: LongInt); |
||||
var c_stream: z_stream; (* compression stream *) |
||||
err: Integer; |
||||
len: LongInt; |
||||
begin |
||||
len := StrLen(hello)+1; |
||||
|
||||
c_stream.zalloc := NIL; |
||||
c_stream.zfree := NIL; |
||||
c_stream.opaque := NIL; |
||||
|
||||
err := deflateInit(c_stream, Z_DEFAULT_COMPRESSION); |
||||
CHECK_ERR(err, 'deflateInit'); |
||||
|
||||
c_stream.next_in := hello; |
||||
c_stream.next_out := compr; |
||||
|
||||
while (c_stream.total_in <> len) and |
||||
(c_stream.total_out < comprLen) do |
||||
begin |
||||
c_stream.avail_out := 1; { force small buffers } |
||||
c_stream.avail_in := 1; |
||||
err := deflate(c_stream, Z_NO_FLUSH); |
||||
CHECK_ERR(err, 'deflate'); |
||||
end; |
||||
|
||||
(* Finish the stream, still forcing small buffers: *) |
||||
while TRUE do |
||||
begin |
||||
c_stream.avail_out := 1; |
||||
err := deflate(c_stream, Z_FINISH); |
||||
if err = Z_STREAM_END then |
||||
break; |
||||
CHECK_ERR(err, 'deflate'); |
||||
end; |
||||
|
||||
err := deflateEnd(c_stream); |
||||
CHECK_ERR(err, 'deflateEnd'); |
||||
end; |
||||
{$ENDIF} |
||||
|
||||
(* =========================================================================== |
||||
* Test inflate with small buffers |
||||
*) |
||||
{$IFDEF TEST_INFLATE} |
||||
procedure test_inflate(compr: Pointer; comprLen : LongInt; |
||||
uncompr: Pointer; uncomprLen : LongInt); |
||||
var err: Integer; |
||||
d_stream: z_stream; (* decompression stream *) |
||||
begin |
||||
StrCopy(PChar(uncompr), 'garbage'); |
||||
|
||||
d_stream.zalloc := NIL; |
||||
d_stream.zfree := NIL; |
||||
d_stream.opaque := NIL; |
||||
|
||||
d_stream.next_in := compr; |
||||
d_stream.avail_in := 0; |
||||
d_stream.next_out := uncompr; |
||||
|
||||
err := inflateInit(d_stream); |
||||
CHECK_ERR(err, 'inflateInit'); |
||||
|
||||
while (d_stream.total_out < uncomprLen) and |
||||
(d_stream.total_in < comprLen) do |
||||
begin |
||||
d_stream.avail_out := 1; (* force small buffers *) |
||||
d_stream.avail_in := 1; |
||||
err := inflate(d_stream, Z_NO_FLUSH); |
||||
if err = Z_STREAM_END then |
||||
break; |
||||
CHECK_ERR(err, 'inflate'); |
||||
end; |
||||
|
||||
err := inflateEnd(d_stream); |
||||
CHECK_ERR(err, 'inflateEnd'); |
||||
|
||||
if StrComp(PChar(uncompr), hello) <> 0 then |
||||
EXIT_ERR('bad inflate') |
||||
else |
||||
WriteLn('inflate(): ', PChar(uncompr)); |
||||
end; |
||||
{$ENDIF} |
||||
|
||||
(* =========================================================================== |
||||
* Test deflate with large buffers and dynamic change of compression level |
||||
*) |
||||
{$IFDEF TEST_DEFLATE} |
||||
procedure test_large_deflate(compr: Pointer; comprLen: LongInt; |
||||
uncompr: Pointer; uncomprLen: LongInt); |
||||
var c_stream: z_stream; (* compression stream *) |
||||
err: Integer; |
||||
begin |
||||
c_stream.zalloc := NIL; |
||||
c_stream.zfree := NIL; |
||||
c_stream.opaque := NIL; |
||||
|
||||
err := deflateInit(c_stream, Z_BEST_SPEED); |
||||
CHECK_ERR(err, 'deflateInit'); |
||||
|
||||
c_stream.next_out := compr; |
||||
c_stream.avail_out := Integer(comprLen); |
||||
|
||||
(* At this point, uncompr is still mostly zeroes, so it should compress |
||||
* very well: |
||||
*) |
||||
c_stream.next_in := uncompr; |
||||
c_stream.avail_in := Integer(uncomprLen); |
||||
err := deflate(c_stream, Z_NO_FLUSH); |
||||
CHECK_ERR(err, 'deflate'); |
||||
if c_stream.avail_in <> 0 then |
||||
EXIT_ERR('deflate not greedy'); |
||||
|
||||
(* Feed in already compressed data and switch to no compression: *) |
||||
deflateParams(c_stream, Z_NO_COMPRESSION, Z_DEFAULT_STRATEGY); |
||||
c_stream.next_in := compr; |
||||
c_stream.avail_in := Integer(comprLen div 2); |
||||
err := deflate(c_stream, Z_NO_FLUSH); |
||||
CHECK_ERR(err, 'deflate'); |
||||
|
||||
(* Switch back to compressing mode: *) |
||||
deflateParams(c_stream, Z_BEST_COMPRESSION, Z_FILTERED); |
||||
c_stream.next_in := uncompr; |
||||
c_stream.avail_in := Integer(uncomprLen); |
||||
err := deflate(c_stream, Z_NO_FLUSH); |
||||
CHECK_ERR(err, 'deflate'); |
||||
|
||||
err := deflate(c_stream, Z_FINISH); |
||||
if err <> Z_STREAM_END then |
||||
EXIT_ERR('deflate should report Z_STREAM_END'); |
||||
|
||||
err := deflateEnd(c_stream); |
||||
CHECK_ERR(err, 'deflateEnd'); |
||||
end; |
||||
{$ENDIF} |
||||
|
||||
(* =========================================================================== |
||||
* Test inflate with large buffers |
||||
*) |
||||
{$IFDEF TEST_INFLATE} |
||||
procedure test_large_inflate(compr: Pointer; comprLen: LongInt; |
||||
uncompr: Pointer; uncomprLen: LongInt); |
||||
var err: Integer; |
||||
d_stream: z_stream; (* decompression stream *) |
||||
begin |
||||
StrCopy(PChar(uncompr), 'garbage'); |
||||
|
||||
d_stream.zalloc := NIL; |
||||
d_stream.zfree := NIL; |
||||
d_stream.opaque := NIL; |
||||
|
||||
d_stream.next_in := compr; |
||||
d_stream.avail_in := Integer(comprLen); |
||||
|
||||
err := inflateInit(d_stream); |
||||
CHECK_ERR(err, 'inflateInit'); |
||||
|
||||
while TRUE do |
||||
begin |
||||
d_stream.next_out := uncompr; (* discard the output *) |
||||
d_stream.avail_out := Integer(uncomprLen); |
||||
err := inflate(d_stream, Z_NO_FLUSH); |
||||
if err = Z_STREAM_END then |
||||
break; |
||||
CHECK_ERR(err, 'large inflate'); |
||||
end; |
||||
|
||||
err := inflateEnd(d_stream); |
||||
CHECK_ERR(err, 'inflateEnd'); |
||||
|
||||
if d_stream.total_out <> 2 * uncomprLen + comprLen div 2 then |
||||
begin |
||||
WriteLn('bad large inflate: ', d_stream.total_out); |
||||
Halt(1); |
||||
end |
||||
else |
||||
WriteLn('large_inflate(): OK'); |
||||
end; |
||||
{$ENDIF} |
||||
|
||||
(* =========================================================================== |
||||
* Test deflate with full flush |
||||
*) |
||||
{$IFDEF TEST_FLUSH} |
||||
procedure test_flush(compr: Pointer; var comprLen : LongInt); |
||||
var c_stream: z_stream; (* compression stream *) |
||||
err: Integer; |
||||
len: Integer; |
||||
begin |
||||
len := StrLen(hello)+1; |
||||
|
||||
c_stream.zalloc := NIL; |
||||
c_stream.zfree := NIL; |
||||
c_stream.opaque := NIL; |
||||
|
||||
err := deflateInit(c_stream, Z_DEFAULT_COMPRESSION); |
||||
CHECK_ERR(err, 'deflateInit'); |
||||
|
||||
c_stream.next_in := hello; |
||||
c_stream.next_out := compr; |
||||
c_stream.avail_in := 3; |
||||
c_stream.avail_out := Integer(comprLen); |
||||
err := deflate(c_stream, Z_FULL_FLUSH); |
||||
CHECK_ERR(err, 'deflate'); |
||||
|
||||
Inc(PByteArray(compr)^[3]); (* force an error in first compressed block *) |
||||
c_stream.avail_in := len - 3; |
||||
|
||||
err := deflate(c_stream, Z_FINISH); |
||||
if err <> Z_STREAM_END then |
||||
CHECK_ERR(err, 'deflate'); |
||||
|
||||
err := deflateEnd(c_stream); |
||||
CHECK_ERR(err, 'deflateEnd'); |
||||
|
||||
comprLen := c_stream.total_out; |
||||
end; |
||||
{$ENDIF} |
||||
|
||||
(* =========================================================================== |
||||
* Test inflateSync() |
||||
*) |
||||
{$IFDEF TEST_SYNC} |
||||
procedure test_sync(compr: Pointer; comprLen: LongInt; |
||||
uncompr: Pointer; uncomprLen : LongInt); |
||||
var err: Integer; |
||||
d_stream: z_stream; (* decompression stream *) |
||||
begin |
||||
StrCopy(PChar(uncompr), 'garbage'); |
||||
|
||||
d_stream.zalloc := NIL; |
||||
d_stream.zfree := NIL; |
||||
d_stream.opaque := NIL; |
||||
|
||||
d_stream.next_in := compr; |
||||
d_stream.avail_in := 2; (* just read the zlib header *) |
||||
|
||||
err := inflateInit(d_stream); |
||||
CHECK_ERR(err, 'inflateInit'); |
||||
|
||||
d_stream.next_out := uncompr; |
||||
d_stream.avail_out := Integer(uncomprLen); |
||||
|
||||
inflate(d_stream, Z_NO_FLUSH); |
||||
CHECK_ERR(err, 'inflate'); |
||||
|
||||
d_stream.avail_in := Integer(comprLen-2); (* read all compressed data *) |
||||
err := inflateSync(d_stream); (* but skip the damaged part *) |
||||
CHECK_ERR(err, 'inflateSync'); |
||||
|
||||
err := inflate(d_stream, Z_FINISH); |
||||
if err <> Z_DATA_ERROR then |
||||
EXIT_ERR('inflate should report DATA_ERROR'); |
||||
(* Because of incorrect adler32 *) |
||||
|
||||
err := inflateEnd(d_stream); |
||||
CHECK_ERR(err, 'inflateEnd'); |
||||
|
||||
WriteLn('after inflateSync(): hel', PChar(uncompr)); |
||||
end; |
||||
{$ENDIF} |
||||
|
||||
(* =========================================================================== |
||||
* Test deflate with preset dictionary |
||||
*) |
||||
{$IFDEF TEST_DICT} |
||||
procedure test_dict_deflate(compr: Pointer; comprLen: LongInt); |
||||
var c_stream: z_stream; (* compression stream *) |
||||
err: Integer; |
||||
begin |
||||
c_stream.zalloc := NIL; |
||||
c_stream.zfree := NIL; |
||||
c_stream.opaque := NIL; |
||||
|
||||
err := deflateInit(c_stream, Z_BEST_COMPRESSION); |
||||
CHECK_ERR(err, 'deflateInit'); |
||||
|
||||
err := deflateSetDictionary(c_stream, dictionary, StrLen(dictionary)); |
||||
CHECK_ERR(err, 'deflateSetDictionary'); |
||||
|
||||
dictId := c_stream.adler; |
||||
c_stream.next_out := compr; |
||||
c_stream.avail_out := Integer(comprLen); |
||||
|
||||
c_stream.next_in := hello; |
||||
c_stream.avail_in := StrLen(hello)+1; |
||||
|
||||
err := deflate(c_stream, Z_FINISH); |
||||
if err <> Z_STREAM_END then |
||||
EXIT_ERR('deflate should report Z_STREAM_END'); |
||||
|
||||
err := deflateEnd(c_stream); |
||||
CHECK_ERR(err, 'deflateEnd'); |
||||
end; |
||||
{$ENDIF} |
||||
|
||||
(* =========================================================================== |
||||
* Test inflate with a preset dictionary |
||||
*) |
||||
{$IFDEF TEST_DICT} |
||||
procedure test_dict_inflate(compr: Pointer; comprLen: LongInt; |
||||
uncompr: Pointer; uncomprLen: LongInt); |
||||
var err: Integer; |
||||
d_stream: z_stream; (* decompression stream *) |
||||
begin |
||||
StrCopy(PChar(uncompr), 'garbage'); |
||||
|
||||
d_stream.zalloc := NIL; |
||||
d_stream.zfree := NIL; |
||||
d_stream.opaque := NIL; |
||||
|
||||
d_stream.next_in := compr; |
||||
d_stream.avail_in := Integer(comprLen); |
||||
|
||||
err := inflateInit(d_stream); |
||||
CHECK_ERR(err, 'inflateInit'); |
||||
|
||||
d_stream.next_out := uncompr; |
||||
d_stream.avail_out := Integer(uncomprLen); |
||||
|
||||
while TRUE do |
||||
begin |
||||
err := inflate(d_stream, Z_NO_FLUSH); |
||||
if err = Z_STREAM_END then |
||||
break; |
||||
if err = Z_NEED_DICT then |
||||
begin |
||||
if d_stream.adler <> dictId then |
||||
EXIT_ERR('unexpected dictionary'); |
||||
err := inflateSetDictionary(d_stream, dictionary, StrLen(dictionary)); |
||||
end; |
||||
CHECK_ERR(err, 'inflate with dict'); |
||||
end; |
||||
|
||||
err := inflateEnd(d_stream); |
||||
CHECK_ERR(err, 'inflateEnd'); |
||||
|
||||
if StrComp(PChar(uncompr), hello) <> 0 then |
||||
EXIT_ERR('bad inflate with dict') |
||||
else |
||||
WriteLn('inflate with dictionary: ', PChar(uncompr)); |
||||
end; |
||||
{$ENDIF} |
||||
|
||||
var compr, uncompr: Pointer; |
||||
comprLen, uncomprLen: LongInt; |
||||
|
||||
begin |
||||
if zlibVersion^ <> ZLIB_VERSION[1] then |
||||
EXIT_ERR('Incompatible zlib version'); |
||||
|
||||
WriteLn('zlib version: ', zlibVersion); |
||||
WriteLn('zlib compile flags: ', Format('0x%x', [zlibCompileFlags])); |
||||
|
||||
comprLen := 10000 * SizeOf(Integer); (* don't overflow on MSDOS *) |
||||
uncomprLen := comprLen; |
||||
GetMem(compr, comprLen); |
||||
GetMem(uncompr, uncomprLen); |
||||
if (compr = NIL) or (uncompr = NIL) then |
||||
EXIT_ERR('Out of memory'); |
||||
(* compr and uncompr are cleared to avoid reading uninitialized |
||||
* data and to ensure that uncompr compresses well. |
||||
*) |
||||
FillChar(compr^, comprLen, 0); |
||||
FillChar(uncompr^, uncomprLen, 0); |
||||
|
||||
{$IFDEF TEST_COMPRESS} |
||||
WriteLn('** Testing compress'); |
||||
test_compress(compr, comprLen, uncompr, uncomprLen); |
||||
{$ENDIF} |
||||
|
||||
{$IFDEF TEST_GZIO} |
||||
WriteLn('** Testing gzio'); |
||||
if ParamCount >= 1 then |
||||
test_gzio(ParamStr(1), uncompr, uncomprLen) |
||||
else |
||||
test_gzio(TESTFILE, uncompr, uncomprLen); |
||||
{$ENDIF} |
||||
|
||||
{$IFDEF TEST_DEFLATE} |
||||
WriteLn('** Testing deflate with small buffers'); |
||||
test_deflate(compr, comprLen); |
||||
{$ENDIF} |
||||
{$IFDEF TEST_INFLATE} |
||||
WriteLn('** Testing inflate with small buffers'); |
||||
test_inflate(compr, comprLen, uncompr, uncomprLen); |
||||
{$ENDIF} |
||||
|
||||
{$IFDEF TEST_DEFLATE} |
||||
WriteLn('** Testing deflate with large buffers'); |
||||
test_large_deflate(compr, comprLen, uncompr, uncomprLen); |
||||
{$ENDIF} |
||||
{$IFDEF TEST_INFLATE} |
||||
WriteLn('** Testing inflate with large buffers'); |
||||
test_large_inflate(compr, comprLen, uncompr, uncomprLen); |
||||
{$ENDIF} |
||||
|
||||
{$IFDEF TEST_FLUSH} |
||||
WriteLn('** Testing deflate with full flush'); |
||||
test_flush(compr, comprLen); |
||||
{$ENDIF} |
||||
{$IFDEF TEST_SYNC} |
||||
WriteLn('** Testing inflateSync'); |
||||
test_sync(compr, comprLen, uncompr, uncomprLen); |
||||
{$ENDIF} |
||||
comprLen := uncomprLen; |
||||
|
||||
{$IFDEF TEST_DICT} |
||||
WriteLn('** Testing deflate and inflate with preset dictionary'); |
||||
test_dict_deflate(compr, comprLen); |
||||
test_dict_inflate(compr, comprLen, uncompr, uncomprLen); |
||||
{$ENDIF} |
||||
|
||||
FreeMem(compr, comprLen); |
||||
FreeMem(uncompr, uncomprLen); |
||||
end. |
||||
@ -0,0 +1,76 @@ |
||||
|
||||
This directory contains a Pascal (Delphi, Kylix) interface to the |
||||
zlib data compression library. |
||||
|
||||
|
||||
Directory listing |
||||
================= |
||||
|
||||
zlibd32.mak makefile for Borland C++ |
||||
example.pas usage example of zlib |
||||
zlibpas.pas the Pascal interface to zlib |
||||
readme.txt this file |
||||
|
||||
|
||||
Compatibility notes |
||||
=================== |
||||
|
||||
- Although the name "zlib" would have been more normal for the |
||||
zlibpas unit, this name is already taken by Borland's ZLib unit. |
||||
This is somehow unfortunate, because that unit is not a genuine |
||||
interface to the full-fledged zlib functionality, but a suite of |
||||
class wrappers around zlib streams. Other essential features, |
||||
such as checksums, are missing. |
||||
It would have been more appropriate for that unit to have a name |
||||
like "ZStreams", or something similar. |
||||
|
||||
- The C and zlib-supplied types int, uInt, long, uLong, etc. are |
||||
translated directly into Pascal types of similar sizes (Integer, |
||||
LongInt, etc.), to avoid namespace pollution. In particular, |
||||
there is no conversion of unsigned int into a Pascal unsigned |
||||
integer. The Word type is non-portable and has the same size |
||||
(16 bits) both in a 16-bit and in a 32-bit environment, unlike |
||||
Integer. Even if there is a 32-bit Cardinal type, there is no |
||||
real need for unsigned int in zlib under a 32-bit environment. |
||||
|
||||
- Except for the callbacks, the zlib function interfaces are |
||||
assuming the calling convention normally used in Pascal |
||||
(__pascal for DOS and Windows16, __fastcall for Windows32). |
||||
Since the cdecl keyword is used, the old Turbo Pascal does |
||||
not work with this interface. |
||||
|
||||
- The gz* function interfaces are not translated, to avoid |
||||
interfacing problems with the C runtime library. Besides, |
||||
gzprintf(gzFile file, const char *format, ...) |
||||
cannot be translated into Pascal. |
||||
|
||||
|
||||
Legal issues |
||||
============ |
||||
|
||||
The zlibpas interface is: |
||||
Copyright (C) 1995-2003 Jean-loup Gailly and Mark Adler. |
||||
Copyright (C) 1998 by Bob Dellaca. |
||||
Copyright (C) 2003 by Cosmin Truta. |
||||
|
||||
The example program is: |
||||
Copyright (C) 1995-2003 by Jean-loup Gailly. |
||||
Copyright (C) 1998,1999,2000 by Jacques Nomssi Nzali. |
||||
Copyright (C) 2003 by Cosmin Truta. |
||||
|
||||
This software is provided 'as-is', without any express or implied |
||||
warranty. In no event will the author 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. |
||||
|
||||
@ -0,0 +1,93 @@ |
||||
# Makefile for zlib
|
||||
# For use with Delphi and C++ Builder under Win32
|
||||
# Updated for zlib 1.2.x by Cosmin Truta
|
||||
|
||||
# ------------ Borland C++ ------------
|
||||
|
||||
# This project uses the Delphi (fastcall/register) calling convention:
|
||||
LOC = -DZEXPORT=__fastcall -DZEXPORTVA=__cdecl
|
||||
|
||||
CC = bcc32
|
||||
LD = bcc32
|
||||
AR = tlib
|
||||
# do not use "-pr" in CFLAGS
|
||||
CFLAGS = -a -d -k- -O2 $(LOC)
|
||||
LDFLAGS =
|
||||
|
||||
|
||||
# variables
|
||||
ZLIB_LIB = zlib.lib
|
||||
|
||||
OBJ1 = adler32.obj compress.obj crc32.obj deflate.obj gzio.obj infback.obj
|
||||
OBJ2 = inffast.obj inflate.obj inftrees.obj trees.obj uncompr.obj zutil.obj
|
||||
OBJP1 = +adler32.obj+compress.obj+crc32.obj+deflate.obj+gzio.obj+infback.obj
|
||||
OBJP2 = +inffast.obj+inflate.obj+inftrees.obj+trees.obj+uncompr.obj+zutil.obj
|
||||
|
||||
|
||||
# targets
|
||||
all: $(ZLIB_LIB) example.exe minigzip.exe |
||||
|
||||
.c.obj: |
||||
$(CC) -c $(CFLAGS) $*.c
|
||||
|
||||
adler32.obj: adler32.c zlib.h zconf.h |
||||
|
||||
compress.obj: compress.c zlib.h zconf.h |
||||
|
||||
crc32.obj: crc32.c zlib.h zconf.h crc32.h |
||||
|
||||
deflate.obj: deflate.c deflate.h zutil.h zlib.h zconf.h |
||||
|
||||
gzio.obj: gzio.c zutil.h zlib.h zconf.h |
||||
|
||||
infback.obj: infback.c zutil.h zlib.h zconf.h inftrees.h inflate.h \
|
||||
inffast.h inffixed.h
|
||||
|
||||
inffast.obj: inffast.c zutil.h zlib.h zconf.h inftrees.h inflate.h \
|
||||
inffast.h
|
||||
|
||||
inflate.obj: inflate.c zutil.h zlib.h zconf.h inftrees.h inflate.h \
|
||||
inffast.h inffixed.h
|
||||
|
||||
inftrees.obj: inftrees.c zutil.h zlib.h zconf.h inftrees.h |
||||
|
||||
trees.obj: trees.c zutil.h zlib.h zconf.h deflate.h trees.h |
||||
|
||||
uncompr.obj: uncompr.c zlib.h zconf.h |
||||
|
||||
zutil.obj: zutil.c zutil.h zlib.h zconf.h |
||||
|
||||
example.obj: example.c zlib.h zconf.h |
||||
|
||||
minigzip.obj: minigzip.c zlib.h zconf.h |
||||
|
||||
|
||||
# For the sake of the old Borland make,
|
||||
# the command line is cut to fit in the MS-DOS 128 byte limit:
|
||||
$(ZLIB_LIB): $(OBJ1) $(OBJ2) |
||||
-del $(ZLIB_LIB)
|
||||
$(AR) $(ZLIB_LIB) $(OBJP1)
|
||||
$(AR) $(ZLIB_LIB) $(OBJP2)
|
||||
|
||||
|
||||
# testing
|
||||
test: example.exe minigzip.exe |
||||
example
|
||||
echo hello world | minigzip | minigzip -d
|
||||
|
||||
example.exe: example.obj $(ZLIB_LIB) |
||||
$(LD) $(LDFLAGS) example.obj $(ZLIB_LIB)
|
||||
|
||||
minigzip.exe: minigzip.obj $(ZLIB_LIB) |
||||
$(LD) $(LDFLAGS) minigzip.obj $(ZLIB_LIB)
|
||||
|
||||
|
||||
# cleanup
|
||||
clean: |
||||
-del *.obj
|
||||
-del *.exe
|
||||
-del *.lib
|
||||
-del *.tds
|
||||
-del zlib.bak
|
||||
-del foo.gz
|
||||
|
||||
@ -0,0 +1,234 @@ |
||||
(* zlibpas -- Pascal interface to the zlib data compression library |
||||
* |
||||
* Copyright (C) 2003 Cosmin Truta. |
||||
* Derived from original sources by Bob Dellaca. |
||||
* For conditions of distribution and use, see copyright notice in readme.txt |
||||
*) |
||||
|
||||
unit zlibpas; |
||||
|
||||
interface |
||||
|
||||
const |
||||
ZLIB_VERSION = '1.2.0'; |
||||
|
||||
type |
||||
alloc_func = function(opaque: Pointer; items, size: Integer): Pointer; |
||||
cdecl; |
||||
free_func = procedure(opaque, address: Pointer); |
||||
cdecl; |
||||
|
||||
in_func = function(opaque: Pointer; var buf: PByte): Integer; |
||||
cdecl; |
||||
out_func = function(opaque: Pointer; buf: PByte; size: Integer): Integer; |
||||
cdecl; |
||||
|
||||
z_streamp = ^z_stream; |
||||
z_stream = packed record |
||||
next_in: PChar; (* next input byte *) |
||||
avail_in: Integer; (* number of bytes available at next_in *) |
||||
total_in: LongInt; (* total nb of input bytes read so far *) |
||||
|
||||
next_out: PChar; (* next output byte should be put there *) |
||||
avail_out: Integer; (* remaining free space at next_out *) |
||||
total_out: LongInt; (* total nb of bytes output so far *) |
||||
|
||||
msg: PChar; (* last error message, NULL if no error *) |
||||
state: Pointer; (* not visible by applications *) |
||||
|
||||
zalloc: alloc_func; (* used to allocate the internal state *) |
||||
zfree: free_func; (* used to free the internal state *) |
||||
opaque: Pointer; (* private data object passed to zalloc and zfree *) |
||||
|
||||
data_type: Integer; (* best guess about the data type: ascii or binary *) |
||||
adler: LongInt; (* adler32 value of the uncompressed data *) |
||||
reserved: LongInt; (* reserved for future use *) |
||||
end; |
||||
|
||||
(* constants *) |
||||
const |
||||
Z_NO_FLUSH = 0; |
||||
Z_PARTIAL_FLUSH = 1; |
||||
Z_SYNC_FLUSH = 2; |
||||
Z_FULL_FLUSH = 3; |
||||
Z_FINISH = 4; |
||||
|
||||
Z_OK = 0; |
||||
Z_STREAM_END = 1; |
||||
Z_NEED_DICT = 2; |
||||
Z_ERRNO = -1; |
||||
Z_STREAM_ERROR = -2; |
||||
Z_DATA_ERROR = -3; |
||||
Z_MEM_ERROR = -4; |
||||
Z_BUF_ERROR = -5; |
||||
Z_VERSION_ERROR = -6; |
||||
|
||||
Z_NO_COMPRESSION = 0; |
||||
Z_BEST_SPEED = 1; |
||||
Z_BEST_COMPRESSION = 9; |
||||
Z_DEFAULT_COMPRESSION = -1; |
||||
|
||||
Z_FILTERED = 1; |
||||
Z_HUFFMAN_ONLY = 2; |
||||
Z_RLE = 3; |
||||
Z_DEFAULT_STRATEGY = 0; |
||||
|
||||
Z_BINARY = 0; |
||||
Z_ASCII = 1; |
||||
Z_UNKNOWN = 2; |
||||
|
||||
Z_DEFLATED = 8; |
||||
|
||||
(* basic functions *) |
||||
function zlibVersion: PChar; |
||||
function deflateInit(var strm: z_stream; level: Integer): Integer; |
||||
function deflate(var strm: z_stream; flush: Integer): Integer; |
||||
function deflateEnd(var strm: z_stream): Integer; |
||||
function inflateInit(var strm: z_stream): Integer; |
||||
function inflate(var strm: z_stream; flush: Integer): Integer; |
||||
function inflateEnd(var strm: z_stream): Integer; |
||||
|
||||
(* advanced functions *) |
||||
function deflateInit2(var strm: z_stream; level, method, windowBits, |
||||
memLevel, strategy: Integer): Integer; |
||||
function deflateSetDictionary(var strm: z_stream; const dictionary: PChar; |
||||
dictLength: Integer): Integer; |
||||
function deflateCopy(var dest, source: z_stream): Integer; |
||||
function deflateReset(var strm: z_stream): Integer; |
||||
function deflateParams(var strm: z_stream; level, strategy: Integer): Integer; |
||||
function deflateBound(var strm: z_stream; sourceLen: LongInt): LongInt; |
||||
function inflateInit2(var strm: z_stream; windowBits: Integer): Integer; |
||||
function inflateSetDictionary(var strm: z_stream; const dictionary: PChar; |
||||
dictLength: Integer): Integer; |
||||
function inflateSync(var strm: z_stream): Integer; |
||||
function inflateCopy(var dest, source: z_stream): Integer; |
||||
function inflateReset(var strm: z_stream): Integer; |
||||
function inflateBackInit(var strm: z_stream; |
||||
windowBits: Integer; window: PChar): Integer; |
||||
function inflateBack(var strm: z_stream; in_fn: in_func; in_desc: Pointer; |
||||
out_fn: out_func; out_desc: Pointer): Integer; |
||||
function inflateBackEnd(var strm: z_stream): Integer; |
||||
function zlibCompileFlags: LongInt; |
||||
|
||||
(* utility functions *) |
||||
function compress(dest: PChar; var destLen: LongInt; |
||||
const source: PChar; sourceLen: LongInt): Integer; |
||||
function compress2(dest: PChar; var destLen: LongInt; |
||||
const source: PChar; sourceLen: LongInt; |
||||
level: Integer): Integer; |
||||
function compressBound(sourceLen: LongInt): LongInt; |
||||
function uncompress(dest: PChar; var destLen: LongInt; |
||||
const source: PChar; sourceLen: LongInt): Integer; |
||||
|
||||
(* checksum functions *) |
||||
function adler32(adler: LongInt; const buf: PChar; len: Integer): LongInt; |
||||
function crc32(crc: LongInt; const buf: PChar; len: Integer): LongInt; |
||||
|
||||
(* various hacks, don't look :) *) |
||||
function deflateInit_(var strm: z_stream; level: Integer; |
||||
const version: PChar; stream_size: Integer): Integer; |
||||
function inflateInit_(var strm: z_stream; const version: PChar; |
||||
stream_size: Integer): Integer; |
||||
function deflateInit2_(var strm: z_stream; |
||||
level, method, windowBits, memLevel, strategy: Integer; |
||||
const version: PChar; stream_size: Integer): Integer; |
||||
function inflateInit2_(var strm: z_stream; windowBits: Integer; |
||||
const version: PChar; stream_size: Integer): Integer; |
||||
function inflateBackInit_(var strm: z_stream; |
||||
windowBits: Integer; window: PChar; |
||||
const version: PChar; stream_size: Integer): Integer; |
||||
|
||||
|
||||
implementation |
||||
|
||||
{$L adler32.obj} |
||||
{$L compress.obj} |
||||
{$L crc32.obj} |
||||
{$L deflate.obj} |
||||
{$L infback.obj} |
||||
{$L inffast.obj} |
||||
{$L inflate.obj} |
||||
{$L inftrees.obj} |
||||
{$L trees.obj} |
||||
{$L uncompr.obj} |
||||
{$L zutil.obj} |
||||
|
||||
function adler32; external; |
||||
function compress; external; |
||||
function compress2; external; |
||||
function compressBound; external; |
||||
function crc32; external; |
||||
function deflate; external; |
||||
function deflateBound; external; |
||||
function deflateCopy; external; |
||||
function deflateEnd; external; |
||||
function deflateInit_; external; |
||||
function deflateInit2_; external; |
||||
function deflateParams; external; |
||||
function deflateReset; external; |
||||
function deflateSetDictionary; external; |
||||
function inflate; external; |
||||
function inflateBack; external; |
||||
function inflateBackEnd; external; |
||||
function inflateBackInit_; external; |
||||
function inflateCopy; external; |
||||
function inflateEnd; external; |
||||
function inflateInit_; external; |
||||
function inflateInit2_; external; |
||||
function inflateReset; external; |
||||
function inflateSetDictionary; external; |
||||
function inflateSync; external; |
||||
function uncompress; external; |
||||
function zlibCompileFlags; external; |
||||
function zlibVersion; external; |
||||
|
||||
function deflateInit(var strm: z_stream; level: Integer): Integer; |
||||
begin |
||||
Result := deflateInit_(strm, level, ZLIB_VERSION, sizeof(z_stream)); |
||||
end; |
||||
|
||||
function deflateInit2(var strm: z_stream; level, method, windowBits, memLevel, |
||||
strategy: Integer): Integer; |
||||
begin |
||||
Result := deflateInit2_(strm, level, method, windowBits, memLevel, strategy, |
||||
ZLIB_VERSION, sizeof(z_stream)); |
||||
end; |
||||
|
||||
function inflateInit(var strm: z_stream): Integer; |
||||
begin |
||||
Result := inflateInit_(strm, ZLIB_VERSION, sizeof(z_stream)); |
||||
end; |
||||
|
||||
function inflateInit2(var strm: z_stream; windowBits: Integer): Integer; |
||||
begin |
||||
Result := inflateInit2_(strm, windowBits, ZLIB_VERSION, sizeof(z_stream)); |
||||
end; |
||||
|
||||
function inflateBackInit(var strm: z_stream; |
||||
windowBits: Integer; window: PChar): Integer; |
||||
begin |
||||
Result := inflateBackInit_(strm, windowBits, window, |
||||
ZLIB_VERSION, sizeof(z_stream)); |
||||
end; |
||||
|
||||
function _malloc(Size: Integer): Pointer; cdecl; |
||||
begin |
||||
GetMem(Result, Size); |
||||
end; |
||||
|
||||
procedure _free(Block: Pointer); cdecl; |
||||
begin |
||||
FreeMem(Block); |
||||
end; |
||||
|
||||
procedure _memset(P: Pointer; B: Byte; count: Integer); cdecl; |
||||
begin |
||||
FillChar(P^, count, B); |
||||
end; |
||||
|
||||
procedure _memcpy(dest, source: Pointer; count: Integer); cdecl; |
||||
begin |
||||
Move(source^, dest^, count); |
||||
end; |
||||
|
||||
end. |
||||
@ -1,149 +1,149 @@ |
||||
|
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <windows.h> |
||||
#include "zlib.h" |
||||
|
||||
int ReadFileMemory(const char* filename,long* plFileSize,void** pFilePtr) |
||||
{ |
||||
FILE* stream; |
||||
void* ptr; |
||||
int retVal=1; |
||||
stream=fopen(filename, "rb"); |
||||
if (stream==NULL) |
||||
return 0; |
||||
|
||||
fseek(stream,0,SEEK_END); |
||||
|
||||
*plFileSize=ftell(stream); |
||||
fseek(stream,0,SEEK_SET); |
||||
ptr=malloc((*plFileSize)+1); |
||||
if (ptr==NULL) |
||||
retVal=0; |
||||
else |
||||
{ |
||||
if (fread(ptr, 1, *plFileSize,stream) != (*plFileSize)) |
||||
retVal=0; |
||||
} |
||||
fclose(stream); |
||||
*pFilePtr=ptr; |
||||
return retVal; |
||||
} |
||||
|
||||
int main(int argc, char *argv[]) |
||||
{ |
||||
int BlockSizeCompress=0x8000; |
||||
int BlockSizeUncompress=0x8000; |
||||
int cprLevel=Z_DEFAULT_COMPRESSION ; |
||||
long lFileSize; |
||||
unsigned char* FilePtr; |
||||
long lBufferSizeCpr; |
||||
long lBufferSizeUncpr; |
||||
long lCompressedSize=0; |
||||
unsigned char* CprPtr; |
||||
unsigned char* UncprPtr; |
||||
long lSizeCpr,lSizeUncpr; |
||||
DWORD dwGetTick; |
||||
|
||||
if (argc<=1) |
||||
{ |
||||
printf("run TestZlib <File> [BlockSizeCompress] [BlockSizeUncompress] [compres. level]\n"); |
||||
return 0; |
||||
} |
||||
|
||||
if (ReadFileMemory(argv[1],&lFileSize,&FilePtr)==0) |
||||
{ |
||||
printf("error reading %s\n",argv[1]); |
||||
return 1; |
||||
} |
||||
else printf("file %s read, %u bytes\n",argv[1],lFileSize); |
||||
|
||||
if (argc>=3) |
||||
BlockSizeCompress=atol(argv[2]); |
||||
|
||||
if (argc>=4) |
||||
BlockSizeUncompress=atol(argv[3]); |
||||
|
||||
if (argc>=5) |
||||
cprLevel=(int)atol(argv[4]); |
||||
|
||||
lBufferSizeCpr = lFileSize + (lFileSize/0x10) + 0x200; |
||||
lBufferSizeUncpr = lBufferSizeCpr; |
||||
|
||||
CprPtr=(unsigned char*)malloc(lBufferSizeCpr + BlockSizeCompress); |
||||
UncprPtr=(unsigned char*)malloc(lBufferSizeUncpr + BlockSizeUncompress); |
||||
|
||||
dwGetTick=GetTickCount(); |
||||
{ |
||||
z_stream zcpr; |
||||
int ret=Z_OK; |
||||
long lOrigToDo = lFileSize; |
||||
long lOrigDone = 0; |
||||
int step=0; |
||||
memset(&zcpr,0,sizeof(z_stream)); |
||||
deflateInit(&zcpr,cprLevel); |
||||
|
||||
zcpr.next_in = FilePtr; |
||||
zcpr.next_out = CprPtr; |
||||
|
||||
|
||||
do |
||||
{ |
||||
long all_read_before = zcpr.total_in; |
||||
zcpr.avail_in = min(lOrigToDo,BlockSizeCompress); |
||||
zcpr.avail_out = BlockSizeCompress; |
||||
ret=deflate(&zcpr,(zcpr.avail_in==lOrigToDo) ? Z_FINISH : Z_SYNC_FLUSH); |
||||
lOrigDone += (zcpr.total_in-all_read_before); |
||||
lOrigToDo -= (zcpr.total_in-all_read_before); |
||||
step++; |
||||
} while (ret==Z_OK); |
||||
|
||||
lSizeCpr=zcpr.total_out; |
||||
deflateEnd(&zcpr); |
||||
dwGetTick=GetTickCount()-dwGetTick; |
||||
printf("total compress size = %u, in %u step\n",lSizeCpr,step); |
||||
printf("time = %u msec = %f sec\n\n",dwGetTick,dwGetTick/(double)1000.); |
||||
} |
||||
|
||||
dwGetTick=GetTickCount(); |
||||
{ |
||||
z_stream zcpr; |
||||
int ret=Z_OK; |
||||
long lOrigToDo = lSizeCpr; |
||||
long lOrigDone = 0; |
||||
int step=0; |
||||
memset(&zcpr,0,sizeof(z_stream)); |
||||
inflateInit(&zcpr); |
||||
|
||||
zcpr.next_in = CprPtr; |
||||
zcpr.next_out = UncprPtr; |
||||
|
||||
|
||||
do |
||||
{ |
||||
long all_read_before = zcpr.total_in; |
||||
zcpr.avail_in = min(lOrigToDo,BlockSizeUncompress); |
||||
zcpr.avail_out = BlockSizeUncompress; |
||||
ret=inflate(&zcpr,Z_SYNC_FLUSH); |
||||
lOrigDone += (zcpr.total_in-all_read_before); |
||||
lOrigToDo -= (zcpr.total_in-all_read_before); |
||||
step++; |
||||
} while (ret==Z_OK); |
||||
|
||||
lSizeUncpr=zcpr.total_out; |
||||
inflateEnd(&zcpr); |
||||
dwGetTick=GetTickCount()-dwGetTick; |
||||
printf("total uncompress size = %u, in %u step\n",lSizeUncpr,step); |
||||
printf("time = %u msec = %f sec\n\n",dwGetTick,dwGetTick/(double)1000.); |
||||
} |
||||
|
||||
if (lSizeUncpr==lFileSize) |
||||
{ |
||||
if (memcmp(FilePtr,UncprPtr,lFileSize)==0) |
||||
printf("compare ok\n"); |
||||
|
||||
} |
||||
|
||||
return 0; |
||||
|
||||
} |
||||
|
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <windows.h> |
||||
#include "zlib.h" |
||||
|
||||
int ReadFileMemory(const char* filename,long* plFileSize,void** pFilePtr) |
||||
{ |
||||
FILE* stream; |
||||
void* ptr; |
||||
int retVal=1; |
||||
stream=fopen(filename, "rb"); |
||||
if (stream==NULL) |
||||
return 0; |
||||
|
||||
fseek(stream,0,SEEK_END); |
||||
|
||||
*plFileSize=ftell(stream); |
||||
fseek(stream,0,SEEK_SET); |
||||
ptr=malloc((*plFileSize)+1); |
||||
if (ptr==NULL) |
||||
retVal=0; |
||||
else |
||||
{ |
||||
if (fread(ptr, 1, *plFileSize,stream) != (*plFileSize)) |
||||
retVal=0; |
||||
} |
||||
fclose(stream); |
||||
*pFilePtr=ptr; |
||||
return retVal; |
||||
} |
||||
|
||||
int main(int argc, char *argv[]) |
||||
{ |
||||
int BlockSizeCompress=0x8000; |
||||
int BlockSizeUncompress=0x8000; |
||||
int cprLevel=Z_DEFAULT_COMPRESSION ; |
||||
long lFileSize; |
||||
unsigned char* FilePtr; |
||||
long lBufferSizeCpr; |
||||
long lBufferSizeUncpr; |
||||
long lCompressedSize=0; |
||||
unsigned char* CprPtr; |
||||
unsigned char* UncprPtr; |
||||
long lSizeCpr,lSizeUncpr; |
||||
DWORD dwGetTick; |
||||
|
||||
if (argc<=1) |
||||
{ |
||||
printf("run TestZlib <File> [BlockSizeCompress] [BlockSizeUncompress] [compres. level]\n"); |
||||
return 0; |
||||
} |
||||
|
||||
if (ReadFileMemory(argv[1],&lFileSize,&FilePtr)==0) |
||||
{ |
||||
printf("error reading %s\n",argv[1]); |
||||
return 1; |
||||
} |
||||
else printf("file %s read, %u bytes\n",argv[1],lFileSize); |
||||
|
||||
if (argc>=3) |
||||
BlockSizeCompress=atol(argv[2]); |
||||
|
||||
if (argc>=4) |
||||
BlockSizeUncompress=atol(argv[3]); |
||||
|
||||
if (argc>=5) |
||||
cprLevel=(int)atol(argv[4]); |
||||
|
||||
lBufferSizeCpr = lFileSize + (lFileSize/0x10) + 0x200; |
||||
lBufferSizeUncpr = lBufferSizeCpr; |
||||
|
||||
CprPtr=(unsigned char*)malloc(lBufferSizeCpr + BlockSizeCompress); |
||||
UncprPtr=(unsigned char*)malloc(lBufferSizeUncpr + BlockSizeUncompress); |
||||
|
||||
dwGetTick=GetTickCount(); |
||||
{ |
||||
z_stream zcpr; |
||||
int ret=Z_OK; |
||||
long lOrigToDo = lFileSize; |
||||
long lOrigDone = 0; |
||||
int step=0; |
||||
memset(&zcpr,0,sizeof(z_stream)); |
||||
deflateInit(&zcpr,cprLevel); |
||||
|
||||
zcpr.next_in = FilePtr; |
||||
zcpr.next_out = CprPtr; |
||||
|
||||
|
||||
do |
||||
{ |
||||
long all_read_before = zcpr.total_in; |
||||
zcpr.avail_in = min(lOrigToDo,BlockSizeCompress); |
||||
zcpr.avail_out = BlockSizeCompress; |
||||
ret=deflate(&zcpr,(zcpr.avail_in==lOrigToDo) ? Z_FINISH : Z_SYNC_FLUSH); |
||||
lOrigDone += (zcpr.total_in-all_read_before); |
||||
lOrigToDo -= (zcpr.total_in-all_read_before); |
||||
step++; |
||||
} while (ret==Z_OK); |
||||
|
||||
lSizeCpr=zcpr.total_out; |
||||
deflateEnd(&zcpr); |
||||
dwGetTick=GetTickCount()-dwGetTick; |
||||
printf("total compress size = %u, in %u step\n",lSizeCpr,step); |
||||
printf("time = %u msec = %f sec\n\n",dwGetTick,dwGetTick/(double)1000.); |
||||
} |
||||
|
||||
dwGetTick=GetTickCount(); |
||||
{ |
||||
z_stream zcpr; |
||||
int ret=Z_OK; |
||||
long lOrigToDo = lSizeCpr; |
||||
long lOrigDone = 0; |
||||
int step=0; |
||||
memset(&zcpr,0,sizeof(z_stream)); |
||||
inflateInit(&zcpr); |
||||
|
||||
zcpr.next_in = CprPtr; |
||||
zcpr.next_out = UncprPtr; |
||||
|
||||
|
||||
do |
||||
{ |
||||
long all_read_before = zcpr.total_in; |
||||
zcpr.avail_in = min(lOrigToDo,BlockSizeUncompress); |
||||
zcpr.avail_out = BlockSizeUncompress; |
||||
ret=inflate(&zcpr,Z_SYNC_FLUSH); |
||||
lOrigDone += (zcpr.total_in-all_read_before); |
||||
lOrigToDo -= (zcpr.total_in-all_read_before); |
||||
step++; |
||||
} while (ret==Z_OK); |
||||
|
||||
lSizeUncpr=zcpr.total_out; |
||||
inflateEnd(&zcpr); |
||||
dwGetTick=GetTickCount()-dwGetTick; |
||||
printf("total uncompress size = %u, in %u step\n",lSizeUncpr,step); |
||||
printf("time = %u msec = %f sec\n\n",dwGetTick,dwGetTick/(double)1000.); |
||||
} |
||||
|
||||
if (lSizeUncpr==lFileSize) |
||||
{ |
||||
if (memcmp(FilePtr,UncprPtr,lFileSize)==0) |
||||
printf("compare ok\n"); |
||||
|
||||
} |
||||
|
||||
return 0; |
||||
|
||||
} |
||||
|
||||
@ -1,14 +1,14 @@ |
||||
CC=cc
|
||||
CFLAGS=-g
|
||||
|
||||
untgz: untgz.o ../../libz.a |
||||
$(CC) $(CFLAGS) -o untgz untgz.o -L../.. -lz
|
||||
untgz: untgz.o ../../libz.a |
||||
$(CC) $(CFLAGS) -o untgz untgz.o -L../.. -lz
|
||||
|
||||
untgz.o: untgz.c ../../zlib.h |
||||
$(CC) $(CFLAGS) -c -I../.. untgz.c
|
||||
|
||||
../../libz.a: |
||||
cd ../..; make
|
||||
cd ../..; ./configure; make
|
||||
|
||||
clean: |
||||
rm -f untgz untgz.o *~
|
||||
|
||||
@ -0,0 +1,17 @@ |
||||
CC=cl
|
||||
CFLAGS=-MD
|
||||
|
||||
untgz.exe: untgz.obj ..\..\zlib.lib |
||||
$(CC) $(CFLAGS) untgz.obj ..\..\zlib.lib
|
||||
|
||||
untgz.obj: untgz.c ..\..\zlib.h |
||||
$(CC) $(CFLAGS) -c -I..\.. untgz.c
|
||||
|
||||
..\..\zlib.lib: |
||||
cd ..\..
|
||||
$(MAKE) -f win32\makefile.msc
|
||||
cd contrib\untgz
|
||||
|
||||
clean: |
||||
-del untgz.obj
|
||||
-del untgz.exe
|
||||
@ -1,63 +0,0 @@ |
||||
# Makefile for zlib. Modified for mingw32 |
||||
# For conditions of distribution and use, see copyright notice in zlib.h |
||||
|
||||
# To compile, |
||||
# |
||||
# make -fmakefile.w32 |
||||
# |
||||
|
||||
CC=gcc |
||||
|
||||
# Generate dependencies (see end of the file) |
||||
|
||||
CPPFLAGS=-MMD |
||||
|
||||
#CFLAGS=-MMD -O |
||||
#CFLAGS=-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7 |
||||
#CFLAGS=-MMD -g -DDEBUG |
||||
CFLAGS=-O3 $(BUTT) -Wall -Wwrite-strings -Wpointer-arith -Wconversion \ |
||||
-Wstrict-prototypes -Wmissing-prototypes |
||||
|
||||
# If cp.exe is not found, replace with copy /Y . |
||||
CP=cp -f |
||||
|
||||
# The default value of RM is "rm -f." |
||||
# If "rm.exe" is not found, uncomment: |
||||
# RM=del |
||||
|
||||
LD=gcc |
||||
LDLIBS=-L. -lz |
||||
LDFLAGS=-s |
||||
|
||||
|
||||
INCL=zlib.h zconf.h |
||||
LIBS=libz.a |
||||
|
||||
AR=ar rcs |
||||
|
||||
OBJS = adler32.o compress.o crc32.o gzio.o uncompr.o deflate.o trees.o \ |
||||
zutil.o inflate.o infblock.o inftrees.o infcodes.o infutil.o \ |
||||
inffast.o |
||||
|
||||
TEST_OBJS = minigzip.o untgz.o |
||||
|
||||
all: minigzip.exe untgz.exe |
||||
|
||||
rebuild: clean all |
||||
|
||||
libz.a: $(OBJS) |
||||
$(AR) $@ $(OBJS) |
||||
|
||||
%.exe : %.o $(LIBS) |
||||
$(LD) $(LDFLAGS) -o $@ $< $(LDLIBS) |
||||
|
||||
.PHONY : clean |
||||
|
||||
clean: |
||||
$(RM) *.d *.o *.exe libz.a foo.gz |
||||
|
||||
DEPS := $(wildcard *.d) |
||||
ifneq ($(DEPS),) |
||||
include $(DEPS) |
||||
endif |
||||
|
||||
@ -1,94 +0,0 @@ |
||||
LIBRARY "zlib" |
||||
|
||||
DESCRIPTION '"""zlib data compression library"""' |
||||
|
||||
EXETYPE WINDOWS |
||||
|
||||
VERSION 1.21 |
||||
|
||||
CODE PRELOAD MOVEABLE DISCARDABLE |
||||
DATA PRELOAD MOVEABLE SINGLE |
||||
|
||||
|
||||
HEAPSIZE 32768,8192 |
||||
|
||||
EXPORTS |
||||
adler32 @1 |
||||
compress @2 |
||||
crc32 @3 |
||||
deflate @4 |
||||
deflateCopy @5 |
||||
deflateEnd @6 |
||||
deflateInit2_ @7 |
||||
deflateInit_ @8 |
||||
deflateParams @9 |
||||
deflateReset @10 |
||||
deflateSetDictionary @11 |
||||
gzclose @12 |
||||
gzdopen @13 |
||||
gzerror @14 |
||||
gzflush @15 |
||||
gzopen @16 |
||||
gzread @17 |
||||
gzwrite @18 |
||||
inflate @19 |
||||
inflateEnd @20 |
||||
inflateInit2_ @21 |
||||
inflateInit_ @22 |
||||
inflateReset @23 |
||||
inflateSetDictionary @24 |
||||
inflateSync @25 |
||||
uncompress @26 |
||||
zlibVersion @27 |
||||
_gzprintf @28 |
||||
gzputc @29 |
||||
gzgetc @30 |
||||
gzseek @31 |
||||
gzrewind @32 |
||||
gztell @33 |
||||
gzeof @34 |
||||
gzsetparams @35 |
||||
zError @36 |
||||
inflateSyncPoint @37 |
||||
get_crc_table @38 |
||||
compress2 @39 |
||||
gzputs @40 |
||||
gzgets @41 |
||||
inflateCopy @42 |
||||
inflateBackInit_ @43 |
||||
inflateBack @44 |
||||
inflateBackEnd @45 |
||||
compressBound @46 |
||||
|
||||
unzOpen @61 |
||||
unzClose @62 |
||||
unzGetGlobalInfo @63 |
||||
unzGetCurrentFileInfo @64 |
||||
unzGoToFirstFile @65 |
||||
unzGoToNextFile @66 |
||||
unzOpenCurrentFile @67 |
||||
unzReadCurrentFile @68 |
||||
unzOpenCurrentFile3 @69 |
||||
unztell @70 |
||||
unzeof @71 |
||||
unzCloseCurrentFile @72 |
||||
unzGetGlobalComment @73 |
||||
unzStringFileNameCompare @74 |
||||
unzLocateFile @75 |
||||
unzGetLocalExtrafield @76 |
||||
unzOpen2 @77 |
||||
unzOpenCurrentFile2 @78 |
||||
unzOpenCurrentFilePassword @79 |
||||
|
||||
zipOpen @80 |
||||
zipOpenNewFileInZip @81 |
||||
zipWriteInFileInZip @82 |
||||
zipCloseFileInZip @83 |
||||
zipClose @84 |
||||
zipOpenNewFileInZip2 @86 |
||||
zipCloseFileInZipRaw @87 |
||||
zipOpen2 @88 |
||||
zipOpenNewFileInZip3 @89 |
||||
|
||||
unzGetFilePos @100 |
||||
unzGoToFilePos @101 |
||||
@ -1,259 +0,0 @@ |
||||
# Microsoft Visual C++ generated build script - Do not modify
|
||||
|
||||
PROJ = ZLIB16
|
||||
DEBUG = 0
|
||||
PROGTYPE = 1
|
||||
CALLER =
|
||||
ARGS =
|
||||
DLLS =
|
||||
D_RCDEFINES = -d_DEBUG
|
||||
R_RCDEFINES = -dNDEBUG
|
||||
ORIGIN = MSVC
|
||||
ORIGIN_VER = 1.00
|
||||
PROJPATH = c:\zlib\
|
||||
USEMFC = 0
|
||||
CC = cl
|
||||
CPP = cl
|
||||
CXX = cl
|
||||
CCREATEPCHFLAG =
|
||||
CPPCREATEPCHFLAG =
|
||||
CUSEPCHFLAG =
|
||||
CPPUSEPCHFLAG =
|
||||
FIRSTC = ADLER32.C
|
||||
FIRSTCPP =
|
||||
RC = rc
|
||||
CFLAGS_D_WDLL = /nologo /G2 /W3 /Zi /ALw /Od /D "_DEBUG" /D "WINDOWS" /D "ZLIB_DLL" /D "ZLIB_INTERNAL" /FR /GD /Fd"ZLIB.PDB"
|
||||
CFLAGS_R_WDLL = /nologo /W3 /ALw /O1 /D "NDEBUG" /D "WINDOWS" /D "ZLIB_DLL" /D "ZLIB_INTERNAL" /FR /GD
|
||||
LFLAGS_D_WDLL = /NOLOGO /ONERROR:NOEXE /NOD /PACKC:61440 /CO /NOE /ALIGN:16 /MAP:FULL
|
||||
LFLAGS_R_WDLL = /NOLOGO /ONERROR:NOEXE /NOD /PACKC:61440 /NOE /ALIGN:16 /MAP:FULL
|
||||
LIBS_D_WDLL = oldnames libw commdlg shell olecli olesvr ldllcew
|
||||
LIBS_R_WDLL = oldnames libw commdlg shell olecli olesvr ldllcew
|
||||
RCFLAGS = /nologo
|
||||
RESFLAGS = /nologo
|
||||
RUNFLAGS =
|
||||
DEFFILE = ZLIB16.DEF
|
||||
OBJS_EXT =
|
||||
LIBS_EXT =
|
||||
!if "$(DEBUG)" == "1" |
||||
CFLAGS = $(CFLAGS_D_WDLL)
|
||||
LFLAGS = $(LFLAGS_D_WDLL)
|
||||
LIBS = $(LIBS_D_WDLL)
|
||||
MAPFILE = nul
|
||||
RCDEFINES = $(D_RCDEFINES)
|
||||
!else |
||||
CFLAGS = $(CFLAGS_R_WDLL)
|
||||
LFLAGS = $(LFLAGS_R_WDLL)
|
||||
LIBS = $(LIBS_R_WDLL)
|
||||
MAPFILE = nul
|
||||
RCDEFINES = $(R_RCDEFINES)
|
||||
!endif |
||||
!if [if exist MSVC.BND del MSVC.BND] |
||||
!endif |
||||
SBRS = ADLER32.SBR \
|
||||
COMPRESS.SBR \
|
||||
CRC32.SBR \
|
||||
DEFLATE.SBR \
|
||||
GZIO.SBR \
|
||||
INFFAST.SBR \
|
||||
INFLATE.SBR \
|
||||
TREES.SBR \
|
||||
UNCOMPR.SBR \
|
||||
ZUTIL.SBR \
|
||||
ZIP.SBR \
|
||||
UNZIP.SBR \
|
||||
INFBACK.SBR \
|
||||
IOAPI.SBR \
|
||||
INFTREES.SBR
|
||||
|
||||
|
||||
ADLER32_DEP = c:\zlib\zlib.h \
|
||||
c:\zlib\zconf.h
|
||||
|
||||
|
||||
COMPRESS_DEP = c:\zlib\zlib.h \
|
||||
c:\zlib\zconf.h
|
||||
|
||||
|
||||
CRC32_DEP = c:\zlib\zutil.h \
|
||||
c:\zlib\zlib.h \
|
||||
c:\zlib\zconf.h \
|
||||
c:\zlib\crc32.h
|
||||
|
||||
|
||||
DEFLATE_DEP = c:\zlib\deflate.h \
|
||||
c:\zlib\zutil.h \
|
||||
c:\zlib\zlib.h \
|
||||
c:\zlib\zconf.h
|
||||
|
||||
|
||||
GZIO_DEP = c:\zlib\zutil.h \
|
||||
c:\zlib\zlib.h \
|
||||
c:\zlib\zconf.h
|
||||
|
||||
|
||||
INFFAST_DEP = c:\zlib\zutil.h \
|
||||
c:\zlib\zlib.h \
|
||||
c:\zlib\zconf.h \
|
||||
c:\zlib\inftrees.h \
|
||||
c:\zlib\inflate.h \
|
||||
c:\zlib\inffast.h
|
||||
|
||||
|
||||
INFLATE_DEP = c:\zlib\zutil.h \
|
||||
c:\zlib\zlib.h \
|
||||
c:\zlib\zconf.h \
|
||||
c:\zlib\inftrees.h \
|
||||
c:\zlib\inflate.h \
|
||||
c:\zlib\inffast.h \
|
||||
c:\zlib\inffixed.h
|
||||
|
||||
|
||||
TREES_DEP = c:\zlib\deflate.h \
|
||||
c:\zlib\zutil.h \
|
||||
c:\zlib\zlib.h \
|
||||
c:\zlib\zconf.h \
|
||||
c:\zlib\trees.h
|
||||
|
||||
|
||||
UNCOMPR_DEP = c:\zlib\zlib.h \
|
||||
c:\zlib\zconf.h
|
||||
|
||||
|
||||
ZUTIL_DEP = c:\zlib\zutil.h \
|
||||
c:\zlib\zlib.h \
|
||||
c:\zlib\zconf.h
|
||||
|
||||
|
||||
ZLIB16_RCDEP =
|
||||
|
||||
ZIP_DEP = c:\zlib\zlib.h \
|
||||
c:\zlib\zconf.h \
|
||||
c:\zlib\zip.h \
|
||||
c:\zlib\ioapi.h \
|
||||
c:\zlib\crypt.h
|
||||
|
||||
|
||||
UNZIP_DEP = c:\zlib\zlib.h \
|
||||
c:\zlib\zconf.h \
|
||||
c:\zlib\unzip.h \
|
||||
c:\zlib\ioapi.h \
|
||||
c:\zlib\crypt.h
|
||||
|
||||
|
||||
INFBACK_DEP = c:\zlib\zutil.h \
|
||||
c:\zlib\zlib.h \
|
||||
c:\zlib\zconf.h \
|
||||
c:\zlib\inftrees.h \
|
||||
c:\zlib\inflate.h \
|
||||
c:\zlib\inffast.h \
|
||||
c:\zlib\inffixed.h
|
||||
|
||||
|
||||
IOAPI_DEP = c:\zlib\zlib.h \
|
||||
c:\zlib\zconf.h \
|
||||
c:\zlib\ioapi.h
|
||||
|
||||
|
||||
INFTREES_DEP = c:\zlib\zutil.h \
|
||||
c:\zlib\zlib.h \
|
||||
c:\zlib\zconf.h \
|
||||
c:\zlib\inftrees.h
|
||||
|
||||
|
||||
all: $(PROJ).DLL $(PROJ).BSC |
||||
|
||||
ADLER32.OBJ: ADLER32.C $(ADLER32_DEP) |
||||
$(CC) $(CFLAGS) $(CCREATEPCHFLAG) /c ADLER32.C
|
||||
|
||||
COMPRESS.OBJ: COMPRESS.C $(COMPRESS_DEP) |
||||
$(CC) $(CFLAGS) $(CUSEPCHFLAG) /c COMPRESS.C
|
||||
|
||||
CRC32.OBJ: CRC32.C $(CRC32_DEP) |
||||
$(CC) $(CFLAGS) $(CUSEPCHFLAG) /c CRC32.C
|
||||
|
||||
DEFLATE.OBJ: DEFLATE.C $(DEFLATE_DEP) |
||||
$(CC) $(CFLAGS) $(CUSEPCHFLAG) /c DEFLATE.C
|
||||
|
||||
GZIO.OBJ: GZIO.C $(GZIO_DEP) |
||||
$(CC) $(CFLAGS) $(CUSEPCHFLAG) /c GZIO.C
|
||||
|
||||
INFFAST.OBJ: INFFAST.C $(INFFAST_DEP) |
||||
$(CC) $(CFLAGS) $(CUSEPCHFLAG) /c INFFAST.C
|
||||
|
||||
INFLATE.OBJ: INFLATE.C $(INFLATE_DEP) |
||||
$(CC) $(CFLAGS) $(CUSEPCHFLAG) /c INFLATE.C
|
||||
|
||||
TREES.OBJ: TREES.C $(TREES_DEP) |
||||
$(CC) $(CFLAGS) $(CUSEPCHFLAG) /c TREES.C
|
||||
|
||||
UNCOMPR.OBJ: UNCOMPR.C $(UNCOMPR_DEP) |
||||
$(CC) $(CFLAGS) $(CUSEPCHFLAG) /c UNCOMPR.C
|
||||
|
||||
ZUTIL.OBJ: ZUTIL.C $(ZUTIL_DEP) |
||||
$(CC) $(CFLAGS) $(CUSEPCHFLAG) /c ZUTIL.C
|
||||
|
||||
ZLIB16.RES: ZLIB16.RC $(ZLIB16_RCDEP) |
||||
$(RC) $(RCFLAGS) $(RCDEFINES) -r ZLIB16.RC
|
||||
|
||||
ZIP.OBJ: ZIP.C $(ZIP_DEP) |
||||
$(CC) $(CFLAGS) $(CUSEPCHFLAG) /c ZIP.C
|
||||
|
||||
UNZIP.OBJ: UNZIP.C $(UNZIP_DEP) |
||||
$(CC) $(CFLAGS) $(CUSEPCHFLAG) /c UNZIP.C
|
||||
|
||||
INFBACK.OBJ: INFBACK.C $(INFBACK_DEP) |
||||
$(CC) $(CFLAGS) $(CUSEPCHFLAG) /c INFBACK.C
|
||||
|
||||
IOAPI.OBJ: IOAPI.C $(IOAPI_DEP) |
||||
$(CC) $(CFLAGS) $(CUSEPCHFLAG) /c IOAPI.C
|
||||
|
||||
INFTREES.OBJ: INFTREES.C $(INFTREES_DEP) |
||||
$(CC) $(CFLAGS) $(CUSEPCHFLAG) /c INFTREES.C
|
||||
|
||||
|
||||
$(PROJ).DLL:: ZLIB16.RES |
||||
|
||||
$(PROJ).DLL:: ADLER32.OBJ COMPRESS.OBJ CRC32.OBJ DEFLATE.OBJ GZIO.OBJ INFFAST.OBJ \
|
||||
INFLATE.OBJ TREES.OBJ UNCOMPR.OBJ ZUTIL.OBJ ZIP.OBJ UNZIP.OBJ INFBACK.OBJ IOAPI.OBJ \
|
||||
INFTREES.OBJ $(OBJS_EXT) $(DEFFILE)
|
||||
echo >NUL @<<$(PROJ).CRF
|
||||
ADLER32.OBJ + |
||||
COMPRESS.OBJ + |
||||
CRC32.OBJ + |
||||
DEFLATE.OBJ + |
||||
GZIO.OBJ + |
||||
INFFAST.OBJ + |
||||
INFLATE.OBJ + |
||||
TREES.OBJ + |
||||
UNCOMPR.OBJ + |
||||
ZUTIL.OBJ + |
||||
ZIP.OBJ + |
||||
UNZIP.OBJ + |
||||
INFBACK.OBJ + |
||||
IOAPI.OBJ + |
||||
INFTREES.OBJ + |
||||
$(OBJS_EXT) |
||||
$(PROJ).DLL |
||||
$(MAPFILE) |
||||
C:\MSVC\LIB\+ |
||||
C:\MSVC\MFC\LIB\+ |
||||
E:\PROGRAMFILES\MICROSOFTVISUALSTUDIO.NET\FRAMEWORKSDK\LIB\+ |
||||
$(LIBS) |
||||
$(DEFFILE); |
||||
<< |
||||
link $(LFLAGS) @$(PROJ).CRF
|
||||
$(RC) $(RESFLAGS) ZLIB16.RES $@
|
||||
@copy $(PROJ).CRF MSVC.BND
|
||||
implib /nowep $(PROJ).LIB $(PROJ).DLL
|
||||
|
||||
$(PROJ).DLL:: ZLIB16.RES |
||||
if not exist MSVC.BND $(RC) $(RESFLAGS) ZLIB16.RES $@
|
||||
|
||||
run: $(PROJ).DLL |
||||
$(PROJ) $(RUNFLAGS)
|
||||
|
||||
|
||||
$(PROJ).BSC: $(SBRS) |
||||
bscmake @<<
|
||||
/o$@ $(SBRS) |
||||
<< |
||||
@ -1,33 +0,0 @@ |
||||
#include <windows.h> |
||||
#include <ver.h> |
||||
|
||||
#define IDR_VERSION1 1 |
||||
IDR_VERSION1 VERSIONINFO MOVEABLE IMPURE LOADONCALL DISCARDABLE |
||||
FILEVERSION 1,2,1,0 |
||||
PRODUCTVERSION 1,2,1,0 |
||||
FILEFLAGSMASK VS_FFI_FILEFLAGSMASK |
||||
FILEFLAGS 0 |
||||
FILEOS VOS_DOS_WINDOWS16 |
||||
FILETYPE VFT_DLL |
||||
FILESUBTYPE 0 // not used |
||||
BEGIN |
||||
BLOCK "StringFileInfo" |
||||
BEGIN |
||||
BLOCK "040904E4" |
||||
//language ID = U.S. English, char set = Windows, Multilingual |
||||
|
||||
BEGIN |
||||
VALUE "FileDescription", "zlib data compression library\0" |
||||
VALUE "FileVersion", "1.2.1\0" |
||||
VALUE "InternalName", "zlib16\0" |
||||
VALUE "OriginalFilename", "zlib16.dll\0" |
||||
VALUE "ProductName", "ZLib16.DLL\0" |
||||
VALUE "Comments","DLL support by Alessandro Iacopetti & Gilles Vollant\0" |
||||
VALUE "LegalCopyright", "(C) 1995-2003 Jean-loup Gailly & Mark Adler\0" |
||||
END |
||||
END |
||||
BLOCK "VarFileInfo" |
||||
BEGIN |
||||
VALUE "Translation", 0x0409, 1252 |
||||
END |
||||
END |
||||
Binary file not shown.
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue