ReactOS  0.4.15-dev-499-g1f31905
ftgzip.c
Go to the documentation of this file.
1 /***************************************************************************/
2 /* */
3 /* ftgzip.c */
4 /* */
5 /* FreeType support for .gz compressed files. */
6 /* */
7 /* This optional component relies on zlib. It should mainly be used to */
8 /* parse compressed PCF fonts, as found with many X11 server */
9 /* distributions. */
10 /* */
11 /* Copyright 2002-2018 by */
12 /* David Turner, Robert Wilhelm, and Werner Lemberg. */
13 /* */
14 /* This file is part of the FreeType project, and may only be used, */
15 /* modified, and distributed under the terms of the FreeType project */
16 /* license, LICENSE.TXT. By continuing to use, modify, or distribute */
17 /* this file you indicate that you have read the license and */
18 /* understand and accept it fully. */
19 /* */
20 /***************************************************************************/
21 
22 
23 #include <ft2build.h>
24 #include FT_INTERNAL_MEMORY_H
25 #include FT_INTERNAL_STREAM_H
26 #include FT_INTERNAL_DEBUG_H
27 #include FT_GZIP_H
28 #include FT_CONFIG_STANDARD_LIBRARY_H
29 
30 
31 #include FT_MODULE_ERRORS_H
32 
33 #undef FTERRORS_H_
34 
35 #undef FT_ERR_PREFIX
36 #define FT_ERR_PREFIX Gzip_Err_
37 #define FT_ERR_BASE FT_Mod_Err_Gzip
38 
39 #include FT_ERRORS_H
40 
41 
42 #ifdef FT_CONFIG_OPTION_USE_ZLIB
43 
44 #ifdef FT_CONFIG_OPTION_PIC
45 #error "gzip code does not support PIC yet"
46 #endif
47 
48 #ifdef FT_CONFIG_OPTION_SYSTEM_ZLIB
49 
50 #include <zlib.h>
51 
52 #else /* !FT_CONFIG_OPTION_SYSTEM_ZLIB */
53 
54  /* In this case, we include our own modified sources of the ZLib */
55  /* within the `gzip' component. The modifications were necessary */
56  /* to #include all files without conflicts, as well as preventing */
57  /* the definition of `extern' functions that may cause linking */
58  /* conflicts when a program is linked with both FreeType and the */
59  /* original ZLib. */
60 
61 #ifndef USE_ZLIB_ZCALLOC
62 #define MY_ZCALLOC /* prevent all zcalloc() & zfree() in zutil.c */
63 #endif
64 
65  /* Note that our `zlib.h' includes `ftzconf.h' instead of `zconf.h'; */
66  /* the main reason is that even a global `zlib.h' includes `zconf.h' */
67  /* with */
68  /* */
69  /* #include "zconf.h" */
70  /* */
71  /* instead of the expected */
72  /* */
73  /* #include <zconf.h> */
74  /* */
75  /* so that configuration with `FT_CONFIG_OPTION_SYSTEM_ZLIB' might */
76  /* include the wrong `zconf.h' file, leading to errors. */
77 #include "zlib.h"
78 
79 #undef SLOW
80 #define SLOW 1 /* we can't use asm-optimized sources here! */
81 
82 #if defined( _MSC_VER ) /* Visual C++ (and Intel C++) */
83  /* We disable the warning `conversion from XXX to YYY, */
84  /* possible loss of data' in order to compile cleanly with */
85  /* the maximum level of warnings: zlib is non-FreeType */
86  /* code. */
87 #pragma warning( push )
88 #pragma warning( disable : 4244 )
89 #endif /* _MSC_VER */
90 
91  /* Urgh. `inflate_mask' must not be declared twice -- C++ doesn't like
92  this. We temporarily disable it and load all necessary header files. */
93 #define NO_INFLATE_MASK
94 #include "zutil.h"
95 #include "inftrees.h"
96 #include "infblock.h"
97 #include "infcodes.h"
98 #include "infutil.h"
99 #undef NO_INFLATE_MASK
100 
101  /* infutil.c must be included before infcodes.c */
102 #include "zutil.c"
103 #include "inftrees.c"
104 #include "infutil.c"
105 #include "infcodes.c"
106 #include "infblock.c"
107 #include "inflate.c"
108 #include "adler32.c"
109 
110 #if defined( _MSC_VER )
111 #pragma warning( pop )
112 #endif
113 
114 #endif /* !FT_CONFIG_OPTION_SYSTEM_ZLIB */
115 
116 
117 /***************************************************************************/
118 /***************************************************************************/
119 /***** *****/
120 /***** Z L I B M E M O R Y M A N A G E M E N T *****/
121 /***** *****/
122 /***************************************************************************/
123 /***************************************************************************/
124 
125  /* it is better to use FreeType memory routines instead of raw
126  'malloc/free' */
127 
128  static voidpf
129  ft_gzip_alloc( FT_Memory memory,
130  uInt items,
131  uInt size )
132  {
133  FT_ULong sz = (FT_ULong)size * items;
134  FT_Error error;
135  FT_Pointer p = NULL;
136 
137 
138  (void)FT_ALLOC( p, sz );
139  return p;
140  }
141 
142 
143  static void
144  ft_gzip_free( FT_Memory memory,
145  voidpf address )
146  {
147  FT_MEM_FREE( address );
148  }
149 
150 
151 #if !defined( FT_CONFIG_OPTION_SYSTEM_ZLIB ) && !defined( USE_ZLIB_ZCALLOC )
152 
153  local voidpf
154  zcalloc ( voidpf opaque,
155  unsigned items,
156  unsigned size )
157  {
158  return ft_gzip_alloc( (FT_Memory)opaque, items, size );
159  }
160 
161  local void
162  zcfree( voidpf opaque,
163  voidpf ptr )
164  {
165  ft_gzip_free( (FT_Memory)opaque, ptr );
166  }
167 
168 #endif /* !SYSTEM_ZLIB && !USE_ZLIB_ZCALLOC */
169 
170 
171 /***************************************************************************/
172 /***************************************************************************/
173 /***** *****/
174 /***** Z L I B F I L E D E S C R I P T O R *****/
175 /***** *****/
176 /***************************************************************************/
177 /***************************************************************************/
178 
179 #define FT_GZIP_BUFFER_SIZE 4096
180 
181  typedef struct FT_GZipFileRec_
182  {
183  FT_Stream source; /* parent/source stream */
184  FT_Stream stream; /* embedding stream */
185  FT_Memory memory; /* memory allocator */
186  z_stream zstream; /* zlib input stream */
187 
188  FT_ULong start; /* starting position, after .gz header */
189  FT_Byte input[FT_GZIP_BUFFER_SIZE]; /* input read buffer */
190 
191  FT_Byte buffer[FT_GZIP_BUFFER_SIZE]; /* output buffer */
192  FT_ULong pos; /* position in output */
193  FT_Byte* cursor;
194  FT_Byte* limit;
195 
196  } FT_GZipFileRec, *FT_GZipFile;
197 
198 
199  /* gzip flag byte */
200 #define FT_GZIP_ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */
201 #define FT_GZIP_HEAD_CRC 0x02 /* bit 1 set: header CRC present */
202 #define FT_GZIP_EXTRA_FIELD 0x04 /* bit 2 set: extra field present */
203 #define FT_GZIP_ORIG_NAME 0x08 /* bit 3 set: original file name present */
204 #define FT_GZIP_COMMENT 0x10 /* bit 4 set: file comment present */
205 #define FT_GZIP_RESERVED 0xE0 /* bits 5..7: reserved */
206 
207 
208  /* check and skip .gz header - we don't support `transparent' compression */
209  static FT_Error
210  ft_gzip_check_header( FT_Stream stream )
211  {
212  FT_Error error;
213  FT_Byte head[4];
214 
215 
216  if ( FT_STREAM_SEEK( 0 ) ||
217  FT_STREAM_READ( head, 4 ) )
218  goto Exit;
219 
220  /* head[0] && head[1] are the magic numbers; */
221  /* head[2] is the method, and head[3] the flags */
222  if ( head[0] != 0x1F ||
223  head[1] != 0x8B ||
224  head[2] != Z_DEFLATED ||
225  (head[3] & FT_GZIP_RESERVED) )
226  {
227  error = FT_THROW( Invalid_File_Format );
228  goto Exit;
229  }
230 
231  /* skip time, xflags and os code */
232  (void)FT_STREAM_SKIP( 6 );
233 
234  /* skip the extra field */
235  if ( head[3] & FT_GZIP_EXTRA_FIELD )
236  {
237  FT_UInt len;
238 
239 
240  if ( FT_READ_USHORT_LE( len ) ||
241  FT_STREAM_SKIP( len ) )
242  goto Exit;
243  }
244 
245  /* skip original file name */
246  if ( head[3] & FT_GZIP_ORIG_NAME )
247  for (;;)
248  {
249  FT_UInt c;
250 
251 
252  if ( FT_READ_BYTE( c ) )
253  goto Exit;
254 
255  if ( c == 0 )
256  break;
257  }
258 
259  /* skip .gz comment */
260  if ( head[3] & FT_GZIP_COMMENT )
261  for (;;)
262  {
263  FT_UInt c;
264 
265 
266  if ( FT_READ_BYTE( c ) )
267  goto Exit;
268 
269  if ( c == 0 )
270  break;
271  }
272 
273  /* skip CRC */
274  if ( head[3] & FT_GZIP_HEAD_CRC )
275  if ( FT_STREAM_SKIP( 2 ) )
276  goto Exit;
277 
278  Exit:
279  return error;
280  }
281 
282 
283  static FT_Error
284  ft_gzip_file_init( FT_GZipFile zip,
286  FT_Stream source )
287  {
288  z_stream* zstream = &zip->zstream;
290 
291 
292  zip->stream = stream;
293  zip->source = source;
294  zip->memory = stream->memory;
295 
296  zip->limit = zip->buffer + FT_GZIP_BUFFER_SIZE;
297  zip->cursor = zip->limit;
298  zip->pos = 0;
299 
300  /* check and skip .gz header */
301  {
302  stream = source;
303 
304  error = ft_gzip_check_header( stream );
305  if ( error )
306  goto Exit;
307 
308  zip->start = FT_STREAM_POS();
309  }
310 
311  /* initialize zlib -- there is no zlib header in the compressed stream */
312  zstream->zalloc = (alloc_func)ft_gzip_alloc;
313  zstream->zfree = (free_func) ft_gzip_free;
314  zstream->opaque = stream->memory;
315 
316  zstream->avail_in = 0;
317  zstream->next_in = zip->buffer;
318 
319  if ( inflateInit2( zstream, -MAX_WBITS ) != Z_OK ||
320  !zstream->next_in )
321  error = FT_THROW( Invalid_File_Format );
322 
323  Exit:
324  return error;
325  }
326 
327 
328  static void
329  ft_gzip_file_done( FT_GZipFile zip )
330  {
331  z_stream* zstream = &zip->zstream;
332 
333 
334  inflateEnd( zstream );
335 
336  /* clear the rest */
337  zstream->zalloc = NULL;
338  zstream->zfree = NULL;
339  zstream->opaque = NULL;
340  zstream->next_in = NULL;
341  zstream->next_out = NULL;
342  zstream->avail_in = 0;
343  zstream->avail_out = 0;
344 
345  zip->memory = NULL;
346  zip->source = NULL;
347  zip->stream = NULL;
348  }
349 
350 
351  static FT_Error
352  ft_gzip_file_reset( FT_GZipFile zip )
353  {
354  FT_Stream stream = zip->source;
355  FT_Error error;
356 
357 
358  if ( !FT_STREAM_SEEK( zip->start ) )
359  {
360  z_stream* zstream = &zip->zstream;
361 
362 
363  inflateReset( zstream );
364 
365  zstream->avail_in = 0;
366  zstream->next_in = zip->input;
367  zstream->avail_out = 0;
368  zstream->next_out = zip->buffer;
369 
370  zip->limit = zip->buffer + FT_GZIP_BUFFER_SIZE;
371  zip->cursor = zip->limit;
372  zip->pos = 0;
373  }
374 
375  return error;
376  }
377 
378 
379  static FT_Error
380  ft_gzip_file_fill_input( FT_GZipFile zip )
381  {
382  z_stream* zstream = &zip->zstream;
383  FT_Stream stream = zip->source;
384  FT_ULong size;
385 
386 
387  if ( stream->read )
388  {
389  size = stream->read( stream, stream->pos, zip->input,
390  FT_GZIP_BUFFER_SIZE );
391  if ( size == 0 )
392  {
393  zip->limit = zip->cursor;
394  return FT_THROW( Invalid_Stream_Operation );
395  }
396  }
397  else
398  {
399  size = stream->size - stream->pos;
400  if ( size > FT_GZIP_BUFFER_SIZE )
401  size = FT_GZIP_BUFFER_SIZE;
402 
403  if ( size == 0 )
404  {
405  zip->limit = zip->cursor;
406  return FT_THROW( Invalid_Stream_Operation );
407  }
408 
409  FT_MEM_COPY( zip->input, stream->base + stream->pos, size );
410  }
411  stream->pos += size;
412 
413  zstream->next_in = zip->input;
414  zstream->avail_in = size;
415 
416  return FT_Err_Ok;
417  }
418 
419 
420  static FT_Error
421  ft_gzip_file_fill_output( FT_GZipFile zip )
422  {
423  z_stream* zstream = &zip->zstream;
425 
426 
427  zip->cursor = zip->buffer;
428  zstream->next_out = zip->cursor;
429  zstream->avail_out = FT_GZIP_BUFFER_SIZE;
430 
431  while ( zstream->avail_out > 0 )
432  {
433  int err;
434 
435 
436  if ( zstream->avail_in == 0 )
437  {
438  error = ft_gzip_file_fill_input( zip );
439  if ( error )
440  break;
441  }
442 
443  err = inflate( zstream, Z_NO_FLUSH );
444 
445  if ( err == Z_STREAM_END )
446  {
447  zip->limit = zstream->next_out;
448  if ( zip->limit == zip->cursor )
449  error = FT_THROW( Invalid_Stream_Operation );
450  break;
451  }
452  else if ( err != Z_OK )
453  {
454  zip->limit = zip->cursor;
455  error = FT_THROW( Invalid_Stream_Operation );
456  break;
457  }
458  }
459 
460  return error;
461  }
462 
463 
464  /* fill output buffer; `count' must be <= FT_GZIP_BUFFER_SIZE */
465  static FT_Error
466  ft_gzip_file_skip_output( FT_GZipFile zip,
467  FT_ULong count )
468  {
470  FT_ULong delta;
471 
472 
473  for (;;)
474  {
475  delta = (FT_ULong)( zip->limit - zip->cursor );
476  if ( delta >= count )
477  delta = count;
478 
479  zip->cursor += delta;
480  zip->pos += delta;
481 
482  count -= delta;
483  if ( count == 0 )
484  break;
485 
486  error = ft_gzip_file_fill_output( zip );
487  if ( error )
488  break;
489  }
490 
491  return error;
492  }
493 
494 
495  static FT_ULong
496  ft_gzip_file_io( FT_GZipFile zip,
497  FT_ULong pos,
498  FT_Byte* buffer,
499  FT_ULong count )
500  {
501  FT_ULong result = 0;
502  FT_Error error;
503 
504 
505  /* Reset inflate stream if we're seeking backwards. */
506  /* Yes, that is not too efficient, but it saves memory :-) */
507  if ( pos < zip->pos )
508  {
509  error = ft_gzip_file_reset( zip );
510  if ( error )
511  goto Exit;
512  }
513 
514  /* skip unwanted bytes */
515  if ( pos > zip->pos )
516  {
517  error = ft_gzip_file_skip_output( zip, (FT_ULong)( pos - zip->pos ) );
518  if ( error )
519  goto Exit;
520  }
521 
522  if ( count == 0 )
523  goto Exit;
524 
525  /* now read the data */
526  for (;;)
527  {
528  FT_ULong delta;
529 
530 
531  delta = (FT_ULong)( zip->limit - zip->cursor );
532  if ( delta >= count )
533  delta = count;
534 
535  FT_MEM_COPY( buffer, zip->cursor, delta );
536  buffer += delta;
537  result += delta;
538  zip->cursor += delta;
539  zip->pos += delta;
540 
541  count -= delta;
542  if ( count == 0 )
543  break;
544 
545  error = ft_gzip_file_fill_output( zip );
546  if ( error )
547  break;
548  }
549 
550  Exit:
551  return result;
552  }
553 
554 
555 /***************************************************************************/
556 /***************************************************************************/
557 /***** *****/
558 /***** G Z E M B E D D I N G S T R E A M *****/
559 /***** *****/
560 /***************************************************************************/
561 /***************************************************************************/
562 
563  static void
564  ft_gzip_stream_close( FT_Stream stream )
565  {
566  FT_GZipFile zip = (FT_GZipFile)stream->descriptor.pointer;
567  FT_Memory memory = stream->memory;
568 
569 
570  if ( zip )
571  {
572  /* finalize gzip file descriptor */
573  ft_gzip_file_done( zip );
574 
575  FT_FREE( zip );
576 
577  stream->descriptor.pointer = NULL;
578  }
579 
580  if ( !stream->read )
581  FT_FREE( stream->base );
582  }
583 
584 
585  static unsigned long
586  ft_gzip_stream_io( FT_Stream stream,
587  unsigned long offset,
588  unsigned char* buffer,
589  unsigned long count )
590  {
591  FT_GZipFile zip = (FT_GZipFile)stream->descriptor.pointer;
592 
593 
594  return ft_gzip_file_io( zip, offset, buffer, count );
595  }
596 
597 
598  static FT_ULong
599  ft_gzip_get_uncompressed_size( FT_Stream stream )
600  {
601  FT_Error error;
602  FT_ULong old_pos;
603  FT_ULong result = 0;
604 
605 
606  old_pos = stream->pos;
607  if ( !FT_Stream_Seek( stream, stream->size - 4 ) )
608  {
610  if ( error )
611  result = 0;
612 
613  (void)FT_Stream_Seek( stream, old_pos );
614  }
615 
616  return result;
617  }
618 
619 
620  /* documentation is in ftgzip.h */
621 
624  FT_Stream source )
625  {
626  FT_Error error;
628  FT_GZipFile zip = NULL;
629 
630 
631  if ( !stream || !source )
632  {
633  error = FT_THROW( Invalid_Stream_Handle );
634  goto Exit;
635  }
636 
637  memory = source->memory;
638 
639  /*
640  * check the header right now; this prevents allocating un-necessary
641  * objects when we don't need them
642  */
643  error = ft_gzip_check_header( source );
644  if ( error )
645  goto Exit;
646 
647  FT_ZERO( stream );
648  stream->memory = memory;
649 
650  if ( !FT_QNEW( zip ) )
651  {
652  error = ft_gzip_file_init( zip, stream, source );
653  if ( error )
654  {
655  FT_FREE( zip );
656  goto Exit;
657  }
658 
659  stream->descriptor.pointer = zip;
660  }
661 
662  /*
663  * We use the following trick to try to dramatically improve the
664  * performance while dealing with small files. If the original stream
665  * size is less than a certain threshold, we try to load the whole font
666  * file into memory. This saves us from using the 32KB buffer needed
667  * to inflate the file, plus the two 4KB intermediate input/output
668  * buffers used in the `FT_GZipFile' structure.
669  */
670  {
671  FT_ULong zip_size = ft_gzip_get_uncompressed_size( source );
672 
673 
674  if ( zip_size != 0 && zip_size < 40 * 1024 )
675  {
676  FT_Byte* zip_buff = NULL;
677 
678 
679  if ( !FT_ALLOC( zip_buff, zip_size ) )
680  {
681  FT_ULong count;
682 
683 
684  count = ft_gzip_file_io( zip, 0, zip_buff, zip_size );
685  if ( count == zip_size )
686  {
687  ft_gzip_file_done( zip );
688  FT_FREE( zip );
689 
690  stream->descriptor.pointer = NULL;
691 
692  stream->size = zip_size;
693  stream->pos = 0;
694  stream->base = zip_buff;
695  stream->read = NULL;
696  stream->close = ft_gzip_stream_close;
697 
698  goto Exit;
699  }
700 
701  ft_gzip_file_io( zip, 0, NULL, 0 );
702  FT_FREE( zip_buff );
703  }
704  error = FT_Err_Ok;
705  }
706 
707  if ( zip_size )
708  stream->size = zip_size;
709  else
710  stream->size = 0x7FFFFFFFL; /* don't know the real size! */
711  }
712 
713  stream->pos = 0;
714  stream->base = NULL;
715  stream->read = ft_gzip_stream_io;
716  stream->close = ft_gzip_stream_close;
717 
718  Exit:
719  return error;
720  }
721 
722 
723  /* documentation is in ftgzip.h */
724 
727  FT_Byte* output,
728  FT_ULong* output_len,
729  const FT_Byte* input,
730  FT_ULong input_len )
731  {
733  int err;
734 
735 
736  /* check for `input' delayed to `inflate' */
737 
738  if ( !memory || ! output_len || !output )
739  return FT_THROW( Invalid_Argument );
740 
741  /* this function is modeled after zlib's `uncompress' function */
742 
743  stream.next_in = (Bytef*)input;
744  stream.avail_in = (uInt)input_len;
745 
746  stream.next_out = output;
747  stream.avail_out = (uInt)*output_len;
748 
749  stream.zalloc = (alloc_func)ft_gzip_alloc;
750  stream.zfree = (free_func) ft_gzip_free;
751  stream.opaque = memory;
752 
754  if ( err != Z_OK )
755  return FT_THROW( Invalid_Argument );
756 
757  err = inflate( &stream, Z_FINISH );
758  if ( err != Z_STREAM_END )
759  {
760  inflateEnd( &stream );
761  if ( err == Z_OK )
762  err = Z_BUF_ERROR;
763  }
764  else
765  {
766  *output_len = stream.total_out;
767 
768  err = inflateEnd( &stream );
769  }
770 
771  if ( err == Z_MEM_ERROR )
772  return FT_THROW( Out_Of_Memory );
773 
774  if ( err == Z_BUF_ERROR )
775  return FT_THROW( Array_Too_Large );
776 
777  if ( err == Z_DATA_ERROR )
778  return FT_THROW( Invalid_Table );
779 
780  return FT_Err_Ok;
781  }
782 
783 
784 #else /* !FT_CONFIG_OPTION_USE_ZLIB */
785 
788  FT_Stream source )
789  {
790  FT_UNUSED( stream );
791  FT_UNUSED( source );
792 
793  return FT_THROW( Unimplemented_Feature );
794  }
795 
796 
799  FT_Byte* output,
800  FT_ULong* output_len,
802  FT_ULong input_len )
803  {
804  FT_UNUSED( memory );
805  FT_UNUSED( output );
806  FT_UNUSED( output_len );
807  FT_UNUSED( input );
808  FT_UNUSED( input_len );
809 
810  return FT_THROW( Unimplemented_Feature );
811  }
812 
813 #endif /* !FT_CONFIG_OPTION_USE_ZLIB */
814 
815 
816 /* END */
#define FT_ALLOC(ptr, size)
Definition: ftmemory.h:303
int FT_Error
Definition: fttypes.h:300
static UCHAR ULONG UCHAR ULONG UCHAR * output
Definition: bcrypt.c:29
FT_Stream_Seek(FT_Stream stream, FT_ULong pos)
Definition: ftstream.c:57
unsigned long FT_ULong
Definition: fttypes.h:253
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
#define FT_READ_USHORT_LE(var)
Definition: ftstream.h:316
#define error(str)
Definition: mkdosfs.c:1605
struct outqueuenode * head
Definition: adnsresfilter.c:66
FT_Gzip_Uncompress(FT_Memory memory, FT_Byte *output, FT_ULong *output_len, const FT_Byte *input, FT_ULong input_len)
Definition: ftgzip.c:798
GLuint GLuint GLsizei count
Definition: gl.h:1545
int ZEXPORT inflateEnd(z_streamp strm)
Definition: inflate.c:1277
uInt avail_in
Definition: zlib.h:88
GLintptr offset
Definition: glext.h:5920
FT_Stream_OpenGzip(FT_Stream stream, FT_Stream source)
Definition: ftgzip.c:787
GLuint buffer
Definition: glext.h:5915
#define FT_READ_BYTE(var)
Definition: ftstream.h:306
return FT_Err_Ok
Definition: ftbbox.c:511
static char memory[1024 *256]
Definition: process.c:116
#define FT_QNEW(ptr)
Definition: ftmemory.h:339
#define Z_STREAM_END
Definition: zlib.h:178
GLint limit
Definition: glext.h:10326
Byte FAR Bytef
Definition: zconf.h:400
voidpf opaque
Definition: zlib.h:100
#define Z_BUF_ERROR
Definition: zlib.h:184
free_func zfree
Definition: zlib.h:99
unsigned char FT_Byte
Definition: fttypes.h:154
#define FT_THROW(e)
Definition: ftdebug.h:213
#define Z_OK
Definition: zlib.h:177
static PVOID ptr
Definition: dispmode.c:27
smooth NULL
Definition: ftsmooth.c:416
#define Z_DEFLATED
Definition: zlib.h:209
#define FT_FREE(ptr)
Definition: ftmemory.h:329
#define FT_STREAM_SKIP(distance)
Definition: ftstream.h:493
GLsizeiptr size
Definition: glext.h:5919
#define FT_ZERO(p)
Definition: ftmemory.h:237
if(!(yy_init))
Definition: macro.lex.yy.c:714
static void Exit(void)
Definition: sock.c:1331
#define FT_MEM_FREE(ptr)
Definition: ftmemory.h:156
const GLubyte * c
Definition: glext.h:8905
alloc_func zalloc
Definition: zlib.h:98
#define inflateInit2(strm, windowBits)
Definition: zlib.h:1800
GLuint address
Definition: glext.h:9393
#define Z_DATA_ERROR
Definition: zlib.h:182
#define Z_NO_FLUSH
Definition: zlib.h:168
int ZEXPORT inflate(z_streamp strm, int flush)
Definition: inflate.c:622
static const WCHAR L[]
Definition: oid.c:1250
unsigned int size
Definition: parse.h:27
Definition: parse.h:22
GLuint GLuint stream
Definition: glext.h:7522
int ZEXPORT inflateReset(z_streamp strm)
Definition: inflate.c:144
typedefFT_BEGIN_HEADER struct FT_MemoryRec_ * FT_Memory
Definition: ftsystem.h:66
GLenum GLsizei len
Definition: glext.h:6722
#define err(...)
#define FT_STREAM_SEEK(position)
Definition: ftstream.h:489
#define local
Definition: zutil.h:30
ULARGE_INTEGER pos
Definition: request.c:4380
#define FT_STREAM_POS()
Definition: ftstream.h:486
Byte FAR * voidpf
Definition: zconf.h:413
#define Z_FINISH
Definition: zlib.h:172
GLenum GLenum GLenum input
Definition: glext.h:9031
const char cursor[]
Definition: icontest.c:13
void zcfree(voidpf opaque, voidpf ptr)
Definition: zutil.c:173
#define FT_EXPORT_DEF(x)
Definition: ftconfig.h:483
unsigned int FT_UInt
Definition: fttypes.h:231
GLuint start
Definition: gl.h:1545
GLsizei GLsizei GLchar * source
Definition: glext.h:6048
voidpf zcalloc(voidpf opaque, unsigned items, unsigned size)
Definition: zutil.c:164
uInt avail_out
Definition: zlib.h:92
z_const Bytef * next_in
Definition: zlib.h:87
#define c
Definition: ke_i.h:80
#define const
Definition: zconf.h:230
FT_Stream_ReadULongLE(FT_Stream stream, FT_Error *error)
Definition: ftstream.c:669
#define FT_MEM_COPY(dest, source, count)
Definition: ftmemory.h:228
GLfloat GLfloat p
Definition: glext.h:8902
Bytef * next_out
Definition: zlib.h:91
static TCHAR * items[]
Definition: page1.c:45
GLuint64EXT * result
Definition: glext.h:11304
#define FT_STREAM_READ(buffer, count)
Definition: ftstream.h:497
#define MAX_WBITS
Definition: zconf.h:270
#define FT_UNUSED(arg)
Definition: ftconfig.h:101
#define Z_MEM_ERROR
Definition: zlib.h:183
unsigned int uInt
Definition: zconf.h:393