Merge XFA to PDFium master at 4dc95e7 on 10/28/2014
[pdfium.git] / core / src / fxcodec / fx_lpng / lpng_v163 / pngconf.h
1 \r
2 /* pngconf.h - machine configurable file for libpng\r
3  *\r
4  * libpng version 1.6.3 - July 18, 2013\r
5  *\r
6  * Copyright (c) 1998-2013 Glenn Randers-Pehrson\r
7  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)\r
8  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)\r
9  *\r
10  * This code is released under the libpng license.\r
11  * For conditions of distribution and use, see the disclaimer\r
12  * and license in png.h\r
13  *\r
14  */\r
15 \r
16 /* Any machine specific code is near the front of this file, so if you\r
17  * are configuring libpng for a machine, you may want to read the section\r
18  * starting here down to where it starts to typedef png_color, png_text,\r
19  * and png_info.\r
20  */\r
21 \r
22 #ifndef PNGCONF_H\r
23 #define PNGCONF_H\r
24 \r
25 /* To do: Do all of this in scripts/pnglibconf.dfa */\r
26 #ifdef PNG_SAFE_LIMITS_SUPPORTED\r
27 #  ifdef PNG_USER_WIDTH_MAX\r
28 #    undef PNG_USER_WIDTH_MAX\r
29 #    define PNG_USER_WIDTH_MAX 1000000L\r
30 #  endif\r
31 #  ifdef PNG_USER_HEIGHT_MAX\r
32 #    undef PNG_USER_HEIGHT_MAX\r
33 #    define PNG_USER_HEIGHT_MAX 1000000L\r
34 #  endif\r
35 #  ifdef PNG_USER_CHUNK_MALLOC_MAX\r
36 #    undef PNG_USER_CHUNK_MALLOC_MAX\r
37 #    define PNG_USER_CHUNK_MALLOC_MAX 4000000L\r
38 #  endif\r
39 #  ifdef PNG_USER_CHUNK_CACHE_MAX\r
40 #    undef PNG_USER_CHUNK_CACHE_MAX\r
41 #    define PNG_USER_CHUNK_CACHE_MAX 128\r
42 #  endif\r
43 #endif\r
44 \r
45 #ifndef PNG_BUILDING_SYMBOL_TABLE /* else includes may cause problems */\r
46 \r
47 /* From libpng 1.6.0 libpng requires an ANSI X3.159-1989 ("ISOC90") compliant C\r
48  * compiler for correct compilation.  The following header files are required by\r
49  * the standard.  If your compiler doesn't provide these header files, or they\r
50  * do not match the standard, you will need to provide/improve them.\r
51  */\r
52 #include <limits.h>\r
53 #include <stddef.h>\r
54 \r
55 /* Library header files.  These header files are all defined by ISOC90; libpng\r
56  * expects conformant implementations, however, an ISOC90 conformant system need\r
57  * not provide these header files if the functionality cannot be implemented.\r
58  * In this case it will be necessary to disable the relevant parts of libpng in\r
59  * the build of pnglibconf.h.\r
60  *\r
61  * Prior to 1.6.0 string.h was included here; the API changes in 1.6.0 to not\r
62  * include this unnecessary header file.\r
63  */\r
64 \r
65 #ifdef PNG_STDIO_SUPPORTED\r
66    /* Required for the definition of FILE: */\r
67 #  include <stdio.h>\r
68 #endif\r
69 \r
70 #ifdef PNG_SETJMP_SUPPORTED\r
71    /* Required for the definition of jmp_buf and the declaration of longjmp: */\r
72 #  include <setjmp.h>\r
73 #endif\r
74 \r
75 #ifdef PNG_CONVERT_tIME_SUPPORTED\r
76    /* Required for struct tm: */\r
77 #  include <time.h>\r
78 #endif\r
79 \r
80 #endif /* PNG_BUILDING_SYMBOL_TABLE */\r
81 \r
82 /* Prior to 1.6.0 it was possible to turn off 'const' in declarations using\r
83  * PNG_NO_CONST; this is no longer supported except for data declarations which\r
84  * apparently still cause problems in 2011 on some compilers.\r
85  */\r
86 #define PNG_CONST const /* backward compatibility only */\r
87 \r
88 /* This controls optimization of the reading of 16 and 32 bit values\r
89  * from PNG files.  It can be set on a per-app-file basis - it\r
90  * just changes whether a macro is used when the function is called.\r
91  * The library builder sets the default; if read functions are not\r
92  * built into the library the macro implementation is forced on.\r
93  */\r
94 #ifndef PNG_READ_INT_FUNCTIONS_SUPPORTED\r
95 #  define PNG_USE_READ_MACROS\r
96 #endif\r
97 #if !defined(PNG_NO_USE_READ_MACROS) && !defined(PNG_USE_READ_MACROS)\r
98 #  if PNG_DEFAULT_READ_MACROS\r
99 #    define PNG_USE_READ_MACROS\r
100 #  endif\r
101 #endif\r
102 \r
103 /* COMPILER SPECIFIC OPTIONS.\r
104  *\r
105  * These options are provided so that a variety of difficult compilers\r
106  * can be used.  Some are fixed at build time (e.g. PNG_API_RULE\r
107  * below) but still have compiler specific implementations, others\r
108  * may be changed on a per-file basis when compiling against libpng.\r
109  */\r
110 \r
111 /* The PNGARG macro was used in versions of libpng prior to 1.6.0 to protect\r
112  * against legacy (pre ISOC90) compilers that did not understand function\r
113  * prototypes.  It is not required for modern C compilers.\r
114  */\r
115 #ifndef PNGARG\r
116 #  define PNGARG(arglist) arglist\r
117 #endif\r
118 \r
119 /* Function calling conventions.\r
120  * =============================\r
121  * Normally it is not necessary to specify to the compiler how to call\r
122  * a function - it just does it - however on x86 systems derived from\r
123  * Microsoft and Borland C compilers ('IBM PC', 'DOS', 'Windows' systems\r
124  * and some others) there are multiple ways to call a function and the\r
125  * default can be changed on the compiler command line.  For this reason\r
126  * libpng specifies the calling convention of every exported function and\r
127  * every function called via a user supplied function pointer.  This is\r
128  * done in this file by defining the following macros:\r
129  *\r
130  * PNGAPI    Calling convention for exported functions.\r
131  * PNGCBAPI  Calling convention for user provided (callback) functions.\r
132  * PNGCAPI   Calling convention used by the ANSI-C library (required\r
133  *           for longjmp callbacks and sometimes used internally to\r
134  *           specify the calling convention for zlib).\r
135  *\r
136  * These macros should never be overridden.  If it is necessary to\r
137  * change calling convention in a private build this can be done\r
138  * by setting PNG_API_RULE (which defaults to 0) to one of the values\r
139  * below to select the correct 'API' variants.\r
140  *\r
141  * PNG_API_RULE=0 Use PNGCAPI - the 'C' calling convention - throughout.\r
142  *                This is correct in every known environment.\r
143  * PNG_API_RULE=1 Use the operating system convention for PNGAPI and\r
144  *                the 'C' calling convention (from PNGCAPI) for\r
145  *                callbacks (PNGCBAPI).  This is no longer required\r
146  *                in any known environment - if it has to be used\r
147  *                please post an explanation of the problem to the\r
148  *                libpng mailing list.\r
149  *\r
150  * These cases only differ if the operating system does not use the C\r
151  * calling convention, at present this just means the above cases\r
152  * (x86 DOS/Windows sytems) and, even then, this does not apply to\r
153  * Cygwin running on those systems.\r
154  *\r
155  * Note that the value must be defined in pnglibconf.h so that what\r
156  * the application uses to call the library matches the conventions\r
157  * set when building the library.\r
158  */\r
159 \r
160 /* Symbol export\r
161  * =============\r
162  * When building a shared library it is almost always necessary to tell\r
163  * the compiler which symbols to export.  The png.h macro 'PNG_EXPORT'\r
164  * is used to mark the symbols.  On some systems these symbols can be\r
165  * extracted at link time and need no special processing by the compiler,\r
166  * on other systems the symbols are flagged by the compiler and just\r
167  * the declaration requires a special tag applied (unfortunately) in a\r
168  * compiler dependent way.  Some systems can do either.\r
169  *\r
170  * A small number of older systems also require a symbol from a DLL to\r
171  * be flagged to the program that calls it.  This is a problem because\r
172  * we do not know in the header file included by application code that\r
173  * the symbol will come from a shared library, as opposed to a statically\r
174  * linked one.  For this reason the application must tell us by setting\r
175  * the magic flag PNG_USE_DLL to turn on the special processing before\r
176  * it includes png.h.\r
177  *\r
178  * Four additional macros are used to make this happen:\r
179  *\r
180  * PNG_IMPEXP The magic (if any) to cause a symbol to be exported from\r
181  *            the build or imported if PNG_USE_DLL is set - compiler\r
182  *            and system specific.\r
183  *\r
184  * PNG_EXPORT_TYPE(type) A macro that pre or appends PNG_IMPEXP to\r
185  *                       'type', compiler specific.\r
186  *\r
187  * PNG_DLL_EXPORT Set to the magic to use during a libpng build to\r
188  *                make a symbol exported from the DLL.  Not used in the\r
189  *                public header files; see pngpriv.h for how it is used\r
190  *                in the libpng build.\r
191  *\r
192  * PNG_DLL_IMPORT Set to the magic to force the libpng symbols to come\r
193  *                from a DLL - used to define PNG_IMPEXP when\r
194  *                PNG_USE_DLL is set.\r
195  */\r
196 \r
197 /* System specific discovery.\r
198  * ==========================\r
199  * This code is used at build time to find PNG_IMPEXP, the API settings\r
200  * and PNG_EXPORT_TYPE(), it may also set a macro to indicate the DLL\r
201  * import processing is possible.  On Windows systems it also sets\r
202  * compiler-specific macros to the values required to change the calling\r
203  * conventions of the various functions.\r
204  */\r
205 #if defined(_Windows) || defined(_WINDOWS) || defined(WIN32) ||\\r
206     defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)\r
207   /* Windows system (DOS doesn't support DLLs).  Includes builds under Cygwin or\r
208    * MinGW on any architecture currently supported by Windows.  Also includes\r
209    * Watcom builds but these need special treatment because they are not\r
210    * compatible with GCC or Visual C because of different calling conventions.\r
211    */\r
212 #  if PNG_API_RULE == 2\r
213     /* If this line results in an error, either because __watcall is not\r
214      * understood or because of a redefine just below you cannot use *this*\r
215      * build of the library with the compiler you are using.  *This* build was\r
216      * build using Watcom and applications must also be built using Watcom!\r
217      */\r
218 #    define PNGCAPI __watcall\r
219 #  endif\r
220 \r
221 #  if defined(__GNUC__) || (defined(_MSC_VER) && (_MSC_VER >= 800))\r
222 #    define PNGCAPI __cdecl\r
223 #    if PNG_API_RULE == 1\r
224        /* If this line results in an error __stdcall is not understood and\r
225         * PNG_API_RULE should not have been set to '1'.\r
226         */\r
227 #      define PNGAPI __stdcall\r
228 #    endif\r
229 #  else\r
230     /* An older compiler, or one not detected (erroneously) above,\r
231      * if necessary override on the command line to get the correct\r
232      * variants for the compiler.\r
233      */\r
234 #    ifndef PNGCAPI\r
235 #      define PNGCAPI _cdecl\r
236 #    endif\r
237 #    if PNG_API_RULE == 1 && !defined(PNGAPI)\r
238 #      define PNGAPI _stdcall\r
239 #    endif\r
240 #  endif /* compiler/api */\r
241 \r
242   /* NOTE: PNGCBAPI always defaults to PNGCAPI. */\r
243 \r
244 #  if defined(PNGAPI) && !defined(PNG_USER_PRIVATEBUILD)\r
245 #     error "PNG_USER_PRIVATEBUILD must be defined if PNGAPI is changed"\r
246 #  endif\r
247 \r
248 #  if (defined(_MSC_VER) && _MSC_VER < 800) ||\\r
249       (defined(__BORLANDC__) && __BORLANDC__ < 0x500)\r
250     /* older Borland and MSC\r
251      * compilers used '__export' and required this to be after\r
252      * the type.\r
253      */\r
254 #    ifndef PNG_EXPORT_TYPE\r
255 #      define PNG_EXPORT_TYPE(type) type PNG_IMPEXP\r
256 #    endif\r
257 #    define PNG_DLL_EXPORT __export\r
258 #  else /* newer compiler */\r
259 #    define PNG_DLL_EXPORT __declspec(dllexport)\r
260 #    ifndef PNG_DLL_IMPORT\r
261 #      define PNG_DLL_IMPORT __declspec(dllimport)\r
262 #    endif\r
263 #  endif /* compiler */\r
264 \r
265 #else /* !Windows */\r
266 #  if (defined(__IBMC__) || defined(__IBMCPP__)) && defined(__OS2__)\r
267 #    define PNGAPI _System\r
268 #  else /* !Windows/x86 && !OS/2 */\r
269     /* Use the defaults, or define PNG*API on the command line (but\r
270      * this will have to be done for every compile!)\r
271      */\r
272 #  endif /* other system, !OS/2 */\r
273 #endif /* !Windows/x86 */\r
274 \r
275 /* Now do all the defaulting . */\r
276 #ifndef PNGCAPI\r
277 #  define PNGCAPI\r
278 #endif\r
279 #ifndef PNGCBAPI\r
280 #  define PNGCBAPI PNGCAPI\r
281 #endif\r
282 #ifndef PNGAPI\r
283 #  define PNGAPI PNGCAPI\r
284 #endif\r
285 \r
286 /* PNG_IMPEXP may be set on the compilation system command line or (if not set)\r
287  * then in an internal header file when building the library, otherwise (when\r
288  * using the library) it is set here.\r
289  */\r
290 #ifndef PNG_IMPEXP\r
291 #  if defined(PNG_USE_DLL) && defined(PNG_DLL_IMPORT)\r
292      /* This forces use of a DLL, disallowing static linking */\r
293 #    define PNG_IMPEXP PNG_DLL_IMPORT\r
294 #  endif\r
295 \r
296 #  ifndef PNG_IMPEXP\r
297 #    define PNG_IMPEXP\r
298 #  endif\r
299 #endif\r
300 \r
301 /* In 1.5.2 the definition of PNG_FUNCTION has been changed to always treat\r
302  * 'attributes' as a storage class - the attributes go at the start of the\r
303  * function definition, and attributes are always appended regardless of the\r
304  * compiler.  This considerably simplifies these macros but may cause problems\r
305  * if any compilers both need function attributes and fail to handle them as\r
306  * a storage class (this is unlikely.)\r
307  */\r
308 #ifndef PNG_FUNCTION\r
309 #  define PNG_FUNCTION(type, name, args, attributes) attributes type name args\r
310 #endif\r
311 \r
312 #ifndef PNG_EXPORT_TYPE\r
313 #  define PNG_EXPORT_TYPE(type) PNG_IMPEXP type\r
314 #endif\r
315 \r
316    /* The ordinal value is only relevant when preprocessing png.h for symbol\r
317     * table entries, so we discard it here.  See the .dfn files in the\r
318     * scripts directory.\r
319     */\r
320 #ifndef PNG_EXPORTA\r
321 \r
322 #  define PNG_EXPORTA(ordinal, type, name, args, attributes)\\r
323       PNG_FUNCTION(PNG_EXPORT_TYPE(type),(PNGAPI name),PNGARG(args), \\r
324         extern attributes)\r
325 #endif\r
326 \r
327 /* ANSI-C (C90) does not permit a macro to be invoked with an empty argument,\r
328  * so make something non-empty to satisfy the requirement:\r
329  */\r
330 #define PNG_EMPTY /*empty list*/\r
331 \r
332 #define PNG_EXPORT(ordinal, type, name, args)\\r
333    PNG_EXPORTA(ordinal, type, name, args, PNG_EMPTY)\r
334 \r
335 /* Use PNG_REMOVED to comment out a removed interface. */\r
336 #ifndef PNG_REMOVED\r
337 #  define PNG_REMOVED(ordinal, type, name, args, attributes)\r
338 #endif\r
339 \r
340 #ifndef PNG_CALLBACK\r
341 #  define PNG_CALLBACK(type, name, args) type (PNGCBAPI name) PNGARG(args)\r
342 #endif\r
343 \r
344 /* Support for compiler specific function attributes.  These are used\r
345  * so that where compiler support is available incorrect use of API\r
346  * functions in png.h will generate compiler warnings.\r
347  *\r
348  * Added at libpng-1.2.41.\r
349  */\r
350 \r
351 #ifndef PNG_NO_PEDANTIC_WARNINGS\r
352 #  ifndef PNG_PEDANTIC_WARNINGS_SUPPORTED\r
353 #    define PNG_PEDANTIC_WARNINGS_SUPPORTED\r
354 #  endif\r
355 #endif\r
356 \r
357 #ifdef PNG_PEDANTIC_WARNINGS_SUPPORTED\r
358   /* Support for compiler specific function attributes.  These are used\r
359    * so that where compiler support is available, incorrect use of API\r
360    * functions in png.h will generate compiler warnings.  Added at libpng\r
361    * version 1.2.41.  Disabling these removes the warnings but may also produce\r
362    * less efficient code.\r
363    */\r
364 #  if defined(__GNUC__)\r
365 #    ifndef PNG_USE_RESULT\r
366 #      define PNG_USE_RESULT __attribute__((__warn_unused_result__))\r
367 #    endif\r
368 #    ifndef PNG_NORETURN\r
369 #      define PNG_NORETURN   __attribute__((__noreturn__))\r
370 #    endif\r
371 #    if __GNUC__ >= 3\r
372 #      ifndef PNG_ALLOCATED\r
373 #        define PNG_ALLOCATED  __attribute__((__malloc__))\r
374 #      endif\r
375 #      ifndef PNG_DEPRECATED\r
376 #        define PNG_DEPRECATED __attribute__((__deprecated__))\r
377 #      endif\r
378 #      ifndef PNG_PRIVATE\r
379 #        if 0 /* Doesn't work so we use deprecated instead*/\r
380 #          define PNG_PRIVATE \\r
381             __attribute__((warning("This function is not exported by libpng.")))\r
382 #        else\r
383 #          define PNG_PRIVATE \\r
384             __attribute__((__deprecated__))\r
385 #        endif\r
386 #      endif\r
387 #      if ((__GNUC__ != 3) || !defined(__GNUC_MINOR__) || (__GNUC_MINOR__ >= 1))\r
388 #        ifndef PNG_RESTRICT\r
389 #          define PNG_RESTRICT __restrict\r
390 #        endif\r
391 #      endif /*  __GNUC__ == 3.0 */\r
392 #    endif /*  __GNUC__ >= 3 */\r
393 \r
394 #  elif defined(_MSC_VER)  && (_MSC_VER >= 1300)\r
395 #    ifndef PNG_USE_RESULT\r
396 #      define PNG_USE_RESULT /* not supported */\r
397 #    endif\r
398 #    ifndef PNG_NORETURN\r
399 #      define PNG_NORETURN   __declspec(noreturn)\r
400 #    endif\r
401 #    ifndef PNG_ALLOCATED\r
402 #      if (_MSC_VER >= 1400)\r
403 #        define PNG_ALLOCATED __declspec(restrict)\r
404 #      endif\r
405 #    endif\r
406 #    ifndef PNG_DEPRECATED\r
407 #      define PNG_DEPRECATED __declspec(deprecated)\r
408 #    endif\r
409 #    ifndef PNG_PRIVATE\r
410 #      define PNG_PRIVATE __declspec(deprecated)\r
411 #    endif\r
412 #    ifndef PNG_RESTRICT\r
413 #      if (_MSC_VER >= 1400)\r
414 #        define PNG_RESTRICT __restrict\r
415 #      endif\r
416 #    endif\r
417 \r
418 #  elif defined(__WATCOMC__)\r
419 #    ifndef PNG_RESTRICT\r
420 #      define PNG_RESTRICT __restrict\r
421 #    endif\r
422 #  endif /* _MSC_VER */\r
423 #endif /* PNG_PEDANTIC_WARNINGS */\r
424 \r
425 #ifndef PNG_DEPRECATED\r
426 #  define PNG_DEPRECATED  /* Use of this function is deprecated */\r
427 #endif\r
428 #ifndef PNG_USE_RESULT\r
429 #  define PNG_USE_RESULT  /* The result of this function must be checked */\r
430 #endif\r
431 #ifndef PNG_NORETURN\r
432 #  define PNG_NORETURN    /* This function does not return */\r
433 #endif\r
434 #ifndef PNG_ALLOCATED\r
435 #  define PNG_ALLOCATED   /* The result of the function is new memory */\r
436 #endif\r
437 #ifndef PNG_PRIVATE\r
438 #  define PNG_PRIVATE     /* This is a private libpng function */\r
439 #endif\r
440 #ifndef PNG_RESTRICT\r
441 #  define PNG_RESTRICT    /* The C99 "restrict" feature */\r
442 #endif\r
443 #ifndef PNG_FP_EXPORT     /* A floating point API. */\r
444 #  ifdef PNG_FLOATING_POINT_SUPPORTED\r
445 #     define PNG_FP_EXPORT(ordinal, type, name, args)\\r
446          PNG_EXPORT(ordinal, type, name, args);\r
447 #  else                   /* No floating point APIs */\r
448 #     define PNG_FP_EXPORT(ordinal, type, name, args)\r
449 #  endif\r
450 #endif\r
451 #ifndef PNG_FIXED_EXPORT  /* A fixed point API. */\r
452 #  ifdef PNG_FIXED_POINT_SUPPORTED\r
453 #     define PNG_FIXED_EXPORT(ordinal, type, name, args)\\r
454          PNG_EXPORT(ordinal, type, name, args);\r
455 #  else                   /* No fixed point APIs */\r
456 #     define PNG_FIXED_EXPORT(ordinal, type, name, args)\r
457 #  endif\r
458 #endif\r
459 \r
460 #ifndef PNG_BUILDING_SYMBOL_TABLE\r
461 /* Some typedefs to get us started.  These should be safe on most of the common\r
462  * platforms.\r
463  *\r
464  * png_uint_32 and png_int_32 may, currently, be larger than required to hold a\r
465  * 32-bit value however this is not normally advisable.\r
466  *\r
467  * png_uint_16 and png_int_16 should always be two bytes in size - this is\r
468  * verified at library build time.\r
469  *\r
470  * png_byte must always be one byte in size.\r
471  *\r
472  * The checks below use constants from limits.h, as defined by the ISOC90\r
473  * standard.\r
474  */\r
475 #if CHAR_BIT == 8 && UCHAR_MAX == 255\r
476    typedef unsigned char png_byte;\r
477 #else\r
478 #  error "libpng requires 8 bit bytes"\r
479 #endif\r
480 \r
481 #if INT_MIN == -32768 && INT_MAX == 32767\r
482    typedef int png_int_16;\r
483 #elif SHRT_MIN == -32768 && SHRT_MAX == 32767\r
484    typedef short png_int_16;\r
485 #else\r
486 #  error "libpng requires a signed 16 bit type"\r
487 #endif\r
488 \r
489 #if UINT_MAX == 65535\r
490    typedef unsigned int png_uint_16;\r
491 #elif USHRT_MAX == 65535\r
492    typedef unsigned short png_uint_16;\r
493 #else\r
494 #  error "libpng requires an unsigned 16 bit type"\r
495 #endif\r
496 \r
497 #if INT_MIN < -2147483646 && INT_MAX > 2147483646\r
498    typedef int png_int_32;\r
499 #elif LONG_MIN < -2147483646 && LONG_MAX > 2147483646\r
500    typedef long int png_int_32;\r
501 #else\r
502 #  error "libpng requires a signed 32 bit (or more) type"\r
503 #endif\r
504 \r
505 #if UINT_MAX > 4294967294\r
506    typedef unsigned int png_uint_32;\r
507 #elif ULONG_MAX > 4294967294\r
508    typedef unsigned long int png_uint_32;\r
509 #else\r
510 #  error "libpng requires an unsigned 32 bit (or more) type"\r
511 #endif\r
512 \r
513 /* Prior to 1.6.0 it was possible to disable the use of size_t, 1.6.0, however,\r
514  * requires an ISOC90 compiler and relies on consistent behavior of sizeof.\r
515  */\r
516 typedef size_t png_size_t;\r
517 typedef ptrdiff_t png_ptrdiff_t;\r
518 \r
519 /* libpng needs to know the maximum value of 'size_t' and this controls the\r
520  * definition of png_alloc_size_t, below.  This maximum value of size_t limits\r
521  * but does not control the maximum allocations the library makes - there is\r
522  * direct application control of this through png_set_user_limits().\r
523  */\r
524 #ifndef PNG_SMALL_SIZE_T\r
525    /* Compiler specific tests for systems where size_t is known to be less than\r
526     * 32 bits (some of these systems may no longer work because of the lack of\r
527     * 'far' support; see above.)\r
528     */\r
529 #  if (defined(__TURBOC__) && !defined(__FLAT__)) ||\\r
530    (defined(_MSC_VER) && defined(MAXSEG_64K))\r
531 #     define PNG_SMALL_SIZE_T\r
532 #  endif\r
533 #endif\r
534 \r
535 /* png_alloc_size_t is guaranteed to be no smaller than png_size_t, and no\r
536  * smaller than png_uint_32.  Casts from png_size_t or png_uint_32 to\r
537  * png_alloc_size_t are not necessary; in fact, it is recommended not to use\r
538  * them at all so that the compiler can complain when something turns out to be\r
539  * problematic.\r
540  *\r
541  * Casts in the other direction (from png_alloc_size_t to png_size_t or\r
542  * png_uint_32) should be explicitly applied; however, we do not expect to\r
543  * encounter practical situations that require such conversions.\r
544  *\r
545  * PNG_SMALL_SIZE_T must be defined if the maximum value of size_t is less than\r
546  * 4294967295 - i.e. less than the maximum value of png_uint_32.\r
547  */\r
548 #ifdef PNG_SMALL_SIZE_T\r
549    typedef png_uint_32 png_alloc_size_t;\r
550 #else\r
551    typedef png_size_t png_alloc_size_t;\r
552 #endif\r
553 \r
554 /* Prior to 1.6.0 libpng offered limited support for Microsoft C compiler\r
555  * implementations of Intel CPU specific support of user-mode segmented address\r
556  * spaces, where 16-bit pointers address more than 65536 bytes of memory using\r
557  * separate 'segment' registers.  The implementation requires two different\r
558  * types of pointer (only one of which includes the segment value.)\r
559  *\r
560  * If required this support is available in version 1.2 of libpng and may be\r
561  * available in versions through 1.5, although the correctness of the code has\r
562  * not been verified recently.\r
563  */\r
564 \r
565 /* Typedef for floating-point numbers that are converted to fixed-point with a\r
566  * multiple of 100,000, e.g., gamma\r
567  */\r
568 typedef png_int_32 png_fixed_point;\r
569 \r
570 /* Add typedefs for pointers */\r
571 typedef void                  * png_voidp;\r
572 typedef const void            * png_const_voidp;\r
573 typedef png_byte              * png_bytep;\r
574 typedef const png_byte        * png_const_bytep;\r
575 typedef png_uint_32           * png_uint_32p;\r
576 typedef const png_uint_32     * png_const_uint_32p;\r
577 typedef png_int_32            * png_int_32p;\r
578 typedef const png_int_32      * png_const_int_32p;\r
579 typedef png_uint_16           * png_uint_16p;\r
580 typedef const png_uint_16     * png_const_uint_16p;\r
581 typedef png_int_16            * png_int_16p;\r
582 typedef const png_int_16      * png_const_int_16p;\r
583 typedef char                  * png_charp;\r
584 typedef const char            * png_const_charp;\r
585 typedef png_fixed_point       * png_fixed_point_p;\r
586 typedef const png_fixed_point * png_const_fixed_point_p;\r
587 typedef png_size_t            * png_size_tp;\r
588 typedef const png_size_t      * png_const_size_tp;\r
589 \r
590 #ifdef PNG_STDIO_SUPPORTED\r
591 typedef FILE            * png_FILE_p;\r
592 #endif\r
593 \r
594 #ifdef PNG_FLOATING_POINT_SUPPORTED\r
595 typedef double       * png_doublep;\r
596 typedef const double * png_const_doublep;\r
597 #endif\r
598 \r
599 /* Pointers to pointers; i.e. arrays */\r
600 typedef png_byte        * * png_bytepp;\r
601 typedef png_uint_32     * * png_uint_32pp;\r
602 typedef png_int_32      * * png_int_32pp;\r
603 typedef png_uint_16     * * png_uint_16pp;\r
604 typedef png_int_16      * * png_int_16pp;\r
605 typedef const char      * * png_const_charpp;\r
606 typedef char            * * png_charpp;\r
607 typedef png_fixed_point * * png_fixed_point_pp;\r
608 #ifdef PNG_FLOATING_POINT_SUPPORTED\r
609 typedef double          * * png_doublepp;\r
610 #endif\r
611 \r
612 /* Pointers to pointers to pointers; i.e., pointer to array */\r
613 typedef char            * * * png_charppp;\r
614 \r
615 #endif /* PNG_BUILDING_SYMBOL_TABLE */\r
616 \r
617 #endif /* PNGCONF_H */\r