"Fossies" - the Fresh Open Source Software Archive

Member "pngcrush-1.8.13/pngconf.h" (29 Aug 2017, 23017 Bytes) of package /linux/privat/pngcrush-1.8.13.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "pngconf.h" see the Fossies "Dox" file reference documentation and the latest Fossies "Diffs" side-by-side code changes report: 1.8.12_vs_1.8.13.

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