contrib/pascal/zlibpas.pas

(* 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.8';
  ZLIB_VERNUM  = $1280;

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;

  gz_headerp = ^gz_header;
  gz_header = packed record
    text: Integer;        (* true if compressed data believed to be text *)
    time: LongInt;        (* modification time *)
    xflags: Integer;      (* extra flags (not used when writing a gzip file) *)
    os: Integer;          (* operating system *)
    extra: PChar;         (* pointer to extra field or Z_NULL if none *)
    extra_len: Integer;   (* extra field length (valid if extra != Z_NULL) *)
    extra_max: Integer;   (* space at extra (only when reading header) *)
    name: PChar;          (* pointer to zero-terminated file name or Z_NULL *)
    name_max: Integer;    (* space at name (only when reading header) *)
    comment: PChar;       (* pointer to zero-terminated comment or Z_NULL *)
    comm_max: Integer;    (* space at comment (only when reading header) *)
    hcrc: Integer;        (* true if there was or will be a header crc *)
    done: Integer;        (* true when done reading gzip header *)
  end;

(* constants *)
const
  Z_NO_FLUSH      = 0;
  Z_PARTIAL_FLUSH = 1;
  Z_SYNC_FLUSH    = 2;
  Z_FULL_FLUSH    = 3;
  Z_FINISH        = 4;
  Z_BLOCK         = 5;
  Z_TREES         = 6;

  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_FIXED               = 4;
  Z_DEFAULT_STRATEGY    = 0;

  Z_BINARY   = 0;
  Z_TEXT     = 1;
  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 deflateTune(var strm: z_stream; good_length, max_lazy, nice_length, max_chain: Integer): Integer;
function deflateBound(var strm: z_stream; sourceLen: LongInt): LongInt;
function deflatePending(var strm: z_stream; var pending: Integer; var bits: Integer): Integer;
function deflatePrime(var strm: z_stream; bits, value: Integer): Integer;
function deflateSetHeader(var strm: z_stream; head: gz_header): Integer;
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 inflateReset2(var strm: z_stream; windowBits: Integer): Integer;
function inflatePrime(var strm: z_stream; bits, value: Integer): Integer;
function inflateMark(var strm: z_stream): LongInt;
function inflateGetHeader(var strm: z_stream; var head: gz_header): 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 adler32_combine(adler1, adler2, len2: LongInt): LongInt;
function crc32(crc: LongInt; const buf: PChar; len: Integer): LongInt;
function crc32_combine(crc1, crc2, len2: LongInt): 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 adler32_combine; external;
function compress; external;
function compress2; external;
function compressBound; external;
function crc32; external;
function crc32_combine; external;
function deflate; external;
function deflateBound; external;
function deflateCopy; external;
function deflateEnd; external;
function deflateInit_; external;
function deflateInit2_; external;
function deflateParams; external;
function deflatePending; external;
function deflatePrime; external;
function deflateReset; external;
function deflateSetDictionary; external;
function deflateSetHeader; external;
function deflateTune; external;
function inflate; external;
function inflateBack; external;
function inflateBackEnd; external;
function inflateBackInit_; external;
function inflateCopy; external;
function inflateEnd; external;
function inflateGetHeader; external;
function inflateInit_; external;
function inflateInit2_; external;
function inflateMark; external;
function inflatePrime; external;
function inflateReset; external;
function inflateReset2; 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.
Revision:	1096
Committed:	Sat Dec 30 14:40:33 2017 UTC (7 years, 10 months ago) by s10k
Content type:	text/x-pascal
File size:	10126 byte(s)
Log Message:	Added zlib, quazip, basicxmlsyntaxhighlighter, conditionalsemaphore and linenumberdisplay libraries. zlib and quazip are pre-compiled, but you can compile them yourself, just delete the dll files (or equivalent binary files to your OS)
#	Content
1	(* zlibpas -- Pascal interface to the zlib data compression library
2	*
3	* Copyright (C) 2003 Cosmin Truta.
4	* Derived from original sources by Bob Dellaca.
5	* For conditions of distribution and use, see copyright notice in readme.txt
6	*)
7
8	unit zlibpas;
9
10	interface
11
12	const
13	ZLIB_VERSION = '1.2.8';
14	ZLIB_VERNUM = $1280;
15
16	type
17	alloc_func = function(opaque: Pointer; items, size: Integer): Pointer;
18	cdecl;
19	free_func = procedure(opaque, address: Pointer);
20	cdecl;
21
22	in_func = function(opaque: Pointer; var buf: PByte): Integer;
23	cdecl;
24	out_func = function(opaque: Pointer; buf: PByte; size: Integer): Integer;
25	cdecl;
26
27	z_streamp = ^z_stream;
28	z_stream = packed record
29	next_in: PChar; (* next input byte *)
30	avail_in: Integer; (* number of bytes available at next_in *)
31	total_in: LongInt; (* total nb of input bytes read so far *)
32
33	next_out: PChar; (* next output byte should be put there *)
34	avail_out: Integer; (* remaining free space at next_out *)
35	total_out: LongInt; (* total nb of bytes output so far *)
36
37	msg: PChar; (* last error message, NULL if no error *)
38	state: Pointer; (* not visible by applications *)
39
40	zalloc: alloc_func; (* used to allocate the internal state *)
41	zfree: free_func; (* used to free the internal state *)
42	opaque: Pointer; (* private data object passed to zalloc and zfree *)
43
44	data_type: Integer; (* best guess about the data type: ascii or binary *)
45	adler: LongInt; (* adler32 value of the uncompressed data *)
46	reserved: LongInt; (* reserved for future use *)
47	end;
48
49	gz_headerp = ^gz_header;
50	gz_header = packed record
51	text: Integer; (* true if compressed data believed to be text *)
52	time: LongInt; (* modification time *)
53	xflags: Integer; (* extra flags (not used when writing a gzip file) *)
54	os: Integer; (* operating system *)
55	extra: PChar; (* pointer to extra field or Z_NULL if none *)
56	extra_len: Integer; (* extra field length (valid if extra != Z_NULL) *)
57	extra_max: Integer; (* space at extra (only when reading header) *)
58	name: PChar; (* pointer to zero-terminated file name or Z_NULL *)
59	name_max: Integer; (* space at name (only when reading header) *)
60	comment: PChar; (* pointer to zero-terminated comment or Z_NULL *)
61	comm_max: Integer; (* space at comment (only when reading header) *)
62	hcrc: Integer; (* true if there was or will be a header crc *)
63	done: Integer; (* true when done reading gzip header *)
64	end;
65
66	(* constants *)
67	const
68	Z_NO_FLUSH = 0;
69	Z_PARTIAL_FLUSH = 1;
70	Z_SYNC_FLUSH = 2;
71	Z_FULL_FLUSH = 3;
72	Z_FINISH = 4;
73	Z_BLOCK = 5;
74	Z_TREES = 6;
75
76	Z_OK = 0;
77	Z_STREAM_END = 1;
78	Z_NEED_DICT = 2;
79	Z_ERRNO = -1;
80	Z_STREAM_ERROR = -2;
81	Z_DATA_ERROR = -3;
82	Z_MEM_ERROR = -4;
83	Z_BUF_ERROR = -5;
84	Z_VERSION_ERROR = -6;
85
86	Z_NO_COMPRESSION = 0;
87	Z_BEST_SPEED = 1;
88	Z_BEST_COMPRESSION = 9;
89	Z_DEFAULT_COMPRESSION = -1;
90
91	Z_FILTERED = 1;
92	Z_HUFFMAN_ONLY = 2;
93	Z_RLE = 3;
94	Z_FIXED = 4;
95	Z_DEFAULT_STRATEGY = 0;
96
97	Z_BINARY = 0;
98	Z_TEXT = 1;
99	Z_ASCII = 1;
100	Z_UNKNOWN = 2;
101
102	Z_DEFLATED = 8;
103
104	(* basic functions *)
105	function zlibVersion: PChar;
106	function deflateInit(var strm: z_stream; level: Integer): Integer;
107	function deflate(var strm: z_stream; flush: Integer): Integer;
108	function deflateEnd(var strm: z_stream): Integer;
109	function inflateInit(var strm: z_stream): Integer;
110	function inflate(var strm: z_stream; flush: Integer): Integer;
111	function inflateEnd(var strm: z_stream): Integer;
112
113	(* advanced functions *)
114	function deflateInit2(var strm: z_stream; level, method, windowBits,
115	memLevel, strategy: Integer): Integer;
116	function deflateSetDictionary(var strm: z_stream; const dictionary: PChar;
117	dictLength: Integer): Integer;
118	function deflateCopy(var dest, source: z_stream): Integer;
119	function deflateReset(var strm: z_stream): Integer;
120	function deflateParams(var strm: z_stream; level, strategy: Integer): Integer;
121	function deflateTune(var strm: z_stream; good_length, max_lazy, nice_length, max_chain: Integer): Integer;
122	function deflateBound(var strm: z_stream; sourceLen: LongInt): LongInt;
123	function deflatePending(var strm: z_stream; var pending: Integer; var bits: Integer): Integer;
124	function deflatePrime(var strm: z_stream; bits, value: Integer): Integer;
125	function deflateSetHeader(var strm: z_stream; head: gz_header): Integer;
126	function inflateInit2(var strm: z_stream; windowBits: Integer): Integer;
127	function inflateSetDictionary(var strm: z_stream; const dictionary: PChar;
128	dictLength: Integer): Integer;
129	function inflateSync(var strm: z_stream): Integer;
130	function inflateCopy(var dest, source: z_stream): Integer;
131	function inflateReset(var strm: z_stream): Integer;
132	function inflateReset2(var strm: z_stream; windowBits: Integer): Integer;
133	function inflatePrime(var strm: z_stream; bits, value: Integer): Integer;
134	function inflateMark(var strm: z_stream): LongInt;
135	function inflateGetHeader(var strm: z_stream; var head: gz_header): Integer;
136	function inflateBackInit(var strm: z_stream;
137	windowBits: Integer; window: PChar): Integer;
138	function inflateBack(var strm: z_stream; in_fn: in_func; in_desc: Pointer;
139	out_fn: out_func; out_desc: Pointer): Integer;
140	function inflateBackEnd(var strm: z_stream): Integer;
141	function zlibCompileFlags: LongInt;
142
143	(* utility functions *)
144	function compress(dest: PChar; var destLen: LongInt;
145	const source: PChar; sourceLen: LongInt): Integer;
146	function compress2(dest: PChar; var destLen: LongInt;
147	const source: PChar; sourceLen: LongInt;
148	level: Integer): Integer;
149	function compressBound(sourceLen: LongInt): LongInt;
150	function uncompress(dest: PChar; var destLen: LongInt;
151	const source: PChar; sourceLen: LongInt): Integer;
152
153	(* checksum functions *)
154	function adler32(adler: LongInt; const buf: PChar; len: Integer): LongInt;
155	function adler32_combine(adler1, adler2, len2: LongInt): LongInt;
156	function crc32(crc: LongInt; const buf: PChar; len: Integer): LongInt;
157	function crc32_combine(crc1, crc2, len2: LongInt): LongInt;
158
159	(* various hacks, don't look :) *)
160	function deflateInit_(var strm: z_stream; level: Integer;
161	const version: PChar; stream_size: Integer): Integer;
162	function inflateInit_(var strm: z_stream; const version: PChar;
163	stream_size: Integer): Integer;
164	function deflateInit2_(var strm: z_stream;
165	level, method, windowBits, memLevel, strategy: Integer;
166	const version: PChar; stream_size: Integer): Integer;
167	function inflateInit2_(var strm: z_stream; windowBits: Integer;
168	const version: PChar; stream_size: Integer): Integer;
169	function inflateBackInit_(var strm: z_stream;
170	windowBits: Integer; window: PChar;
171	const version: PChar; stream_size: Integer): Integer;
172
173
174	implementation
175
176	{$L adler32.obj}
177	{$L compress.obj}
178	{$L crc32.obj}
179	{$L deflate.obj}
180	{$L infback.obj}
181	{$L inffast.obj}
182	{$L inflate.obj}
183	{$L inftrees.obj}
184	{$L trees.obj}
185	{$L uncompr.obj}
186	{$L zutil.obj}
187
188	function adler32; external;
189	function adler32_combine; external;
190	function compress; external;
191	function compress2; external;
192	function compressBound; external;
193	function crc32; external;
194	function crc32_combine; external;
195	function deflate; external;
196	function deflateBound; external;
197	function deflateCopy; external;
198	function deflateEnd; external;
199	function deflateInit_; external;
200	function deflateInit2_; external;
201	function deflateParams; external;
202	function deflatePending; external;
203	function deflatePrime; external;
204	function deflateReset; external;
205	function deflateSetDictionary; external;
206	function deflateSetHeader; external;
207	function deflateTune; external;
208	function inflate; external;
209	function inflateBack; external;
210	function inflateBackEnd; external;
211	function inflateBackInit_; external;
212	function inflateCopy; external;
213	function inflateEnd; external;
214	function inflateGetHeader; external;
215	function inflateInit_; external;
216	function inflateInit2_; external;
217	function inflateMark; external;
218	function inflatePrime; external;
219	function inflateReset; external;
220	function inflateReset2; external;
221	function inflateSetDictionary; external;
222	function inflateSync; external;
223	function uncompress; external;
224	function zlibCompileFlags; external;
225	function zlibVersion; external;
226
227	function deflateInit(var strm: z_stream; level: Integer): Integer;
228	begin
229	Result := deflateInit_(strm, level, ZLIB_VERSION, sizeof(z_stream));
230	end;
231
232	function deflateInit2(var strm: z_stream; level, method, windowBits, memLevel,
233	strategy: Integer): Integer;
234	begin
235	Result := deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
236	ZLIB_VERSION, sizeof(z_stream));
237	end;
238
239	function inflateInit(var strm: z_stream): Integer;
240	begin
241	Result := inflateInit_(strm, ZLIB_VERSION, sizeof(z_stream));
242	end;
243
244	function inflateInit2(var strm: z_stream; windowBits: Integer): Integer;
245	begin
246	Result := inflateInit2_(strm, windowBits, ZLIB_VERSION, sizeof(z_stream));
247	end;
248
249	function inflateBackInit(var strm: z_stream;
250	windowBits: Integer; window: PChar): Integer;
251	begin
252	Result := inflateBackInit_(strm, windowBits, window,
253	ZLIB_VERSION, sizeof(z_stream));
254	end;
255
256	function _malloc(Size: Integer): Pointer; cdecl;
257	begin
258	GetMem(Result, Size);
259	end;
260
261	procedure _free(Block: Pointer); cdecl;
262	begin
263	FreeMem(Block);
264	end;
265
266	procedure _memset(P: Pointer; B: Byte; count: Integer); cdecl;
267	begin
268	FillChar(P^, count, B);
269	end;
270
271	procedure _memcpy(dest, source: Pointer; count: Integer); cdecl;
272	begin
273	Move(source^, dest^, count);
274	end;
275
276	end.