CMakeLists.txt

   1 # CMakeLists.txt
   2
   3 # Copyright (c) 2018-2023 Cosmin Truta
   4 # Copyright (c) 2007,2009-2018 Glenn Randers-Pehrson
   5 # Written by Christian Ehrlicher, 2007
   6 # Revised by Roger Lowman, 2009-2010
   7 # Revised by Clifford Yapp, 2011-2012,2017
   8 # Revised by Claudio Bley, 2013
   9 # Revised by Roger Leigh, 2016
  10 # Revised by Andreas Franek, 2016
  11 # Revised by Sam Serrels, 2017
  12 # Revised by Vadim Barkov, 2017
  13 # Revised by Vicky Pfau, 2018
  14 # Revised by Cameron Cawley, 2018,2021
  15 # Revised by Kyle Bentley, 2018
  16 # Revised by David Callu, 2020
  17 # Revised by Steve Robinson, 2020
  18 # Revised by Simon Hausmann, 2020
  19 # Revised by Alex Gaynor, 2020
  20 # Revised by Owen Rudge, 2020
  21 # Revised by Gleb Mazovetskiy, 2021
  22 # Revised by Christopher Sean Morrison, 2022
  23 # Revised by B. Scott Michel, 2022
  24 # Revised by Jeremy Maitin-Shepard, 2022
  25 # Revised by Martin Storsjo, 2022
  26 # Revised by Jon Creighton, 2023
  27 # Revised by Gunther Nikl, 2023
  28
  29 # This code is released under the libpng license.
  30 # For conditions of distribution and use, see the disclaimer
  31 # and license in png.h
  32
  33 cmake_minimum_required(VERSION 3.1)
  34 cmake_policy(VERSION 3.1)
  35
  36 project(libpng C ASM)
  37 enable_testing()
  38
  39 include(CMakeParseArguments)
  40 include(CheckCSourceCompiles)
  41 include(GNUInstallDirs)
  42
  43 set(PNGLIB_MAJOR 1)
  44 set(PNGLIB_MINOR 6)
  45 set(PNGLIB_REVISION 40)
  46 set(PNGLIB_SUBREVISION 0)
  47 #set(PNGLIB_SUBREVISION "git")
  48 set(PNGLIB_VERSION ${PNGLIB_MAJOR}.${PNGLIB_MINOR}.${PNGLIB_REVISION})
  49 set(PNGLIB_ABI_VERSION ${PNGLIB_MAJOR}${PNGLIB_MINOR})
  50 set(PNGLIB_SHARED_VERSION ${PNGLIB_ABI_VERSION}.${PNGLIB_REVISION}.${PNGLIB_SUBREVISION})
  51
  52 # Allow the users to specify an application-specific API prefix for libpng
  53 # vendoring purposes. A standard libpng build should have no such prefix.
  54 set(PNG_PREFIX ""
  55     CACHE STRING "Prefix to prepend to the API function names")
  56
  57 # Allow the users to override the postfix appended to debug library file names.
  58 # Previously, we used to set CMAKE_DEBUG_POSTFIX globally. That variable should
  59 # not be cached, however, because doing so would affect all projects processed
  60 # after libpng, in unexpected and undesirable ways.
  61 set(PNG_DEBUG_POSTFIX "d"
  62     CACHE STRING "Postfix to append to library file names under the Debug configuration")
  63
  64 # Allow the users to import their own extra configuration settings.
  65 set(DFA_XTRA ""
  66     CACHE FILEPATH "File containing extra configuration settings")
  67
  68 # Allow the users to configure the following build options.
  69 option(PNG_SHARED "Build libpng as a shared lib" ON)
  70 option(PNG_STATIC "Build libpng as a static lib" ON)
  71 option(PNG_FRAMEWORK "Build libpng as a Mac OS X framework" OFF)
  72 option(PNG_EXECUTABLES "Build libpng executables" ON)
  73 option(PNG_TESTS "Build libpng tests" ON)
  74 option(PNG_DEBUG "Enable debug output" OFF)
  75 option(PNG_HARDWARE_OPTIMIZATIONS "Enable hardware optimizations" ON)
  76
  77 # Allow the users to specify a location of zlib.
  78 # Useful if zlib is being built alongside this as a sub-project.
  79 option(PNG_BUILD_ZLIB "Custom zlib location, else find_package is used" OFF)
  80 if(NOT PNG_BUILD_ZLIB)
  81   find_package(ZLIB REQUIRED)
  82   include_directories(${ZLIB_INCLUDE_DIRS})
  83 endif()
  84
  85 if(UNIX AND NOT APPLE AND NOT BEOS AND NOT HAIKU AND NOT EMSCRIPTEN)
  86   find_library(M_LIBRARY m)
  87   if(NOT M_LIBRARY)
  88     set(M_LIBRARY "")
  89   endif()
  90 else()
  91   # libm is not needed and/or not available.
  92   set(M_LIBRARY "")
  93 endif()
  94
  95 # CMake currently sets CMAKE_SYSTEM_PROCESSOR to one of x86_64 or arm64 on macOS,
  96 # based upon the OS architecture, not the target architecture. As such, we need
  97 # to check CMAKE_OSX_ARCHITECTURES to identify which hardware-specific flags to
  98 # enable. Note that this will fail if you attempt to build a universal binary in
  99 # a single CMake invocation.
 100 if (APPLE AND CMAKE_OSX_ARCHITECTURES)
 101   set(TARGET_ARCH ${CMAKE_OSX_ARCHITECTURES})
 102 else()
 103   set(TARGET_ARCH ${CMAKE_SYSTEM_PROCESSOR})
 104 endif()
 105
 106 if(PNG_HARDWARE_OPTIMIZATIONS)
 107
 108 # Set definitions and sources for ARM.
 109 if(TARGET_ARCH MATCHES "^arm" OR
 110    TARGET_ARCH MATCHES "^aarch64")
 111   if(TARGET_ARCH MATCHES "^arm64" OR
 112      TARGET_ARCH MATCHES "^aarch64")
 113     set(PNG_ARM_NEON_POSSIBLE_VALUES on off)
 114     set(PNG_ARM_NEON "on"
 115         CACHE STRING "Enable ARM NEON optimizations: on|off; on is default")
 116   else()
 117     set(PNG_ARM_NEON_POSSIBLE_VALUES check on off)
 118     set(PNG_ARM_NEON "off"
 119         CACHE STRING "Enable ARM NEON optimizations: check|on|off; off is default")
 120   endif()
 121   set_property(CACHE PNG_ARM_NEON
 122                PROPERTY STRINGS ${PNG_ARM_NEON_POSSIBLE_VALUES})
 123   list(FIND PNG_ARM_NEON_POSSIBLE_VALUES ${PNG_ARM_NEON} index)
 124   if(index EQUAL -1)
 125     message(FATAL_ERROR "PNG_ARM_NEON must be one of [${PNG_ARM_NEON_POSSIBLE_VALUES}]")
 126   elseif(NOT ${PNG_ARM_NEON} STREQUAL "off")
 127     set(libpng_arm_sources
 128         arm/arm_init.c
 129         arm/filter_neon.S
 130         arm/filter_neon_intrinsics.c
 131         arm/palette_neon_intrinsics.c)
 132     if(${PNG_ARM_NEON} STREQUAL "on")
 133       add_definitions(-DPNG_ARM_NEON_OPT=2)
 134     elseif(${PNG_ARM_NEON} STREQUAL "check")
 135       add_definitions(-DPNG_ARM_NEON_CHECK_SUPPORTED)
 136     endif()
 137   else()
 138     add_definitions(-DPNG_ARM_NEON_OPT=0)
 139   endif()
 140 endif()
 141
 142 # Set definitions and sources for PowerPC.
 143 if(TARGET_ARCH MATCHES "^powerpc*" OR
 144    TARGET_ARCH MATCHES "^ppc64*")
 145   set(PNG_POWERPC_VSX_POSSIBLE_VALUES on off)
 146   set(PNG_POWERPC_VSX "on"
 147       CACHE STRING "Enable POWERPC VSX optimizations: on|off; on is default")
 148   set_property(CACHE PNG_POWERPC_VSX
 149                PROPERTY STRINGS ${PNG_POWERPC_VSX_POSSIBLE_VALUES})
 150   list(FIND PNG_POWERPC_VSX_POSSIBLE_VALUES ${PNG_POWERPC_VSX} index)
 151   if(index EQUAL -1)
 152     message(FATAL_ERROR "PNG_POWERPC_VSX must be one of [${PNG_POWERPC_VSX_POSSIBLE_VALUES}]")
 153   elseif(NOT ${PNG_POWERPC_VSX} STREQUAL "off")
 154     set(libpng_powerpc_sources
 155         powerpc/powerpc_init.c
 156         powerpc/filter_vsx_intrinsics.c)
 157     if(${PNG_POWERPC_VSX} STREQUAL "on")
 158       add_definitions(-DPNG_POWERPC_VSX_OPT=2)
 159     endif()
 160   else()
 161     add_definitions(-DPNG_POWERPC_VSX_OPT=0)
 162   endif()
 163 endif()
 164
 165 # Set definitions and sources for Intel.
 166 if(TARGET_ARCH MATCHES "^i?86" OR
 167    TARGET_ARCH MATCHES "^x86_64*")
 168   set(PNG_INTEL_SSE_POSSIBLE_VALUES on off)
 169   set(PNG_INTEL_SSE "on"
 170       CACHE STRING "Enable INTEL_SSE optimizations: on|off; on is default")
 171   set_property(CACHE PNG_INTEL_SSE
 172                PROPERTY STRINGS ${PNG_INTEL_SSE_POSSIBLE_VALUES})
 173   list(FIND PNG_INTEL_SSE_POSSIBLE_VALUES ${PNG_INTEL_SSE} index)
 174   if(index EQUAL -1)
 175     message(FATAL_ERROR "PNG_INTEL_SSE must be one of [${PNG_INTEL_SSE_POSSIBLE_VALUES}]")
 176   elseif(NOT ${PNG_INTEL_SSE} STREQUAL "off")
 177     set(libpng_intel_sources
 178         intel/intel_init.c
 179         intel/filter_sse2_intrinsics.c)
 180     if(${PNG_INTEL_SSE} STREQUAL "on")
 181       add_definitions(-DPNG_INTEL_SSE_OPT=1)
 182     endif()
 183   else()
 184     add_definitions(-DPNG_INTEL_SSE_OPT=0)
 185   endif()
 186 endif()
 187
 188 # Set definitions and sources for MIPS.
 189 if(TARGET_ARCH MATCHES "mipsel*" OR
 190    TARGET_ARCH MATCHES "mips64el*")
 191   set(PNG_MIPS_MSA_POSSIBLE_VALUES on off)
 192   set(PNG_MIPS_MSA "on"
 193       CACHE STRING "Enable MIPS_MSA optimizations: on|off; on is default")
 194   set_property(CACHE PNG_MIPS_MSA
 195                PROPERTY STRINGS ${PNG_MIPS_MSA_POSSIBLE_VALUES})
 196   list(FIND PNG_MIPS_MSA_POSSIBLE_VALUES ${PNG_MIPS_MSA} index)
 197   if(index EQUAL -1)
 198     message(FATAL_ERROR "PNG_MIPS_MSA must be one of [${PNG_MIPS_MSA_POSSIBLE_VALUES}]")
 199   elseif(NOT ${PNG_MIPS_MSA} STREQUAL "off")
 200     set(libpng_mips_sources
 201         mips/mips_init.c
 202         mips/filter_msa_intrinsics.c)
 203     if(${PNG_MIPS_MSA} STREQUAL "on")
 204       add_definitions(-DPNG_MIPS_MSA_OPT=2)
 205     endif()
 206   else()
 207     add_definitions(-DPNG_MIPS_MSA_OPT=0)
 208   endif()
 209 endif()
 210
 211 else(PNG_HARDWARE_OPTIMIZATIONS)
 212
 213 # Set definitions and sources for ARM.
 214 if(TARGET_ARCH MATCHES "^arm" OR
 215    TARGET_ARCH MATCHES "^aarch64")
 216   add_definitions(-DPNG_ARM_NEON_OPT=0)
 217 endif()
 218
 219 # Set definitions and sources for PowerPC.
 220 if(TARGET_ARCH MATCHES "^powerpc*" OR
 221    TARGET_ARCH MATCHES "^ppc64*")
 222   add_definitions(-DPNG_POWERPC_VSX_OPT=0)
 223 endif()
 224
 225 # Set definitions and sources for Intel.
 226 if(TARGET_ARCH MATCHES "^i?86" OR
 227    TARGET_ARCH MATCHES "^x86_64*")
 228   add_definitions(-DPNG_INTEL_SSE_OPT=0)
 229 endif()
 230
 231 # Set definitions and sources for MIPS.
 232 if(TARGET_ARCH MATCHES "mipsel*" OR
 233    TARGET_ARCH MATCHES "mips64el*")
 234   add_definitions(-DPNG_MIPS_MSA_OPT=0)
 235 endif()
 236
 237 endif(PNG_HARDWARE_OPTIMIZATIONS)
 238
 239 option(ld-version-script "Enable linker version script" ON)
 240 if(ld-version-script AND NOT ANDROID AND NOT APPLE)
 241   # Check if LD supports linker scripts.
 242   file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/conftest.map" "
 243 VERS_1 { global: sym1; local: *; };
 244 VERS_2 { global: sym2; main; } VERS_1;
 245 ")
 246   set(_SAVED_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
 247   if(NOT CMAKE_HOST_SYSTEM_NAME MATCHES "^SunOS")
 248     # Avoid using CMAKE_SHARED_LIBRARY_C_FLAGS in version script checks on
 249     # Solaris, because of an incompatibility with the Solaris link editor.
 250     list(APPEND CMAKE_REQUIRED_FLAGS ${CMAKE_SHARED_LIBRARY_C_FLAGS})
 251   endif()
 252   list(APPEND CMAKE_REQUIRED_FLAGS "-Wl,--version-script='${CMAKE_CURRENT_BINARY_DIR}/conftest.map'")
 253   check_c_source_compiles("
 254 void sym1(void) {}
 255 void sym2(void) {}
 256 int main(void) { return 0; }
 257 " HAVE_LD_VERSION_SCRIPT)
 258   if(NOT HAVE_LD_VERSION_SCRIPT)
 259     set(CMAKE_REQUIRED_FLAGS ${_SAVED_CMAKE_REQUIRED_FLAGS})
 260     if(NOT CMAKE_HOST_SYSTEM_NAME MATCHES "^SunOS")
 261       # Again, avoid using CMAKE_SHARED_LIBRARY_C_FLAGS in version script
 262       # checks on Solaris.
 263       list(APPEND CMAKE_REQUIRED_FLAGS ${CMAKE_SHARED_LIBRARY_C_FLAGS})
 264     endif()
 265     list(APPEND CMAKE_REQUIRED_FLAGS "-Wl,-M -Wl,${CMAKE_CURRENT_BINARY_DIR}/conftest.map")
 266     check_c_source_compiles("
 267 void sym1(void) {}
 268 void sym2(void) {}
 269 int main(void) { return 0; }
 270 " HAVE_SOLARIS_LD_VERSION_SCRIPT)
 271   endif()
 272   set(CMAKE_REQUIRED_FLAGS ${_SAVED_CMAKE_REQUIRED_FLAGS})
 273   file(REMOVE "${CMAKE_CURRENT_BINARY_DIR}/conftest.map")
 274 endif()
 275
 276 # Find symbol prefix.  Likely obsolete and unnecessary with recent
 277 # toolchains (it's not done in many other projects).
 278 function(find_symbol_prefix)
 279   set(SYMBOL_PREFIX)
 280
 281   execute_process(COMMAND "${CMAKE_C_COMPILER}" -E -
 282                   INPUT_FILE /dev/null
 283                   OUTPUT_VARIABLE OUT
 284                   RESULT_VARIABLE STATUS)
 285
 286   if(CPP_FAIL)
 287     message(WARNING "Failed to run the C preprocessor")
 288   endif()
 289
 290   string(REPLACE "\n" ";" OUT "${OUT}")
 291   foreach(line ${OUT})
 292     string(REGEX MATCH "^PREFIX=" found_match "${line}")
 293     if(found_match)
 294       string(REGEX REPLACE "^PREFIX=(.*\)" "\\1" prefix "${line}")
 295       string(REGEX MATCH "__USER_LABEL_PREFIX__" found_match "${prefix}")
 296       if(found_match)
 297         string(REGEX REPLACE "(.*)__USER_LABEL_PREFIX__(.*)" "\\1\\2" prefix "${prefix}")
 298       endif()
 299       set(SYMBOL_PREFIX "${prefix}")
 300     endif()
 301   endforeach()
 302
 303   message(STATUS "Symbol prefix: ${SYMBOL_PREFIX}")
 304   set(SYMBOL_PREFIX "${SYMBOL_PREFIX}" PARENT_SCOPE)
 305 endfunction()
 306
 307 if(UNIX)
 308   find_symbol_prefix()
 309 endif()
 310
 311 find_program(AWK NAMES gawk awk)
 312
 313 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 314
 315 if(NOT AWK OR ANDROID OR IOS)
 316   # No awk available to generate sources; use pre-built pnglibconf.h
 317   configure_file(${CMAKE_CURRENT_SOURCE_DIR}/scripts/pnglibconf.h.prebuilt
 318                  ${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.h)
 319   add_custom_target(png_genfiles)
 320 else()
 321   # Copy the awk scripts, converting their line endings to Unix (LF)
 322   configure_file(${CMAKE_CURRENT_SOURCE_DIR}/scripts/checksym.awk
 323                  ${CMAKE_CURRENT_BINARY_DIR}/scripts/checksym.awk
 324                  @ONLY
 325                  NEWLINE_STYLE LF)
 326   configure_file(${CMAKE_CURRENT_SOURCE_DIR}/scripts/options.awk
 327                  ${CMAKE_CURRENT_BINARY_DIR}/scripts/options.awk
 328                  @ONLY
 329                  NEWLINE_STYLE LF)
 330   configure_file(${CMAKE_CURRENT_SOURCE_DIR}/scripts/dfn.awk
 331                  ${CMAKE_CURRENT_BINARY_DIR}/scripts/dfn.awk
 332                  @ONLY
 333                  NEWLINE_STYLE LF)
 334
 335   # Generate .chk from .out with awk:
 336   # generate_chk(INPUT inputfile OUTPUT outputfile [DEPENDS dep1 [dep2...]])
 337   function(generate_chk)
 338     set(options)
 339     set(oneValueArgs INPUT OUTPUT)
 340     set(multiValueArgs DEPENDS)
 341     cmake_parse_arguments(_GC "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
 342     if(NOT _GC_INPUT)
 343       message(FATAL_ERROR "generate_chk: Missing INPUT argument")
 344     endif()
 345     if(NOT _GC_OUTPUT)
 346       message(FATAL_ERROR "generate_chk: Missing OUTPUT argument")
 347     endif()
 348
 349     add_custom_command(OUTPUT "${_GC_OUTPUT}"
 350                        COMMAND "${CMAKE_COMMAND}"
 351                                "-DINPUT=${_GC_INPUT}"
 352                                "-DOUTPUT=${_GC_OUTPUT}"
 353                                -P "${CMAKE_CURRENT_BINARY_DIR}/scripts/genchk.cmake"
 354                        DEPENDS "${_GC_INPUT}" ${_GC_DEPENDS}
 355                        WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
 356   endfunction()
 357
 358   # Generate .out from .c with awk
 359   # generate_out(INPUT inputfile OUTPUT outputfile [DEPENDS dep1 [dep2...]])
 360   function(generate_out)
 361     set(options)
 362     set(oneValueArgs INPUT OUTPUT)
 363     set(multiValueArgs DEPENDS)
 364     cmake_parse_arguments(_GO "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
 365     if(NOT _GO_INPUT)
 366       message(FATAL_ERROR "generate_out: Missing INPUT argument")
 367     endif()
 368     if(NOT _GO_OUTPUT)
 369       message(FATAL_ERROR "generate_out: Missing OUTPUT argument")
 370     endif()
 371
 372     add_custom_command(OUTPUT "${_GO_OUTPUT}"
 373                        COMMAND "${CMAKE_COMMAND}"
 374                                "-DINPUT=${_GO_INPUT}"
 375                                "-DOUTPUT=${_GO_OUTPUT}"
 376                                -P "${CMAKE_CURRENT_BINARY_DIR}/scripts/genout.cmake"
 377                        DEPENDS "${_GO_INPUT}" ${_GO_DEPENDS}
 378                        WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
 379   endfunction()
 380
 381   # Generate specific source file with awk
 382   # generate_source(OUTPUT outputfile [DEPENDS dep1 [dep2...]])
 383   function(generate_source)
 384     set(options)
 385     set(oneValueArgs OUTPUT)
 386     set(multiValueArgs DEPENDS)
 387     cmake_parse_arguments(_GSO "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
 388     if(NOT _GSO_OUTPUT)
 389       message(FATAL_ERROR "generate_source: Missing OUTPUT argument")
 390     endif()
 391
 392     add_custom_command(OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${_GSO_OUTPUT}"
 393                        COMMAND "${CMAKE_COMMAND}"
 394                                "-DOUTPUT=${_GSO_OUTPUT}"
 395                                -P "${CMAKE_CURRENT_BINARY_DIR}/scripts/gensrc.cmake"
 396                        DEPENDS ${_GSO_DEPENDS}
 397                        WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
 398   endfunction()
 399
 400   # Copy file
 401   # generate_copy(INPUT inputfile OUTPUT outputfile [DEPENDS dep1 [dep2...]])
 402   function(generate_copy)
 403     set(options)
 404     set(oneValueArgs INPUT OUTPUT)
 405     set(multiValueArgs DEPENDS)
 406     cmake_parse_arguments(_GCO "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
 407     if(NOT _GCO_INPUT)
 408       message(FATAL_ERROR "generate_copy: Missing INPUT argument")
 409     endif()
 410     if(NOT _GCO_OUTPUT)
 411       message(FATAL_ERROR "generate_copy: Missing OUTPUT argument")
 412     endif()
 413
 414     add_custom_command(OUTPUT "${_GCO_OUTPUT}"
 415                        COMMAND "${CMAKE_COMMAND}"
 416                                -E remove "${_GCO_OUTPUT}"
 417                        COMMAND "${CMAKE_COMMAND}"
 418                                -E copy "${_GCO_INPUT}" "${_GCO_OUTPUT}"
 419                        DEPENDS "${source}" ${_GCO_DEPENDS})
 420   endfunction()
 421
 422   # Generate scripts/pnglibconf.h
 423   generate_source(OUTPUT "scripts/pnglibconf.c"
 424                   DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/scripts/pnglibconf.dfa"
 425                           "${CMAKE_CURRENT_BINARY_DIR}/scripts/options.awk"
 426                           "${CMAKE_CURRENT_SOURCE_DIR}/pngconf.h")
 427   add_custom_target(png_scripts_pnglibconf_c
 428                     DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/scripts/pnglibconf.c")
 429
 430   # Generate pnglibconf.c
 431   generate_source(OUTPUT "pnglibconf.c"
 432                   DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/scripts/pnglibconf.dfa"
 433                           "${CMAKE_CURRENT_BINARY_DIR}/scripts/options.awk"
 434                           "${CMAKE_CURRENT_SOURCE_DIR}/pngconf.h")
 435   add_custom_target(pnglibconf_c
 436                     DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.c")
 437
 438   if(PNG_PREFIX)
 439     set(PNGLIBCONF_H_EXTRA_DEPENDS
 440         "${CMAKE_CURRENT_BINARY_DIR}/scripts/prefix.out"
 441         "${CMAKE_CURRENT_SOURCE_DIR}/scripts/macro.lst")
 442     set(PNGPREFIX_H_EXTRA_DEPENDS
 443         "${CMAKE_CURRENT_BINARY_DIR}/scripts/intprefix.out")
 444   endif()
 445
 446   generate_out(INPUT "${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.c"
 447                OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.out"
 448                DEPENDS pnglibconf_c)
 449   add_custom_target(pnglibconf_out
 450                     DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.out")
 451
 452   # Generate pnglibconf.h
 453   generate_source(OUTPUT "pnglibconf.h"
 454                   DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.out" pnglibconf_out
 455                           ${PNGLIBCONF_H_EXTRA_DEPENDS})
 456   add_custom_target(pnglibconf_h
 457                     DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.h")
 458
 459   generate_out(INPUT "${CMAKE_CURRENT_SOURCE_DIR}/scripts/intprefix.c"
 460                OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/scripts/intprefix.out"
 461                DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.h" pnglibconf_h)
 462   add_custom_target(png_scripts_intprefix_out
 463                     DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/scripts/intprefix.out")
 464
 465   generate_out(INPUT "${CMAKE_CURRENT_SOURCE_DIR}/scripts/prefix.c"
 466                OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/scripts/prefix.out"
 467                DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/png.h"
 468                        "${CMAKE_CURRENT_SOURCE_DIR}/pngconf.h"
 469                        "${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.out" pnglibconf_out)
 470   add_custom_target(png_scripts_prefix_out
 471                     DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/scripts/prefix.out")
 472
 473   # Generate pngprefix.h
 474   generate_source(OUTPUT "pngprefix.h"
 475                   DEPENDS ${PNGPREFIX_H_EXTRA_DEPENDS})
 476   add_custom_target(pngprefix_h
 477                     DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/pngprefix.h")
 478
 479   generate_out(INPUT "${CMAKE_CURRENT_SOURCE_DIR}/scripts/sym.c"
 480                OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/scripts/sym.out"
 481                DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.h" pnglibconf_h)
 482   add_custom_target(png_scripts_sym_out
 483                     DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/scripts/sym.out")
 484
 485   generate_out(INPUT "${CMAKE_CURRENT_SOURCE_DIR}/scripts/symbols.c"
 486                OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/scripts/symbols.out"
 487                DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/png.h"
 488                        "${CMAKE_CURRENT_SOURCE_DIR}/pngconf.h"
 489                        "${CMAKE_CURRENT_SOURCE_DIR}/scripts/pnglibconf.h.prebuilt")
 490   add_custom_target(png_scripts_symbols_out
 491                     DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/scripts/symbols.out")
 492
 493   generate_out(INPUT "${CMAKE_CURRENT_SOURCE_DIR}/scripts/vers.c"
 494                OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/scripts/vers.out"
 495                DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/png.h"
 496                        "${CMAKE_CURRENT_SOURCE_DIR}/pngconf.h"
 497                        "${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.h" pnglibconf_h)
 498   add_custom_target(png_scripts_vers_out
 499                     DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/scripts/vers.out")
 500
 501   generate_chk(INPUT "${CMAKE_CURRENT_BINARY_DIR}/scripts/symbols.out"
 502                OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/scripts/symbols.chk"
 503                DEPENDS png_scripts_symbols_out
 504                        "${CMAKE_CURRENT_BINARY_DIR}/scripts/checksym.awk"
 505                        "${CMAKE_CURRENT_SOURCE_DIR}/scripts/symbols.def")
 506
 507   add_custom_target(png_scripts_symbols_chk
 508                     DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/scripts/symbols.chk")
 509
 510   generate_copy(INPUT "${CMAKE_CURRENT_BINARY_DIR}/scripts/sym.out"
 511                 OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/libpng.sym"
 512                 DEPENDS png_scripts_sym_out)
 513   generate_copy(INPUT "${CMAKE_CURRENT_BINARY_DIR}/scripts/vers.out"
 514                 OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/libpng.vers"
 515                 DEPENDS png_scripts_vers_out)
 516
 517   add_custom_target(png_genvers
 518                     DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/libpng.vers")
 519   add_custom_target(png_gensym
 520                     DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/libpng.sym")
 521
 522   add_custom_target(png_genprebuilt
 523                     COMMAND "${CMAKE_COMMAND}"
 524                             "-DOUTPUT=scripts/pnglibconf.h.prebuilt"
 525                             -P "${CMAKE_CURRENT_BINARY_DIR}/scripts/gensrc.cmake"
 526                     WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
 527
 528   # A single target handles generation of all generated files.
 529   add_custom_target(png_genfiles
 530                     DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/libpng.sym" png_gensym
 531                             "${CMAKE_CURRENT_BINARY_DIR}/libpng.vers" png_genvers
 532                             "${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.c" pnglibconf_c
 533                             "${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.h" pnglibconf_h
 534                             "${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.out" pnglibconf_out
 535                             "${CMAKE_CURRENT_BINARY_DIR}/pngprefix.h" pngprefix_h
 536                             "${CMAKE_CURRENT_BINARY_DIR}/scripts/intprefix.out" png_scripts_intprefix_out
 537                             "${CMAKE_CURRENT_BINARY_DIR}/scripts/pnglibconf.c" png_scripts_pnglibconf_c
 538                             "${CMAKE_CURRENT_BINARY_DIR}/scripts/prefix.out" png_scripts_prefix_out
 539                             "${CMAKE_CURRENT_BINARY_DIR}/scripts/sym.out" png_scripts_sym_out
 540                             "${CMAKE_CURRENT_BINARY_DIR}/scripts/symbols.chk" png_scripts_symbols_chk
 541                             "${CMAKE_CURRENT_BINARY_DIR}/scripts/symbols.out" png_scripts_symbols_out
 542                             "${CMAKE_CURRENT_BINARY_DIR}/scripts/vers.out" png_scripts_vers_out)
 543 endif(NOT AWK OR ANDROID OR IOS)
 544
 545 # List the source code files.
 546 set(libpng_public_hdrs
 547     png.h
 548     pngconf.h
 549     "${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.h"
 550 )
 551 set(libpng_private_hdrs
 552     pngpriv.h
 553     pngdebug.h
 554     pnginfo.h
 555     pngstruct.h
 556 )
 557 if(AWK AND NOT ANDROID AND NOT IOS)
 558   list(APPEND libpng_private_hdrs "${CMAKE_CURRENT_BINARY_DIR}/pngprefix.h")
 559 endif()
 560 set(libpng_sources
 561     ${libpng_public_hdrs}
 562     ${libpng_private_hdrs}
 563     png.c
 564     pngerror.c
 565     pngget.c
 566     pngmem.c
 567     pngpread.c
 568     pngread.c
 569     pngrio.c
 570     pngrtran.c
 571     pngrutil.c
 572     pngset.c
 573     pngtrans.c
 574     pngwio.c
 575     pngwrite.c
 576     pngwtran.c
 577     pngwutil.c
 578     ${libpng_arm_sources}
 579     ${libpng_intel_sources}
 580     ${libpng_mips_sources}
 581     ${libpng_powerpc_sources}
 582 )
 583 set(pngtest_sources
 584     pngtest.c
 585 )
 586 set(pngvalid_sources
 587     contrib/libtests/pngvalid.c
 588 )
 589 set(pngstest_sources
 590     contrib/libtests/pngstest.c
 591 )
 592 set(pngunknown_sources
 593     contrib/libtests/pngunknown.c
 594 )
 595 set(pngimage_sources
 596     contrib/libtests/pngimage.c
 597 )
 598 set(pngfix_sources
 599     contrib/tools/pngfix.c
 600 )
 601 set(png_fix_itxt_sources
 602     contrib/tools/png-fix-itxt.c
 603 )
 604
 605 if(MSVC OR (WIN32 AND (CMAKE_C_COMPILER_ID MATCHES ".*Clang")))
 606   add_definitions(-D_CRT_NONSTDC_NO_DEPRECATE)
 607   add_definitions(-D_CRT_SECURE_NO_DEPRECATE)
 608 endif()
 609
 610 if(PNG_DEBUG)
 611   add_definitions(-DPNG_DEBUG)
 612 endif()
 613
 614 # Now build our targets.
 615 include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${ZLIB_INCLUDE_DIRS})
 616
 617 # Initialize the list of libpng library targets.
 618 set(PNG_LIBRARY_TARGETS "")
 619
 620 # Initialize the libpng library file names.
 621 if(UNIX
 622    OR (WIN32 AND NOT "${CMAKE_SHARED_LIBRARY_PREFIX}" STREQUAL "")
 623    OR (WIN32 AND NOT "${CMAKE_STATIC_LIBRARY_PREFIX}" STREQUAL ""))
 624   # We are on a Unix or Unix-like toolchain like the GNU toolchain on Windows.
 625   # Library file names are expected to have an implicit prefix such as "lib".
 626   # Let CMake prepend and append its usual prefixes and suffixes by default.
 627   set(PNG_SHARED_OUTPUT_NAME "png${PNGLIB_ABI_VERSION}")
 628   set(PNG_STATIC_OUTPUT_NAME "png${PNGLIB_ABI_VERSION}")
 629 else()
 630   # We are, most likely, on a Windows toolchain like MSVC, Clang on Windows,
 631   # Borland/Embarcadero, etc. We need to specify the "libpng" name explicitly.
 632   # We also need to use a custom suffix, in order to distinguish between the
 633   # shared import library name and the static library name.
 634   set(PNG_SHARED_OUTPUT_NAME "libpng${PNGLIB_ABI_VERSION}")
 635   set(PNG_STATIC_OUTPUT_NAME "libpng${PNGLIB_ABI_VERSION}_static")
 636 endif()
 637
 638 if(PNG_SHARED)
 639   add_library(png_shared SHARED ${libpng_sources})
 640   add_dependencies(png_shared png_genfiles)
 641   list(APPEND PNG_LIBRARY_TARGETS png_shared)
 642   set_target_properties(png_shared PROPERTIES
 643                         OUTPUT_NAME "${PNG_SHARED_OUTPUT_NAME}"
 644                         DEBUG_POSTFIX "${PNG_DEBUG_POSTFIX}"
 645                         VERSION "${PNGLIB_SHARED_VERSION}"
 646                         SOVERSION "${PNGLIB_ABI_VERSION}")
 647   if(UNIX AND AWK)
 648     if(HAVE_LD_VERSION_SCRIPT)
 649       set_target_properties(png_shared PROPERTIES
 650                             LINK_FLAGS "-Wl,--version-script='${CMAKE_CURRENT_BINARY_DIR}/libpng.vers'")
 651     elseif(HAVE_SOLARIS_LD_VERSION_SCRIPT)
 652       set_target_properties(png_shared PROPERTIES
 653                             LINK_FLAGS "-Wl,-M -Wl,'${CMAKE_CURRENT_BINARY_DIR}/libpng.vers'")
 654     endif()
 655   endif()
 656   if(WIN32)
 657     set_target_properties(png_shared PROPERTIES DEFINE_SYMBOL PNG_BUILD_DLL)
 658   endif()
 659   target_link_libraries(png_shared ${ZLIB_LIBRARIES} ${M_LIBRARY})
 660 endif()
 661
 662 if(PNG_STATIC)
 663   add_library(png_static STATIC ${libpng_sources})
 664   add_dependencies(png_static png_genfiles)
 665   list(APPEND PNG_LIBRARY_TARGETS png_static)
 666   set_target_properties(png_static PROPERTIES
 667                         OUTPUT_NAME "${PNG_STATIC_OUTPUT_NAME}"
 668                         DEBUG_POSTFIX "${PNG_DEBUG_POSTFIX}")
 669   target_link_libraries(png_static ${ZLIB_LIBRARIES} ${M_LIBRARY})
 670 endif()
 671
 672 if(PNG_FRAMEWORK)
 673   add_library(png_framework SHARED ${libpng_sources})
 674   add_dependencies(png_framework png_genfiles)
 675   list(APPEND PNG_LIBRARY_TARGETS png_framework)
 676   set_target_properties(png_framework PROPERTIES
 677                         FRAMEWORK TRUE
 678                         FRAMEWORK_VERSION "${PNGLIB_VERSION}"
 679                         MACOSX_FRAMEWORK_SHORT_VERSION_STRING "${PNGLIB_MAJOR}.${PNGLIB_MINOR}"
 680                         MACOSX_FRAMEWORK_BUNDLE_VERSION "${PNGLIB_VERSION}"
 681                         MACOSX_FRAMEWORK_IDENTIFIER "org.libpng.libpng"
 682                         XCODE_ATTRIBUTE_INSTALL_PATH "@rpath"
 683                         PUBLIC_HEADER "${libpng_public_hdrs}"
 684                         OUTPUT_NAME "png")
 685   target_link_libraries(png_framework ${ZLIB_LIBRARIES} ${M_LIBRARY})
 686 endif()
 687
 688 if(NOT PNG_LIBRARY_TARGETS)
 689   message(SEND_ERROR "No library variant selected to build. "
 690                      "Please enable at least one of the following options: "
 691                      "PNG_SHARED, PNG_STATIC, PNG_FRAMEWORK")
 692 endif()
 693
 694 function(png_add_test)
 695   set(options)
 696   set(oneValueArgs NAME COMMAND)
 697   set(multiValueArgs OPTIONS FILES)
 698   cmake_parse_arguments(_PAT "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
 699   if(NOT _PAT_NAME)
 700     message(FATAL_ERROR "png_add_test: Missing NAME argument")
 701   endif()
 702   if(NOT _PAT_COMMAND)
 703     message(FATAL_ERROR "png_add_test: Missing COMMAND argument")
 704   endif()
 705
 706   set(TEST_OPTIONS "${_PAT_OPTIONS}")
 707   set(TEST_FILES "${_PAT_FILES}")
 708
 709   configure_file("${CMAKE_CURRENT_SOURCE_DIR}/scripts/test.cmake.in"
 710                  "${CMAKE_CURRENT_BINARY_DIR}/tests/${_PAT_NAME}.cmake"
 711                  @ONLY)
 712   add_test(NAME "${_PAT_NAME}"
 713            COMMAND "${CMAKE_COMMAND}"
 714                    "-DLIBPNG=$<TARGET_FILE:png_shared>"
 715                    "-DTEST_COMMAND=$<TARGET_FILE:${_PAT_COMMAND}>"
 716                    -P "${CMAKE_CURRENT_BINARY_DIR}/tests/${_PAT_NAME}.cmake")
 717 endfunction()
 718
 719 if(PNG_TESTS AND PNG_SHARED)
 720   # Find test PNG files by globbing, but sort lists to ensure
 721   # consistency between different filesystems.
 722   file(GLOB PNGSUITE_PNGS "${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/*.png")
 723   list(SORT PNGSUITE_PNGS)
 724   file(GLOB TEST_PNGS "${CMAKE_CURRENT_SOURCE_DIR}/contrib/testpngs/*.png")
 725   list(SORT TEST_PNGS)
 726
 727   set(PNGTEST_PNG "${CMAKE_CURRENT_SOURCE_DIR}/pngtest.png")
 728
 729   add_executable(pngtest ${pngtest_sources})
 730   target_link_libraries(pngtest png_shared)
 731
 732   png_add_test(NAME pngtest
 733                COMMAND pngtest
 734                FILES "${PNGTEST_PNG}")
 735
 736   add_executable(pngvalid ${pngvalid_sources})
 737   target_link_libraries(pngvalid png_shared)
 738
 739   png_add_test(NAME pngvalid-gamma-16-to-8
 740                COMMAND pngvalid
 741                OPTIONS --gamma-16-to-8)
 742   png_add_test(NAME pngvalid-gamma-alpha-mode
 743                COMMAND pngvalid
 744                OPTIONS --gamma-alpha-mode)
 745   png_add_test(NAME pngvalid-gamma-background
 746                COMMAND pngvalid
 747                OPTIONS --gamma-background)
 748   png_add_test(NAME pngvalid-gamma-expand16-alpha-mode
 749                COMMAND pngvalid
 750                OPTIONS --gamma-alpha-mode --expand16)
 751   png_add_test(NAME pngvalid-gamma-expand16-background
 752                COMMAND pngvalid
 753                OPTIONS --gamma-background --expand16)
 754   png_add_test(NAME pngvalid-gamma-expand16-transform
 755                COMMAND pngvalid
 756                OPTIONS --gamma-transform --expand16)
 757   png_add_test(NAME pngvalid-gamma-sbit
 758                COMMAND pngvalid
 759                OPTIONS --gamma-sbit)
 760   png_add_test(NAME pngvalid-gamma-threshold
 761                COMMAND pngvalid
 762                OPTIONS --gamma-threshold)
 763   png_add_test(NAME pngvalid-gamma-transform
 764                COMMAND pngvalid
 765                OPTIONS --gamma-transform)
 766   png_add_test(NAME pngvalid-progressive-interlace-standard
 767                COMMAND pngvalid
 768                OPTIONS --standard --progressive-read --interlace)
 769   png_add_test(NAME pngvalid-progressive-size
 770                COMMAND pngvalid
 771                OPTIONS --size --progressive-read)
 772   png_add_test(NAME pngvalid-progressive-standard
 773                COMMAND pngvalid
 774                OPTIONS --standard --progressive-read)
 775   png_add_test(NAME pngvalid-standard
 776                COMMAND pngvalid
 777                OPTIONS --standard)
 778   png_add_test(NAME pngvalid-transform
 779                COMMAND pngvalid
 780                OPTIONS --transform)
 781
 782   add_executable(pngstest ${pngstest_sources})
 783   target_link_libraries(pngstest png_shared)
 784
 785   foreach(gamma_type 1.8 linear none sRGB)
 786     foreach(alpha_type none alpha)
 787       set(PNGSTEST_FILES)
 788       foreach(test_png ${TEST_PNGS})
 789         string(REGEX MATCH ".*-linear[-.].*" TEST_PNG_LINEAR "${test_png}")
 790         string(REGEX MATCH ".*-sRGB[-.].*" TEST_PNG_SRGB "${test_png}")
 791         string(REGEX MATCH ".*-1.8[-.].*" TEST_PNG_G18 "${test_png}")
 792         string(REGEX MATCH ".*-alpha-.*" TEST_PNG_ALPHA "${test_png}")
 793
 794         set(TEST_PNG_VALID TRUE)
 795
 796         if(TEST_PNG_ALPHA)
 797           if(NOT "${alpha_type}" STREQUAL "alpha")
 798             set(TEST_PNG_VALID FALSE)
 799           endif()
 800         else()
 801           if("${alpha_type}" STREQUAL "alpha")
 802             set(TEST_PNG_VALID FALSE)
 803           endif()
 804         endif()
 805
 806         if(TEST_PNG_LINEAR)
 807           if(NOT "${gamma_type}" STREQUAL "linear")
 808             set(TEST_PNG_VALID FALSE)
 809           endif()
 810         elseif(TEST_PNG_SRGB)
 811           if(NOT "${gamma_type}" STREQUAL "sRGB")
 812             set(TEST_PNG_VALID FALSE)
 813           endif()
 814         elseif(TEST_PNG_G18)
 815           if(NOT "${gamma_type}" STREQUAL "1.8")
 816             set(TEST_PNG_VALID FALSE)
 817           endif()
 818         else()
 819           if(NOT "${gamma_type}" STREQUAL "none")
 820             set(TEST_PNG_VALID FALSE)
 821           endif()
 822         endif()
 823
 824         if(TEST_PNG_VALID)
 825           list(APPEND PNGSTEST_FILES "${test_png}")
 826         endif()
 827       endforeach()
 828       # Should already be sorted, but sort anyway to be certain.
 829       list(SORT PNGSTEST_FILES)
 830       png_add_test(NAME pngstest-${gamma_type}-${alpha_type}
 831                    COMMAND pngstest
 832                    OPTIONS --tmpfile "${gamma_type}-${alpha_type}-" --log
 833                    FILES ${PNGSTEST_FILES})
 834     endforeach()
 835   endforeach()
 836
 837   add_executable(pngunknown ${pngunknown_sources})
 838   target_link_libraries(pngunknown png_shared)
 839
 840   png_add_test(NAME pngunknown-discard
 841                COMMAND pngunknown
 842                OPTIONS --strict default=discard
 843                FILES "${PNGTEST_PNG}")
 844   png_add_test(NAME pngunknown-IDAT
 845                COMMAND pngunknown
 846                OPTIONS --strict default=discard IDAT=save
 847                FILES "${PNGTEST_PNG}")
 848   png_add_test(NAME pngunknown-if-safe
 849                COMMAND pngunknown
 850                OPTIONS --strict default=if-safe
 851                FILES "${PNGTEST_PNG}")
 852   png_add_test(NAME pngunknown-sAPI
 853                COMMAND pngunknown
 854                OPTIONS --strict bKGD=save cHRM=save gAMA=save all=discard iCCP=save sBIT=save sRGB=save
 855                FILES "${PNGTEST_PNG}")
 856   png_add_test(NAME pngunknown-save
 857                COMMAND pngunknown
 858                OPTIONS --strict default=save
 859                FILES "${PNGTEST_PNG}")
 860   png_add_test(NAME pngunknown-sTER
 861                COMMAND pngunknown
 862                OPTIONS --strict sTER=if-safe
 863                FILES "${PNGTEST_PNG}")
 864   png_add_test(NAME pngunknown-vpAg
 865                COMMAND pngunknown
 866                OPTIONS --strict vpAg=if-safe
 867                FILES "${PNGTEST_PNG}")
 868
 869   add_executable(pngimage ${pngimage_sources})
 870   target_link_libraries(pngimage png_shared)
 871
 872   png_add_test(NAME pngimage-quick
 873                COMMAND pngimage
 874                OPTIONS --list-combos --log
 875                FILES ${PNGSUITE_PNGS})
 876   png_add_test(NAME pngimage-full
 877                COMMAND pngimage
 878                OPTIONS --exhaustive --list-combos --log
 879                FILES ${PNGSUITE_PNGS})
 880 endif()
 881
 882 if(PNG_SHARED AND PNG_EXECUTABLES)
 883   add_executable(pngfix ${pngfix_sources})
 884   target_link_libraries(pngfix png_shared)
 885   set(PNG_BIN_TARGETS pngfix)
 886
 887   add_executable(png-fix-itxt ${png_fix_itxt_sources})
 888   target_link_libraries(png-fix-itxt ${ZLIB_LIBRARIES} ${M_LIBRARY})
 889   list(APPEND PNG_BIN_TARGETS png-fix-itxt)
 890 endif()
 891
 892 # Create a symlink from src to dest (if possible), or, alternatively,
 893 # copy src to dest if different.
 894 function(create_symlink DEST_FILE)
 895   cmake_parse_arguments(_SYM "" "FILE;TARGET" "" ${ARGN})
 896   if(NOT _SYM_FILE AND NOT _SYM_TARGET)
 897     message(FATAL_ERROR "create_symlink: Missing FILE or TARGET argument")
 898   endif()
 899   if(_SYM_FILE AND _SYM_TARGET)
 900     message(FATAL_ERROR "create_symlink: "
 901                         "The arguments FILE (${_SYM_FILE}) and TARGET (${_SYM_TARGET}) "
 902                         "are mutually-exclusive")
 903   endif()
 904
 905   if(_SYM_FILE)
 906     # If we don't need to symlink something that's coming from a build target,
 907     # we can go ahead and symlink/copy at configure time.
 908     if(CMAKE_HOST_WIN32 AND NOT CYGWIN)
 909       execute_process(COMMAND "${CMAKE_COMMAND}"
 910                               -E copy_if_different
 911                               ${_SYM_FILE} ${DEST_FILE}
 912                       WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
 913     else()
 914       execute_process(COMMAND "${CMAKE_COMMAND}"
 915                               -E create_symlink
 916                               ${_SYM_FILE} ${DEST_FILE}
 917                       WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
 918     endif()
 919   endif()
 920
 921   if(_SYM_TARGET)
 922     # We need to use generator expressions, which can be a bit tricky.
 923     # For simplicity, make the symlink a POST_BUILD step, and use the TARGET
 924     # signature of add_custom_command.
 925     if(CMAKE_HOST_WIN32 AND NOT CYGWIN)
 926       add_custom_command(TARGET ${_SYM_TARGET}
 927                          POST_BUILD
 928                          COMMAND "${CMAKE_COMMAND}"
 929                                  -E copy_if_different
 930                                  $<TARGET_LINKER_FILE_NAME:${_SYM_TARGET}>
 931                                  $<TARGET_LINKER_FILE_DIR:${_SYM_TARGET}>/${DEST_FILE})
 932     else()
 933       add_custom_command(TARGET ${_SYM_TARGET}
 934                          POST_BUILD
 935                          COMMAND "${CMAKE_COMMAND}"
 936                                  -E create_symlink
 937                                  $<TARGET_LINKER_FILE_NAME:${_SYM_TARGET}>
 938                                  $<TARGET_LINKER_FILE_DIR:${_SYM_TARGET}>/${DEST_FILE})
 939     endif()
 940   endif()
 941 endfunction()
 942
 943 # Create source generation scripts.
 944 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/scripts/genchk.cmake.in
 945                ${CMAKE_CURRENT_BINARY_DIR}/scripts/genchk.cmake
 946                @ONLY)
 947 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/scripts/genout.cmake.in
 948                ${CMAKE_CURRENT_BINARY_DIR}/scripts/genout.cmake
 949                @ONLY)
 950 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/scripts/gensrc.cmake.in
 951                ${CMAKE_CURRENT_BINARY_DIR}/scripts/gensrc.cmake
 952                @ONLY)
 953
 954 # libpng is a library so default to 'lib'
 955 if(NOT DEFINED CMAKE_INSTALL_LIBDIR)
 956   set(CMAKE_INSTALL_LIBDIR lib)
 957 endif()
 958
 959 # Create pkgconfig files.
 960 # We use the same files like ./configure, so we have to set its vars.
 961 # Only do this on Windows for Cygwin - the files don't make much sense
 962 # outside of a UNIX look-alike.
 963 if(NOT WIN32 OR CYGWIN OR MINGW)
 964   set(prefix      ${CMAKE_INSTALL_PREFIX})
 965   set(exec_prefix ${CMAKE_INSTALL_PREFIX})
 966   set(libdir      ${CMAKE_INSTALL_FULL_LIBDIR})
 967   set(includedir  ${CMAKE_INSTALL_FULL_INCLUDEDIR})
 968   set(LIBS        "-lz -lm")
 969   configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libpng.pc.in
 970                  ${CMAKE_CURRENT_BINARY_DIR}/libpng${PNGLIB_ABI_VERSION}.pc
 971                  @ONLY)
 972   create_symlink(libpng.pc FILE libpng${PNGLIB_ABI_VERSION}.pc)
 973   configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libpng-config.in
 974                  ${CMAKE_CURRENT_BINARY_DIR}/libpng${PNGLIB_ABI_VERSION}-config
 975                  @ONLY)
 976   create_symlink(libpng-config FILE libpng${PNGLIB_ABI_VERSION}-config)
 977 endif()
 978
 979 # Install.
 980 if(NOT SKIP_INSTALL_LIBRARIES AND NOT SKIP_INSTALL_ALL)
 981   install(TARGETS ${PNG_LIBRARY_TARGETS}
 982           EXPORT libpng
 983           RUNTIME DESTINATION bin
 984           LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
 985           ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
 986           FRAMEWORK DESTINATION ${CMAKE_INSTALL_LIBDIR})
 987
 988   if(PNG_SHARED)
 989     # Create a symlink for libpng.dll.a => libpng16.dll.a on Cygwin
 990     if(CYGWIN OR MINGW)
 991       create_symlink(libpng${CMAKE_IMPORT_LIBRARY_SUFFIX} TARGET png_shared)
 992       install(FILES $<TARGET_LINKER_FILE_DIR:png_shared>/libpng${CMAKE_IMPORT_LIBRARY_SUFFIX}
 993               DESTINATION ${CMAKE_INSTALL_LIBDIR})
 994     endif()
 995
 996     if(NOT WIN32)
 997       create_symlink(libpng${CMAKE_SHARED_LIBRARY_SUFFIX} TARGET png_shared)
 998       install(FILES $<TARGET_LINKER_FILE_DIR:png_shared>/libpng${CMAKE_SHARED_LIBRARY_SUFFIX}
 999               DESTINATION ${CMAKE_INSTALL_LIBDIR})
1000     endif()
1001   endif()
1002
1003   if(PNG_STATIC)
1004     if(NOT WIN32 OR CYGWIN OR MINGW)
1005       create_symlink(libpng${CMAKE_STATIC_LIBRARY_SUFFIX} TARGET png_static)
1006       install(FILES $<TARGET_LINKER_FILE_DIR:png_static>/libpng${CMAKE_STATIC_LIBRARY_SUFFIX}
1007               DESTINATION ${CMAKE_INSTALL_LIBDIR})
1008     endif()
1009   endif()
1010 endif()
1011
1012 if(NOT SKIP_INSTALL_HEADERS AND NOT SKIP_INSTALL_ALL)
1013   install(FILES ${libpng_public_hdrs}
1014           DESTINATION include)
1015   install(FILES ${libpng_public_hdrs}
1016           DESTINATION include/libpng${PNGLIB_ABI_VERSION})
1017 endif()
1018 if(NOT SKIP_INSTALL_EXECUTABLES AND NOT SKIP_INSTALL_ALL)
1019   if(NOT WIN32 OR CYGWIN OR MINGW)
1020     install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/libpng-config
1021             DESTINATION bin)
1022     install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/libpng${PNGLIB_ABI_VERSION}-config
1023             DESTINATION bin)
1024   endif()
1025 endif()
1026
1027 if(NOT SKIP_INSTALL_PROGRAMS AND NOT SKIP_INSTALL_ALL)
1028   install(TARGETS ${PNG_BIN_TARGETS}
1029           RUNTIME DESTINATION bin)
1030 endif()
1031
1032 if(NOT SKIP_INSTALL_FILES AND NOT SKIP_INSTALL_ALL)
1033   # Install the man pages.
1034   install(FILES libpng.3 libpngpf.3
1035           DESTINATION ${CMAKE_INSTALL_MANDIR}/man3)
1036   install(FILES png.5
1037           DESTINATION ${CMAKE_INSTALL_MANDIR}/man5)
1038   # Install the pkg-config files.
1039   if(NOT CMAKE_HOST_WIN32 OR CYGWIN OR MINGW)
1040     install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libpng.pc
1041             DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
1042     install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/libpng-config
1043             DESTINATION ${CMAKE_INSTALL_BINDIR})
1044     install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libpng${PNGLIB_ABI_VERSION}.pc
1045             DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
1046     install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/libpng${PNGLIB_ABI_VERSION}-config
1047             DESTINATION ${CMAKE_INSTALL_BINDIR})
1048   endif()
1049 endif()
1050
1051 # Create an export file that CMake users can include() to import our targets.
1052 if(NOT SKIP_INSTALL_EXPORT AND NOT SKIP_INSTALL_ALL)
1053   install(EXPORT libpng
1054           DESTINATION lib/libpng
1055           FILE libpng${PNGLIB_ABI_VERSION}.cmake)
1056 endif()
1057
1058 # TODO: Create MSVC import lib for MinGW-compiled shared lib.
1059 # pexports libpng.dll > libpng.def
1060 # lib /def:libpng.def /machine:x86