/[pngwrite]/trunk/zinflate.pas
ViewVC logotype

Annotation of /trunk/zinflate.pas

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1 - (hide annotations)
Sun Apr 13 19:38:04 2008 UTC (13 years, 9 months ago) by plugwash
File size: 22970 byte(s)
initial import

1 plugwash 1 Unit zInflate;
2    
3     { inflate.c -- zlib interface to inflate modules
4     Copyright (C) 1995-1998 Mark Adler
5    
6     Pascal tranlastion
7     Copyright (C) 1998 by Jacques Nomssi Nzali
8     For conditions of distribution and use, see copyright notice in readme.paszlib
9     }
10    
11     interface
12    
13     {$I zconf.inc}
14    
15     uses
16     zutil, zlib, infblock, infutil;
17    
18     function inflateInit(var z : z_stream) : int;
19    
20     { Initializes the internal stream state for decompression. The fields
21     zalloc, zfree and opaque must be initialized before by the caller. If
22     zalloc and zfree are set to Z_NULL, inflateInit updates them to use default
23     allocation functions.
24    
25     inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
26     enough memory, Z_VERSION_ERROR if the zlib library version is incompatible
27     with the version assumed by the caller. msg is set to null if there is no
28     error message. inflateInit does not perform any decompression: this will be
29     done by inflate(). }
30    
31    
32    
33     function inflateInit_(z : z_streamp;
34     const version : string;
35     stream_size : int) : int;
36    
37    
38     function inflateInit2_(var z: z_stream;
39     w : int;
40     const version : string;
41     stream_size : int) : int;
42    
43     function inflateInit2(var z: z_stream;
44     windowBits : int) : int;
45    
46     {
47     This is another version of inflateInit with an extra parameter. The
48     fields next_in, avail_in, zalloc, zfree and opaque must be initialized
49     before by the caller.
50    
51     The windowBits parameter is the base two logarithm of the maximum window
52     size (the size of the history buffer). It should be in the range 8..15 for
53     this version of the library. The default value is 15 if inflateInit is used
54     instead. If a compressed stream with a larger window size is given as
55     input, inflate() will return with the error code Z_DATA_ERROR instead of
56     trying to allocate a larger window.
57    
58     inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
59     memory, Z_STREAM_ERROR if a parameter is invalid (such as a negative
60     memLevel). msg is set to null if there is no error message. inflateInit2
61     does not perform any decompression apart from reading the zlib header if
62     present: this will be done by inflate(). (So next_in and avail_in may be
63     modified, but next_out and avail_out are unchanged.)
64     }
65    
66    
67    
68     function inflateEnd(var z : z_stream) : int;
69    
70     {
71     All dynamically allocated data structures for this stream are freed.
72     This function discards any unprocessed input and does not flush any
73     pending output.
74    
75     inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
76     was inconsistent. In the error case, msg may be set but then points to a
77     static string (which must not be deallocated).
78     }
79    
80     function inflateReset(var z : z_stream) : int;
81    
82     {
83     This function is equivalent to inflateEnd followed by inflateInit,
84     but does not free and reallocate all the internal decompression state.
85     The stream will keep attributes that may have been set by inflateInit2.
86    
87     inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
88     stream state was inconsistent (such as zalloc or state being NULL).
89     }
90    
91    
92     function inflate(var z : z_stream;
93     f : int) : int;
94     {
95     inflate decompresses as much data as possible, and stops when the input
96     buffer becomes empty or the output buffer becomes full. It may introduce
97     some output latency (reading input without producing any output)
98     except when forced to flush.
99    
100     The detailed semantics are as follows. inflate performs one or both of the
101     following actions:
102    
103     - Decompress more input starting at next_in and update next_in and avail_in
104     accordingly. If not all input can be processed (because there is not
105     enough room in the output buffer), next_in is updated and processing
106     will resume at this point for the next call of inflate().
107    
108     - Provide more output starting at next_out and update next_out and avail_out
109     accordingly. inflate() provides as much output as possible, until there
110     is no more input data or no more space in the output buffer (see below
111     about the flush parameter).
112    
113     Before the call of inflate(), the application should ensure that at least
114     one of the actions is possible, by providing more input and/or consuming
115     more output, and updating the next_* and avail_* values accordingly.
116     The application can consume the uncompressed output when it wants, for
117     example when the output buffer is full (avail_out == 0), or after each
118     call of inflate(). If inflate returns Z_OK and with zero avail_out, it
119     must be called again after making room in the output buffer because there
120     might be more output pending.
121    
122     If the parameter flush is set to Z_SYNC_FLUSH, inflate flushes as much
123     output as possible to the output buffer. The flushing behavior of inflate is
124     not specified for values of the flush parameter other than Z_SYNC_FLUSH
125     and Z_FINISH, but the current implementation actually flushes as much output
126     as possible anyway.
127    
128     inflate() should normally be called until it returns Z_STREAM_END or an
129     error. However if all decompression is to be performed in a single step
130     (a single call of inflate), the parameter flush should be set to
131     Z_FINISH. In this case all pending input is processed and all pending
132     output is flushed; avail_out must be large enough to hold all the
133     uncompressed data. (The size of the uncompressed data may have been saved
134     by the compressor for this purpose.) The next operation on this stream must
135     be inflateEnd to deallocate the decompression state. The use of Z_FINISH
136     is never required, but can be used to inform inflate that a faster routine
137     may be used for the single inflate() call.
138    
139     If a preset dictionary is needed at this point (see inflateSetDictionary
140     below), inflate sets strm-adler to the adler32 checksum of the
141     dictionary chosen by the compressor and returns Z_NEED_DICT; otherwise
142     it sets strm->adler to the adler32 checksum of all output produced
143     so far (that is, total_out bytes) and returns Z_OK, Z_STREAM_END or
144     an error code as described below. At the end of the stream, inflate()
145     checks that its computed adler32 checksum is equal to that saved by the
146     compressor and returns Z_STREAM_END only if the checksum is correct.
147    
148     inflate() returns Z_OK if some progress has been made (more input processed
149     or more output produced), Z_STREAM_END if the end of the compressed data has
150     been reached and all uncompressed output has been produced, Z_NEED_DICT if a
151     preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
152     corrupted (input stream not conforming to the zlib format or incorrect
153     adler32 checksum), Z_STREAM_ERROR if the stream structure was inconsistent
154     (for example if next_in or next_out was NULL), Z_MEM_ERROR if there was not
155     enough memory, Z_BUF_ERROR if no progress is possible or if there was not
156     enough room in the output buffer when Z_FINISH is used. In the Z_DATA_ERROR
157     case, the application may then call inflateSync to look for a good
158     compression block.
159     }
160    
161    
162     function inflateSetDictionary(var z : z_stream;
163     dictionary : pBytef; {const array of byte}
164     dictLength : uInt) : int;
165    
166     {
167     Initializes the decompression dictionary from the given uncompressed byte
168     sequence. This function must be called immediately after a call of inflate
169     if this call returned Z_NEED_DICT. The dictionary chosen by the compressor
170     can be determined from the Adler32 value returned by this call of
171     inflate. The compressor and decompressor must use exactly the same
172     dictionary (see deflateSetDictionary).
173    
174     inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
175     parameter is invalid (such as NULL dictionary) or the stream state is
176     inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
177     expected one (incorrect Adler32 value). inflateSetDictionary does not
178     perform any decompression: this will be done by subsequent calls of
179     inflate().
180     }
181    
182     function inflateSync(var z : z_stream) : int;
183    
184     {
185     Skips invalid compressed data until a full flush point (see above the
186     description of deflate with Z_FULL_FLUSH) can be found, or until all
187     available input is skipped. No output is provided.
188    
189     inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR
190     if no more input was provided, Z_DATA_ERROR if no flush point has been found,
191     or Z_STREAM_ERROR if the stream structure was inconsistent. In the success
192     case, the application may save the current current value of total_in which
193     indicates where valid compressed data was found. In the error case, the
194     application may repeatedly call inflateSync, providing more input each time,
195     until success or end of the input data.
196     }
197    
198    
199     function inflateSyncPoint(var z : z_stream) : int;
200    
201    
202     implementation
203    
204     uses
205     adler;
206    
207     function inflateReset(var z : z_stream) : int;
208     begin
209     if (z.state = Z_NULL) then
210     begin
211     inflateReset := Z_STREAM_ERROR;
212     exit;
213     end;
214     z.total_out := 0;
215     z.total_in := 0;
216     z.msg := '';
217     if z.state^.nowrap then
218     z.state^.mode := BLOCKS
219     else
220     z.state^.mode := METHOD;
221     inflate_blocks_reset(z.state^.blocks^, z, Z_NULL);
222     {$IFDEF DEBUG}
223     Tracev('inflate: reset');
224     {$ENDIF}
225     inflateReset := Z_OK;
226     end;
227    
228    
229     function inflateEnd(var z : z_stream) : int;
230     begin
231     if (z.state = Z_NULL) or not Assigned(z.zfree) then
232     begin
233     inflateEnd := Z_STREAM_ERROR;
234     exit;
235     end;
236     if (z.state^.blocks <> Z_NULL) then
237     inflate_blocks_free(z.state^.blocks, z);
238     ZFREE(z, z.state);
239     z.state := Z_NULL;
240     {$IFDEF DEBUG}
241     Tracev('inflate: end');
242     {$ENDIF}
243     inflateEnd := Z_OK;
244     end;
245    
246    
247     function inflateInit2_(var z: z_stream;
248     w : int;
249     const version : string;
250     stream_size : int) : int;
251     begin
252     if (version = '') or (version[1] <> ZLIB_VERSION[1]) or
253     (stream_size <> sizeof(z_stream)) then
254     begin
255     inflateInit2_ := Z_VERSION_ERROR;
256     exit;
257     end;
258     { initialize state }
259     { SetLength(strm.msg, 255); }
260     z.msg := '';
261     if not Assigned(z.zalloc) then
262     begin
263     {$IFDEF FPC} z.zalloc := @zcalloc; {$ELSE}
264     z.zalloc := zcalloc;
265     {$endif}
266     z.opaque := voidpf(0);
267     end;
268     if not Assigned(z.zfree) then
269     {$IFDEF FPC} z.zfree := @zcfree; {$ELSE}
270     z.zfree := zcfree;
271     {$ENDIF}
272    
273     z.state := pInternal_state( ZALLOC(z,1,sizeof(internal_state)) );
274     if (z.state = Z_NULL) then
275     begin
276     inflateInit2_ := Z_MEM_ERROR;
277     exit;
278     end;
279    
280     z.state^.blocks := Z_NULL;
281    
282     { handle undocumented nowrap option (no zlib header or check) }
283     z.state^.nowrap := FALSE;
284     if (w < 0) then
285     begin
286     w := - w;
287     z.state^.nowrap := TRUE;
288     end;
289    
290     { set window size }
291     if (w < 8) or (w > 15) then
292     begin
293     inflateEnd(z);
294     inflateInit2_ := Z_STREAM_ERROR;
295     exit;
296     end;
297     z.state^.wbits := uInt(w);
298    
299     { create inflate_blocks state }
300     if z.state^.nowrap then
301     z.state^.blocks := inflate_blocks_new(z, NIL, uInt(1) shl w)
302     else
303     {$IFDEF FPC}
304     z.state^.blocks := inflate_blocks_new(z, @adler32, uInt(1) shl w);
305     {$ELSE}
306     z.state^.blocks := inflate_blocks_new(z, adler32, uInt(1) shl w);
307     {$ENDIF}
308     if (z.state^.blocks = Z_NULL) then
309     begin
310     inflateEnd(z);
311     inflateInit2_ := Z_MEM_ERROR;
312     exit;
313     end;
314     {$IFDEF DEBUG}
315     Tracev('inflate: allocated');
316     {$ENDIF}
317     { reset state }
318     inflateReset(z);
319     inflateInit2_ := Z_OK;
320     end;
321    
322     function inflateInit2(var z: z_stream; windowBits : int) : int;
323     begin
324     inflateInit2 := inflateInit2_(z, windowBits, ZLIB_VERSION, sizeof(z_stream));
325     end;
326    
327    
328     function inflateInit(var z : z_stream) : int;
329     { inflateInit is a macro to allow checking the zlib version
330     and the compiler's view of z_stream: }
331     begin
332     inflateInit := inflateInit2_(z, DEF_WBITS, ZLIB_VERSION, sizeof(z_stream));
333     end;
334    
335     function inflateInit_(z : z_streamp;
336     const version : string;
337     stream_size : int) : int;
338     begin
339     { initialize state }
340     if (z = Z_NULL) then
341     inflateInit_ := Z_STREAM_ERROR
342     else
343     inflateInit_ := inflateInit2_(z^, DEF_WBITS, version, stream_size);
344     end;
345    
346     function inflate(var z : z_stream;
347     f : int) : int;
348     var
349     r : int;
350     b : uInt;
351     begin
352     if (z.state = Z_NULL) or (z.next_in = Z_NULL) then
353     begin
354     inflate := Z_STREAM_ERROR;
355     exit;
356     end;
357     if f = Z_FINISH then
358     f := Z_BUF_ERROR
359     else
360     f := Z_OK;
361     r := Z_BUF_ERROR;
362     while True do
363     case (z.state^.mode) of
364     BLOCKS:
365     begin
366     r := inflate_blocks(z.state^.blocks^, z, r);
367     if (r = Z_DATA_ERROR) then
368     begin
369     z.state^.mode := BAD;
370     z.state^.sub.marker := 0; { can try inflateSync }
371     continue; { break C-switch }
372     end;
373     if (r = Z_OK) then
374     r := f;
375     if (r <> Z_STREAM_END) then
376     begin
377     inflate := r;
378     exit;
379     end;
380     r := f;
381     inflate_blocks_reset(z.state^.blocks^, z, @z.state^.sub.check.was);
382     if (z.state^.nowrap) then
383     begin
384     z.state^.mode := DONE;
385     continue; { break C-switch }
386     end;
387     z.state^.mode := CHECK4; { falltrough }
388     end;
389     CHECK4:
390     begin
391     {NEEDBYTE}
392     if (z.avail_in = 0) then
393     begin
394     inflate := r;
395     exit;
396     end;
397     r := f;
398    
399     {z.state^.sub.check.need := uLong(NEXTBYTE(z)) shl 24;}
400     Dec(z.avail_in);
401     Inc(z.total_in);
402     z.state^.sub.check.need := uLong(z.next_in^) shl 24;
403     Inc(z.next_in);
404    
405     z.state^.mode := CHECK3; { falltrough }
406     end;
407     CHECK3:
408     begin
409     {NEEDBYTE}
410     if (z.avail_in = 0) then
411     begin
412     inflate := r;
413     exit;
414     end;
415     r := f;
416     {Inc( z.state^.sub.check.need, uLong(NEXTBYTE(z)) shl 16);}
417     Dec(z.avail_in);
418     Inc(z.total_in);
419     Inc(z.state^.sub.check.need, uLong(z.next_in^) shl 16);
420     Inc(z.next_in);
421    
422     z.state^.mode := CHECK2; { falltrough }
423     end;
424     CHECK2:
425     begin
426     {NEEDBYTE}
427     if (z.avail_in = 0) then
428     begin
429     inflate := r;
430     exit;
431     end;
432     r := f;
433    
434     {Inc( z.state^.sub.check.need, uLong(NEXTBYTE(z)) shl 8);}
435     Dec(z.avail_in);
436     Inc(z.total_in);
437     Inc(z.state^.sub.check.need, uLong(z.next_in^) shl 8);
438     Inc(z.next_in);
439    
440     z.state^.mode := CHECK1; { falltrough }
441     end;
442     CHECK1:
443     begin
444     {NEEDBYTE}
445     if (z.avail_in = 0) then
446     begin
447     inflate := r;
448     exit;
449     end;
450     r := f;
451     {Inc( z.state^.sub.check.need, uLong(NEXTBYTE(z)) );}
452     Dec(z.avail_in);
453     Inc(z.total_in);
454     Inc(z.state^.sub.check.need, uLong(z.next_in^) );
455     Inc(z.next_in);
456    
457    
458     if (z.state^.sub.check.was <> z.state^.sub.check.need) then
459     begin
460     z.state^.mode := BAD;
461     z.msg := 'incorrect data check';
462     z.state^.sub.marker := 5; { can't try inflateSync }
463     continue; { break C-switch }
464     end;
465     {$IFDEF DEBUG}
466     Tracev('inflate: zlib check ok');
467     {$ENDIF}
468     z.state^.mode := DONE; { falltrough }
469     end;
470     DONE:
471     begin
472     inflate := Z_STREAM_END;
473     exit;
474     end;
475     METHOD:
476     begin
477     {NEEDBYTE}
478     if (z.avail_in = 0) then
479     begin
480     inflate := r;
481     exit;
482     end;
483     r := f; {}
484    
485     {z.state^.sub.method := NEXTBYTE(z);}
486     Dec(z.avail_in);
487     Inc(z.total_in);
488     z.state^.sub.method := z.next_in^;
489     Inc(z.next_in);
490    
491     if ((z.state^.sub.method and $0f) <> Z_DEFLATED) then
492     begin
493     z.state^.mode := BAD;
494     z.msg := 'unknown compression method';
495     z.state^.sub.marker := 5; { can't try inflateSync }
496     continue; { break C-switch }
497     end;
498     if ((z.state^.sub.method shr 4) + 8 > z.state^.wbits) then
499     begin
500     z.state^.mode := BAD;
501     z.msg := 'invalid window size';
502     z.state^.sub.marker := 5; { can't try inflateSync }
503     continue; { break C-switch }
504     end;
505     z.state^.mode := FLAG;
506     { fall trough }
507     end;
508     FLAG:
509     begin
510     {NEEDBYTE}
511     if (z.avail_in = 0) then
512     begin
513     inflate := r;
514     exit;
515     end;
516     r := f; {}
517     {b := NEXTBYTE(z);}
518     Dec(z.avail_in);
519     Inc(z.total_in);
520     b := z.next_in^;
521     Inc(z.next_in);
522    
523     if (((z.state^.sub.method shl 8) + b) mod 31) <> 0 then {% mod ?}
524     begin
525     z.state^.mode := BAD;
526     z.msg := 'incorrect header check';
527     z.state^.sub.marker := 5; { can't try inflateSync }
528     continue; { break C-switch }
529     end;
530     {$IFDEF DEBUG}
531     Tracev('inflate: zlib header ok');
532     {$ENDIF}
533     if ((b and PRESET_DICT) = 0) then
534     begin
535     z.state^.mode := BLOCKS;
536     continue; { break C-switch }
537     end;
538     z.state^.mode := DICT4;
539     { falltrough }
540     end;
541     DICT4:
542     begin
543     if (z.avail_in = 0) then
544     begin
545     inflate := r;
546     exit;
547     end;
548     r := f;
549    
550     {z.state^.sub.check.need := uLong(NEXTBYTE(z)) shl 24;}
551     Dec(z.avail_in);
552     Inc(z.total_in);
553     z.state^.sub.check.need := uLong(z.next_in^) shl 24;
554     Inc(z.next_in);
555    
556     z.state^.mode := DICT3; { falltrough }
557     end;
558     DICT3:
559     begin
560     if (z.avail_in = 0) then
561     begin
562     inflate := r;
563     exit;
564     end;
565     r := f;
566     {Inc(z.state^.sub.check.need, uLong(NEXTBYTE(z)) shl 16);}
567     Dec(z.avail_in);
568     Inc(z.total_in);
569     Inc(z.state^.sub.check.need, uLong(z.next_in^) shl 16);
570     Inc(z.next_in);
571    
572     z.state^.mode := DICT2; { falltrough }
573     end;
574     DICT2:
575     begin
576     if (z.avail_in = 0) then
577     begin
578     inflate := r;
579     exit;
580     end;
581     r := f;
582    
583     {Inc(z.state^.sub.check.need, uLong(NEXTBYTE(z)) shl 8);}
584     Dec(z.avail_in);
585     Inc(z.total_in);
586     Inc(z.state^.sub.check.need, uLong(z.next_in^) shl 8);
587     Inc(z.next_in);
588    
589     z.state^.mode := DICT1; { falltrough }
590     end;
591     DICT1:
592     begin
593     if (z.avail_in = 0) then
594     begin
595     inflate := r;
596     exit;
597     end;
598     { r := f; --- wird niemals benutzt }
599     {Inc(z.state^.sub.check.need, uLong(NEXTBYTE(z)) );}
600     Dec(z.avail_in);
601     Inc(z.total_in);
602     Inc(z.state^.sub.check.need, uLong(z.next_in^) );
603     Inc(z.next_in);
604    
605     z.adler := z.state^.sub.check.need;
606     z.state^.mode := DICT0;
607     inflate := Z_NEED_DICT;
608     exit;
609     end;
610     DICT0:
611     begin
612     z.state^.mode := BAD;
613     z.msg := 'need dictionary';
614     z.state^.sub.marker := 0; { can try inflateSync }
615     inflate := Z_STREAM_ERROR;
616     exit;
617     end;
618     BAD:
619     begin
620     inflate := Z_DATA_ERROR;
621     exit;
622     end;
623     else
624     begin
625     inflate := Z_STREAM_ERROR;
626     exit;
627     end;
628     end;
629     {$ifdef NEED_DUMMY_result}
630     result := Z_STREAM_ERROR; { Some dumb compilers complain without this }
631     {$endif}
632     end;
633    
634     function inflateSetDictionary(var z : z_stream;
635     dictionary : pBytef; {const array of byte}
636     dictLength : uInt) : int;
637     var
638     length : uInt;
639     begin
640     length := dictLength;
641    
642     if (z.state = Z_NULL) or (z.state^.mode <> DICT0) then
643     begin
644     inflateSetDictionary := Z_STREAM_ERROR;
645     exit;
646     end;
647     if (adler32(Long(1), dictionary, dictLength) <> z.adler) then
648     begin
649     inflateSetDictionary := Z_DATA_ERROR;
650     exit;
651     end;
652     z.adler := Long(1);
653    
654     if (length >= (uInt(1) shl z.state^.wbits)) then
655     begin
656     length := (1 shl z.state^.wbits)-1;
657     Inc( dictionary, dictLength - length);
658     end;
659     inflate_set_dictionary(z.state^.blocks^, dictionary^, length);
660     z.state^.mode := BLOCKS;
661     inflateSetDictionary := Z_OK;
662     end;
663    
664    
665     function inflateSync(var z : z_stream) : int;
666     const
667     mark : packed array[0..3] of byte = (0, 0, $ff, $ff);
668     var
669     n : uInt; { number of bytes to look at }
670     p : pBytef; { pointer to bytes }
671     m : uInt; { number of marker bytes found in a row }
672     r, w : uLong; { temporaries to save total_in and total_out }
673     begin
674     { set up }
675     if (z.state = Z_NULL) then
676     begin
677     inflateSync := Z_STREAM_ERROR;
678     exit;
679     end;
680     if (z.state^.mode <> BAD) then
681     begin
682     z.state^.mode := BAD;
683     z.state^.sub.marker := 0;
684     end;
685     n := z.avail_in;
686     if (n = 0) then
687     begin
688     inflateSync := Z_BUF_ERROR;
689     exit;
690     end;
691     p := z.next_in;
692     m := z.state^.sub.marker;
693    
694     { search }
695     while (n <> 0) and (m < 4) do
696     begin
697     if (p^ = mark[m]) then
698     Inc(m)
699     else
700     if (p^ <> 0) then
701     m := 0
702     else
703     m := 4 - m;
704     Inc(p);
705     Dec(n);
706     end;
707    
708     { restore }
709     Inc(z.total_in, ptr2int(p) - ptr2int(z.next_in));
710     z.next_in := p;
711     z.avail_in := n;
712     z.state^.sub.marker := m;
713    
714    
715     { return no joy or set up to restart on a new block }
716     if (m <> 4) then
717     begin
718     inflateSync := Z_DATA_ERROR;
719     exit;
720     end;
721     r := z.total_in;
722     w := z.total_out;
723     inflateReset(z);
724     z.total_in := r;
725     z.total_out := w;
726     z.state^.mode := BLOCKS;
727     inflateSync := Z_OK;
728     end;
729    
730    
731     {
732     returns true if inflate is currently at the end of a block generated
733     by Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
734     implementation to provide an additional safety check. PPP uses Z_SYNC_FLUSH
735     but removes the length bytes of the resulting empty stored block. When
736     decompressing, PPP checks that at the end of input packet, inflate is
737     waiting for these length bytes.
738     }
739    
740     function inflateSyncPoint(var z : z_stream) : int;
741     begin
742     if (z.state = Z_NULL) or (z.state^.blocks = Z_NULL) then
743     begin
744     inflateSyncPoint := Z_STREAM_ERROR;
745     exit;
746     end;
747     inflateSyncPoint := inflate_blocks_sync_point(z.state^.blocks^);
748     end;
749    
750     end.

Properties

Name Value
svn:executable

No admin address has been configured">No admin address has been configured
ViewVC Help
Powered by ViewVC 1.1.26