← Back to branch summary

~ubuntu-branches/ubuntu/utopic/critcl/utopic

« back to all changes in this revision

Viewing changes to examples/zlibwrap/zlib/contrib/pascal/zlibpas.pas

  • Committer: Package Import Robot
  • Author(s): Andrew Shadura
  • Date: 2013-05-11 00:08:06 UTC
  • Revision ID: package-import@ubuntu.com-20130511000806-7hq1zc3fnn0gat79
Tags: upstream-3.1.9
Import upstream version 3.1.9

Show diffs side-by-side

added added

removed removed

Lines of Context:
examples/zlibwrap/zlib/contrib/pascal/zlibpas.pas
 
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.5';
 
14
 
 
15
type
 
16
  alloc_func = function(opaque: Pointer; items, size: Integer): Pointer;
 
17
                 cdecl;
 
18
  free_func  = procedure(opaque, address: Pointer);
 
19
                 cdecl;
 
20
 
 
21
  in_func    = function(opaque: Pointer; var buf: PByte): Integer;
 
22
                 cdecl;
 
23
  out_func   = function(opaque: Pointer; buf: PByte; size: Integer): Integer;
 
24
                 cdecl;
 
25
 
 
26
  z_streamp = ^z_stream;
 
27
  z_stream = packed record
 
28
    next_in: PChar;       (* next input byte *)
 
29
    avail_in: Integer;    (* number of bytes available at next_in *)
 
30
    total_in: LongInt;    (* total nb of input bytes read so far *)
 
31
 
 
32
    next_out: PChar;      (* next output byte should be put there *)
 
33
    avail_out: Integer;   (* remaining free space at next_out *)
 
34
    total_out: LongInt;   (* total nb of bytes output so far *)
 
35
 
 
36
    msg: PChar;           (* last error message, NULL if no error *)
 
37
    state: Pointer;       (* not visible by applications *)
 
38
 
 
39
    zalloc: alloc_func;   (* used to allocate the internal state *)
 
40
    zfree: free_func;     (* used to free the internal state *)
 
41
    opaque: Pointer;      (* private data object passed to zalloc and zfree *)
 
42
 
 
43
    data_type: Integer;   (* best guess about the data type: ascii or binary *)
 
44
    adler: LongInt;       (* adler32 value of the uncompressed data *)
 
45
    reserved: LongInt;    (* reserved for future use *)
 
46
  end;
 
47
 
 
48
(* constants *)
 
49
const
 
50
  Z_NO_FLUSH      = 0;
 
51
  Z_PARTIAL_FLUSH = 1;
 
52
  Z_SYNC_FLUSH    = 2;
 
53
  Z_FULL_FLUSH    = 3;
 
54
  Z_FINISH        = 4;
 
55
 
 
56
  Z_OK            =  0;
 
57
  Z_STREAM_END    =  1;
 
58
  Z_NEED_DICT     =  2;
 
59
  Z_ERRNO         = -1;
 
60
  Z_STREAM_ERROR  = -2;
 
61
  Z_DATA_ERROR    = -3;
 
62
  Z_MEM_ERROR     = -4;
 
63
  Z_BUF_ERROR     = -5;
 
64
  Z_VERSION_ERROR = -6;
 
65
 
 
66
  Z_NO_COMPRESSION       =  0;
 
67
  Z_BEST_SPEED           =  1;
 
68
  Z_BEST_COMPRESSION     =  9;
 
69
  Z_DEFAULT_COMPRESSION  = -1;
 
70
 
 
71
  Z_FILTERED            = 1;
 
72
  Z_HUFFMAN_ONLY        = 2;
 
73
  Z_RLE                 = 3;
 
74
  Z_DEFAULT_STRATEGY    = 0;
 
75
 
 
76
  Z_BINARY   = 0;
 
77
  Z_ASCII    = 1;
 
78
  Z_UNKNOWN  = 2;
 
79
 
 
80
  Z_DEFLATED = 8;
 
81
 
 
82
(* basic functions *)
 
83
function zlibVersion: PChar;
 
84
function deflateInit(var strm: z_stream; level: Integer): Integer;
 
85
function deflate(var strm: z_stream; flush: Integer): Integer;
 
86
function deflateEnd(var strm: z_stream): Integer;
 
87
function inflateInit(var strm: z_stream): Integer;
 
88
function inflate(var strm: z_stream; flush: Integer): Integer;
 
89
function inflateEnd(var strm: z_stream): Integer;
 
90
 
 
91
(* advanced functions *)
 
92
function deflateInit2(var strm: z_stream; level, method, windowBits,
 
93
                      memLevel, strategy: Integer): Integer;
 
94
function deflateSetDictionary(var strm: z_stream; const dictionary: PChar;
 
95
                              dictLength: Integer): Integer;
 
96
function deflateCopy(var dest, source: z_stream): Integer;
 
97
function deflateReset(var strm: z_stream): Integer;
 
98
function deflateParams(var strm: z_stream; level, strategy: Integer): Integer;
 
99
function deflateBound(var strm: z_stream; sourceLen: LongInt): LongInt;
 
100
function deflatePrime(var strm: z_stream; bits, value: Integer): Integer;
 
101
function inflateInit2(var strm: z_stream; windowBits: Integer): Integer;
 
102
function inflateSetDictionary(var strm: z_stream; const dictionary: PChar;
 
103
                              dictLength: Integer): Integer;
 
104
function inflateSync(var strm: z_stream): Integer;
 
105
function inflateCopy(var dest, source: z_stream): Integer;
 
106
function inflateReset(var strm: z_stream): Integer;
 
107
function inflateBackInit(var strm: z_stream;
 
108
                         windowBits: Integer; window: PChar): Integer;
 
109
function inflateBack(var strm: z_stream; in_fn: in_func; in_desc: Pointer;
 
110
                     out_fn: out_func; out_desc: Pointer): Integer;
 
111
function inflateBackEnd(var strm: z_stream): Integer;
 
112
function zlibCompileFlags: LongInt;
 
113
 
 
114
(* utility functions *)
 
115
function compress(dest: PChar; var destLen: LongInt;
 
116
                  const source: PChar; sourceLen: LongInt): Integer;
 
117
function compress2(dest: PChar; var destLen: LongInt;
 
118
                  const source: PChar; sourceLen: LongInt;
 
119
                  level: Integer): Integer;
 
120
function compressBound(sourceLen: LongInt): LongInt;
 
121
function uncompress(dest: PChar; var destLen: LongInt;
 
122
                    const source: PChar; sourceLen: LongInt): Integer;
 
123
 
 
124
(* checksum functions *)
 
125
function adler32(adler: LongInt; const buf: PChar; len: Integer): LongInt;
 
126
function crc32(crc: LongInt; const buf: PChar; len: Integer): LongInt;
 
127
 
 
128
(* various hacks, don't look :) *)
 
129
function deflateInit_(var strm: z_stream; level: Integer;
 
130
                      const version: PChar; stream_size: Integer): Integer;
 
131
function inflateInit_(var strm: z_stream; const version: PChar;
 
132
                      stream_size: Integer): Integer;
 
133
function deflateInit2_(var strm: z_stream;
 
134
                       level, method, windowBits, memLevel, strategy: Integer;
 
135
                       const version: PChar; stream_size: Integer): Integer;
 
136
function inflateInit2_(var strm: z_stream; windowBits: Integer;
 
137
                       const version: PChar; stream_size: Integer): Integer;
 
138
function inflateBackInit_(var strm: z_stream;
 
139
                          windowBits: Integer; window: PChar;
 
140
                          const version: PChar; stream_size: Integer): Integer;
 
141
 
 
142
 
 
143
implementation
 
144
 
 
145
{$L adler32.obj}
 
146
{$L compress.obj}
 
147
{$L crc32.obj}
 
148
{$L deflate.obj}
 
149
{$L infback.obj}
 
150
{$L inffast.obj}
 
151
{$L inflate.obj}
 
152
{$L inftrees.obj}
 
153
{$L trees.obj}
 
154
{$L uncompr.obj}
 
155
{$L zutil.obj}
 
156
 
 
157
function adler32; external;
 
158
function compress; external;
 
159
function compress2; external;
 
160
function compressBound; external;
 
161
function crc32; external;
 
162
function deflate; external;
 
163
function deflateBound; external;
 
164
function deflateCopy; external;
 
165
function deflateEnd; external;
 
166
function deflateInit_; external;
 
167
function deflateInit2_; external;
 
168
function deflateParams; external;
 
169
function deflatePrime; external;
 
170
function deflateReset; external;
 
171
function deflateSetDictionary; external;
 
172
function inflate; external;
 
173
function inflateBack; external;
 
174
function inflateBackEnd; external;
 
175
function inflateBackInit_; external;
 
176
function inflateCopy; external;
 
177
function inflateEnd; external;
 
178
function inflateInit_; external;
 
179
function inflateInit2_; external;
 
180
function inflateReset; external;
 
181
function inflateSetDictionary; external;
 
182
function inflateSync; external;
 
183
function uncompress; external;
 
184
function zlibCompileFlags; external;
 
185
function zlibVersion; external;
 
186
 
 
187
function deflateInit(var strm: z_stream; level: Integer): Integer;
 
188
begin
 
189
  Result := deflateInit_(strm, level, ZLIB_VERSION, sizeof(z_stream));
 
190
end;
 
191
 
 
192
function deflateInit2(var strm: z_stream; level, method, windowBits, memLevel,
 
193
                      strategy: Integer): Integer;
 
194
begin
 
195
  Result := deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
 
196
                          ZLIB_VERSION, sizeof(z_stream));
 
197
end;
 
198
 
 
199
function inflateInit(var strm: z_stream): Integer;
 
200
begin
 
201
  Result := inflateInit_(strm, ZLIB_VERSION, sizeof(z_stream));
 
202
end;
 
203
 
 
204
function inflateInit2(var strm: z_stream; windowBits: Integer): Integer;
 
205
begin
 
206
  Result := inflateInit2_(strm, windowBits, ZLIB_VERSION, sizeof(z_stream));
 
207
end;
 
208
 
 
209
function inflateBackInit(var strm: z_stream;
 
210
                         windowBits: Integer; window: PChar): Integer;
 
211
begin
 
212
  Result := inflateBackInit_(strm, windowBits, window,
 
213
                             ZLIB_VERSION, sizeof(z_stream));
 
214
end;
 
215
 
 
216
function _malloc(Size: Integer): Pointer; cdecl;
 
217
begin
 
218
  GetMem(Result, Size);
 
219
end;
 
220
 
 
221
procedure _free(Block: Pointer); cdecl;
 
222
begin
 
223
  FreeMem(Block);
 
224
end;
 
225
 
 
226
procedure _memset(P: Pointer; B: Byte; count: Integer); cdecl;
 
227
begin
 
228
  FillChar(P^, count, B);
 
229
end;
 
230
 
 
231
procedure _memcpy(dest, source: Pointer; count: Integer); cdecl;
 
232
begin
 
233
  Move(source^, dest^, count);
 
234
end;
 
235
 
 
236
end.