PageRenderTime 45ms CodeModel.GetById 37ms app.highlight 4ms RepoModel.GetById 1ms app.codeStats 0ms

/StormLib/stormlib/zlib/contrib/pascal/zlibpas.pas

http://ghostcb.googlecode.com/
Pascal | 236 lines | 178 code | 35 blank | 23 comment | 0 complexity | 9d642adfa3206f574774cbf6410922e9 MD5 | raw file
  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
  8unit zlibpas;
  9
 10interface
 11
 12const
 13  ZLIB_VERSION = '1.2.3';
 14
 15type
 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 *)
 49const
 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 *)
 83function zlibVersion: PChar;
 84function deflateInit(var strm: z_stream; level: Integer): Integer;
 85function deflate(var strm: z_stream; flush: Integer): Integer;
 86function deflateEnd(var strm: z_stream): Integer;
 87function inflateInit(var strm: z_stream): Integer;
 88function inflate(var strm: z_stream; flush: Integer): Integer;
 89function inflateEnd(var strm: z_stream): Integer;
 90
 91(* advanced functions *)
 92function deflateInit2(var strm: z_stream; level, method, windowBits,
 93                      memLevel, strategy: Integer): Integer;
 94function deflateSetDictionary(var strm: z_stream; const dictionary: PChar;
 95                              dictLength: Integer): Integer;
 96function deflateCopy(var dest, source: z_stream): Integer;
 97function deflateReset(var strm: z_stream): Integer;
 98function deflateParams(var strm: z_stream; level, strategy: Integer): Integer;
 99function deflateBound(var strm: z_stream; sourceLen: LongInt): LongInt;
100function deflatePrime(var strm: z_stream; bits, value: Integer): Integer;
101function inflateInit2(var strm: z_stream; windowBits: Integer): Integer;
102function inflateSetDictionary(var strm: z_stream; const dictionary: PChar;
103                              dictLength: Integer): Integer;
104function inflateSync(var strm: z_stream): Integer;
105function inflateCopy(var dest, source: z_stream): Integer;
106function inflateReset(var strm: z_stream): Integer;
107function inflateBackInit(var strm: z_stream;
108                         windowBits: Integer; window: PChar): Integer;
109function inflateBack(var strm: z_stream; in_fn: in_func; in_desc: Pointer;
110                     out_fn: out_func; out_desc: Pointer): Integer;
111function inflateBackEnd(var strm: z_stream): Integer;
112function zlibCompileFlags: LongInt;
113
114(* utility functions *)
115function compress(dest: PChar; var destLen: LongInt;
116                  const source: PChar; sourceLen: LongInt): Integer;
117function compress2(dest: PChar; var destLen: LongInt;
118                  const source: PChar; sourceLen: LongInt;
119                  level: Integer): Integer;
120function compressBound(sourceLen: LongInt): LongInt;
121function uncompress(dest: PChar; var destLen: LongInt;
122                    const source: PChar; sourceLen: LongInt): Integer;
123
124(* checksum functions *)
125function adler32(adler: LongInt; const buf: PChar; len: Integer): LongInt;
126function crc32(crc: LongInt; const buf: PChar; len: Integer): LongInt;
127
128(* various hacks, don't look :) *)
129function deflateInit_(var strm: z_stream; level: Integer;
130                      const version: PChar; stream_size: Integer): Integer;
131function inflateInit_(var strm: z_stream; const version: PChar;
132                      stream_size: Integer): Integer;
133function deflateInit2_(var strm: z_stream;
134                       level, method, windowBits, memLevel, strategy: Integer;
135                       const version: PChar; stream_size: Integer): Integer;
136function inflateInit2_(var strm: z_stream; windowBits: Integer;
137                       const version: PChar; stream_size: Integer): Integer;
138function inflateBackInit_(var strm: z_stream;
139                          windowBits: Integer; window: PChar;
140                          const version: PChar; stream_size: Integer): Integer;
141
142
143implementation
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
157function adler32; external;
158function compress; external;
159function compress2; external;
160function compressBound; external;
161function crc32; external;
162function deflate; external;
163function deflateBound; external;
164function deflateCopy; external;
165function deflateEnd; external;
166function deflateInit_; external;
167function deflateInit2_; external;
168function deflateParams; external;
169function deflatePrime; external;
170function deflateReset; external;
171function deflateSetDictionary; external;
172function inflate; external;
173function inflateBack; external;
174function inflateBackEnd; external;
175function inflateBackInit_; external;
176function inflateCopy; external;
177function inflateEnd; external;
178function inflateInit_; external;
179function inflateInit2_; external;
180function inflateReset; external;
181function inflateSetDictionary; external;
182function inflateSync; external;
183function uncompress; external;
184function zlibCompileFlags; external;
185function zlibVersion; external;
186
187function deflateInit(var strm: z_stream; level: Integer): Integer;
188begin
189  Result := deflateInit_(strm, level, ZLIB_VERSION, sizeof(z_stream));
190end;
191
192function deflateInit2(var strm: z_stream; level, method, windowBits, memLevel,
193                      strategy: Integer): Integer;
194begin
195  Result := deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
196                          ZLIB_VERSION, sizeof(z_stream));
197end;
198
199function inflateInit(var strm: z_stream): Integer;
200begin
201  Result := inflateInit_(strm, ZLIB_VERSION, sizeof(z_stream));
202end;
203
204function inflateInit2(var strm: z_stream; windowBits: Integer): Integer;
205begin
206  Result := inflateInit2_(strm, windowBits, ZLIB_VERSION, sizeof(z_stream));
207end;
208
209function inflateBackInit(var strm: z_stream;
210                         windowBits: Integer; window: PChar): Integer;
211begin
212  Result := inflateBackInit_(strm, windowBits, window,
213                             ZLIB_VERSION, sizeof(z_stream));
214end;
215
216function _malloc(Size: Integer): Pointer; cdecl;
217begin
218  GetMem(Result, Size);
219end;
220
221procedure _free(Block: Pointer); cdecl;
222begin
223  FreeMem(Block);
224end;
225
226procedure _memset(P: Pointer; B: Byte; count: Integer); cdecl;
227begin
228  FillChar(P^, count, B);
229end;
230
231procedure _memcpy(dest, source: Pointer; count: Integer); cdecl;
232begin
233  Move(source^, dest^, count);
234end;
235
236end.