diff --git a/CMakeLists.txt b/CMakeLists.txt index 0b905fc..4c45969 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,1952 +1,294 @@ -cmake version 2.8.9 ------------------------------------------------------------------------------- -Introduction - -CMakeLists - Reference of CMake properties. - ------------------------------------------------------------------------------- -Properties - - CMake Properties - Properties supported by CMake, the Cross-Platform Makefile Generator. - -This is the documentation for the properties supported by CMake. Properties -can have different scopes. They can either be assigned to a source file, a -directory, a target or globally to CMake. By modifying the values of -properties the behaviour of the build system can be customized. - ------------------------------------------------------------------------------- -Properties of Global Scope - - ALLOW_DUPLICATE_CUSTOM_TARGETS - Allow duplicate custom targets to be created. - - Normally CMake requires that all targets built in a project have - globally unique logical names (see policy CMP0002). This is necessary - to generate meaningful project file names in Xcode and VS IDE - generators. It also allows the target names to be referenced - unambiguously. - - Makefile generators are capable of supporting duplicate custom target - names. For projects that care only about Makefile generators and do - not wish to support Xcode or VS IDE generators, one may set this - property to true to allow duplicate custom targets. The property - allows multiple add_custom_target command calls in different - directories to specify the same target name. However, setting this - property will cause non-Makefile generators to produce an error and - refuse to generate the project. - - DEBUG_CONFIGURATIONS - Specify which configurations are for debugging. - - The value must be a semi-colon separated list of configuration names. - Currently this property is used only by the target_link_libraries - command (see its documentation for details). Additional uses may be - defined in the future. - - This property must be set at the top level of the project and before - the first target_link_libraries command invocation. If any entry in - the list does not match a valid configuration for the project the - behavior is undefined. - - DISABLED_FEATURES - List of features which are disabled during the CMake run. - - List of features which are disabled during the CMake run. By default - it contains the names of all packages which were not found. This is - determined using the _FOUND variables. Packages which are - searched QUIET are not listed. A project can add its own features to - this list. This property is used by the macros in - FeatureSummary.cmake. - - ENABLED_FEATURES - List of features which are enabled during the CMake run. - - List of features which are enabled during the CMake run. By default - it contains the names of all packages which were found. This is - determined using the _FOUND variables. Packages which are - searched QUIET are not listed. A project can add its own features to - this list. This property is used by the macros in - FeatureSummary.cmake. - - ENABLED_LANGUAGES - Read-only property that contains the list of currently enabled - languages - - Set to list of currently enabled languages. - - FIND_LIBRARY_USE_LIB64_PATHS - Whether FIND_LIBRARY should automatically search lib64 directories. - - FIND_LIBRARY_USE_LIB64_PATHS is a boolean specifying whether the - FIND_LIBRARY command should automatically search the lib64 variant of - directories called lib in the search path when building 64-bit - binaries. - - FIND_LIBRARY_USE_OPENBSD_VERSIONING - Whether FIND_LIBRARY should find OpenBSD-style shared libraries. - - This property is a boolean specifying whether the FIND_LIBRARY command - should find shared libraries with OpenBSD-style versioned extension: - ".so..". The property is set to true on OpenBSD and - false on other platforms. - - GLOBAL_DEPENDS_DEBUG_MODE - Enable global target dependency graph debug mode. - - CMake automatically analyzes the global inter-target dependency graph - at the beginning of native build system generation. This property - causes it to display details of its analysis to stderr. - - GLOBAL_DEPENDS_NO_CYCLES - Disallow global target dependency graph cycles. - - CMake automatically analyzes the global inter-target dependency graph - at the beginning of native build system generation. It reports an - error if the dependency graph contains a cycle that does not consist - of all STATIC library targets. This property tells CMake to disallow - all cycles completely, even among static libraries. - - IN_TRY_COMPILE - Read-only property that is true during a try-compile configuration. - - True when building a project inside a TRY_COMPILE or TRY_RUN command. - - PACKAGES_FOUND - List of packages which were found during the CMake run. - - List of packages which were found during the CMake run. Whether a - package has been found is determined using the _FOUND variables. - - PACKAGES_NOT_FOUND - List of packages which were not found during the CMake run. - - List of packages which were not found during the CMake run. Whether a - package has been found is determined using the _FOUND variables. - - PREDEFINED_TARGETS_FOLDER - Name of FOLDER for targets that are added automatically by CMake. - - If not set, CMake uses "CMakePredefinedTargets" as a default value for - this property. Targets such as INSTALL, PACKAGE and RUN_TESTS will be - organized into this FOLDER. See also the documentation for the FOLDER - target property. - - REPORT_UNDEFINED_PROPERTIES - If set, report any undefined properties to this file. - - If this property is set to a filename then when CMake runs it will - report any properties or variables that were accessed but not defined - into the filename specified in this property. - - RULE_LAUNCH_COMPILE - Specify a launcher for compile rules. - - Makefile generators prefix compiler commands with the given launcher - command line. This is intended to allow launchers to intercept build - problems with high granularity. Non-Makefile generators currently - ignore this property. - - RULE_LAUNCH_CUSTOM - Specify a launcher for custom rules. - - Makefile generators prefix custom commands with the given launcher - command line. This is intended to allow launchers to intercept build - problems with high granularity. Non-Makefile generators currently - ignore this property. - - RULE_LAUNCH_LINK - Specify a launcher for link rules. - - Makefile generators prefix link and archive commands with the given - launcher command line. This is intended to allow launchers to - intercept build problems with high granularity. Non-Makefile - generators currently ignore this property. - - RULE_MESSAGES - Specify whether to report a message for each make rule. - - This property specifies whether Makefile generators should add a - progress message describing what each build rule does. If the - property is not set the default is ON. Set the property to OFF to - disable granular messages and report only as each target completes. - This is intended to allow scripted builds to avoid the build time cost - of detailed reports. If a CMAKE_RULE_MESSAGES cache entry exists its - value initializes the value of this property. Non-Makefile generators - currently ignore this property. - - TARGET_ARCHIVES_MAY_BE_SHARED_LIBS - Set if shared libraries may be named like archives. - - On AIX shared libraries may be named "lib.a". This property is - set to true on such platforms. - - TARGET_SUPPORTS_SHARED_LIBS - Does the target platform support shared libraries. - - TARGET_SUPPORTS_SHARED_LIBS is a boolean specifying whether the target - platform supports shared libraries. Basically all current general - general purpose OS do so, the exception are usually embedded systems - with no or special OSs. - - USE_FOLDERS - Use the FOLDER target property to organize targets into folders. - - If not set, CMake treats this property as OFF by default. CMake - generators that are capable of organizing into a hierarchy of folders - use the values of the FOLDER target property to name those folders. - See also the documentation for the FOLDER target property. - - __CMAKE_DELETE_CACHE_CHANGE_VARS_ - Internal property - - Used to detect compiler changes, Do not set. - ------------------------------------------------------------------------------- -Properties on Directories - - ADDITIONAL_MAKE_CLEAN_FILES - Additional files to clean during the make clean stage. - - A list of files that will be cleaned as a part of the "make clean" - stage. - - CACHE_VARIABLES - List of cache variables available in the current directory. - - This read-only property specifies the list of CMake cache variables - currently defined. It is intended for debugging purposes. - - CLEAN_NO_CUSTOM - Should the output of custom commands be left. - - If this is true then the outputs of custom commands for this directory - will not be removed during the "make clean" stage. - - COMPILE_DEFINITIONS - Preprocessor definitions for compiling a directory's sources. - - The COMPILE_DEFINITIONS property may be set to a semicolon-separated - list of preprocessor definitions using the syntax VAR or VAR=value. - Function-style definitions are not supported. CMake will - automatically escape the value correctly for the native build system - (note that CMake language syntax may require escapes to specify some - values). This property may be set on a per-configuration basis using - the name COMPILE_DEFINITIONS_ where is an upper-case - name (ex. "COMPILE_DEFINITIONS_DEBUG"). This property will be - initialized in each directory by its value in the directory's parent. - - CMake will automatically drop some definitions that are not supported - by the native build tool. The VS6 IDE does not support definition - values with spaces (but NMake does). - - Disclaimer: Most native build tools have poor support for escaping - certain values. CMake has work-arounds for many cases but some values - may just not be possible to pass correctly. If a value does not seem - to be escaped correctly, do not attempt to work-around the problem by - adding escape sequences to the value. Your work-around may break in a - future version of CMake that has improved escape support. Instead - consider defining the macro in a (configured) header file. Then - report the limitation. Known limitations include: - - # - broken almost everywhere - ; - broken in VS IDE and Borland Makefiles - , - broken in VS IDE - % - broken in some cases in NMake - & | - broken in some cases on MinGW - ^ < > \" - broken in most Make tools on Windows - - CMake does not reject these values outright because they do work in - some cases. Use with caution. - - COMPILE_DEFINITIONS_ - Per-configuration preprocessor definitions in a directory. - - This is the configuration-specific version of COMPILE_DEFINITIONS. - This property will be initialized in each directory by its value in - the directory's parent. - - - DEFINITIONS - For CMake 2.4 compatibility only. Use COMPILE_DEFINITIONS instead. - - This read-only property specifies the list of flags given so far to - the add_definitions command. It is intended for debugging purposes. - Use the COMPILE_DEFINITIONS instead. - - EXCLUDE_FROM_ALL - Exclude the directory from the all target of its parent. - - A property on a directory that indicates if its targets are excluded - from the default build target. If it is not, then with a Makefile for - example typing make will cause the targets to be built. The same - concept applies to the default build of other generators. - - IMPLICIT_DEPENDS_INCLUDE_TRANSFORM - Specify #include line transforms for dependencies in a directory. - - This property specifies rules to transform macro-like #include lines - during implicit dependency scanning of C and C++ source files. The - list of rules must be semicolon-separated with each entry of the form - "A_MACRO(%)=value-with-%" (the % must be literal). During dependency - scanning occurrences of A_MACRO(...) on #include lines will be - replaced by the value given with the macro argument substituted for - '%'. For example, the entry - - MYDIR(%)= - - will convert lines of the form - - #include MYDIR(myheader.h) - - to - - #include - - allowing the dependency to be followed. - - This property applies to sources in all targets within a directory. - The property value is initialized in each directory by its value in - the directory's parent. - - INCLUDE_DIRECTORIES - List of preprocessor include file search directories. - - This property specifies the list of directories given so far to the - include_directories command. This property exists on directories and - targets. In addition to accepting values from the include_directories - command, values may be set directly on any directory or any target - using the set_property command. A target gets its initial value for - this property from the value of the directory property. A directory - gets its initial value from its parent directory if it has one. Both - directory and target property values are adjusted by calls to the - include_directories command. - - The target property values are used by the generators to set the - include paths for the compiler. See also the include_directories - command. - - INCLUDE_REGULAR_EXPRESSION - Include file scanning regular expression. - - This read-only property specifies the regular expression used during - dependency scanning to match include files that should be followed. - See the include_regular_expression command. - - INTERPROCEDURAL_OPTIMIZATION - Enable interprocedural optimization for targets in a directory. - - If set to true, enables interprocedural optimizations if they are - known to be supported by the compiler. - - INTERPROCEDURAL_OPTIMIZATION_ - Per-configuration interprocedural optimization for a directory. - - This is a per-configuration version of INTERPROCEDURAL_OPTIMIZATION. - If set, this property overrides the generic property for the named - configuration. - - LINK_DIRECTORIES - List of linker search directories. - - This read-only property specifies the list of directories given so far - to the link_directories command. It is intended for debugging - purposes. - - LISTFILE_STACK - The current stack of listfiles being processed. - - This property is mainly useful when trying to debug errors in your - CMake scripts. It returns a list of what list files are currently - being processed, in order. So if one listfile does an INCLUDE command - then that is effectively pushing the included listfile onto the stack. - - MACROS - List of macro commands available in the current directory. - - This read-only property specifies the list of CMake macros currently - defined. It is intended for debugging purposes. See the macro - command. - - PARENT_DIRECTORY - Source directory that added current subdirectory. - - This read-only property specifies the source directory that added the - current source directory as a subdirectory of the build. In the - top-level directory the value is the empty-string. - - RULE_LAUNCH_COMPILE - Specify a launcher for compile rules. - - See the global property of the same name for details. This overrides - the global property for a directory. - - RULE_LAUNCH_CUSTOM - Specify a launcher for custom rules. - - See the global property of the same name for details. This overrides - the global property for a directory. - - RULE_LAUNCH_LINK - Specify a launcher for link rules. - - See the global property of the same name for details. This overrides - the global property for a directory. - - TEST_INCLUDE_FILE - A cmake file that will be included when ctest is run. - - If you specify TEST_INCLUDE_FILE, that file will be included and - processed when ctest is run on the directory. - - VARIABLES - List of variables defined in the current directory. - - This read-only property specifies the list of CMake variables - currently defined. It is intended for debugging purposes. - ------------------------------------------------------------------------------- -Properties on Targets - - _OUTPUT_NAME - Old per-configuration target file base name. - - This is a configuration-specific version of OUTPUT_NAME. Use - OUTPUT_NAME_ instead. - - _POSTFIX - Postfix to append to the target file name for configuration . - - When building with configuration the value of this property - is appended to the target file name built on disk. For non-executable - targets, this property is initialized by the value of the variable - CMAKE__POSTFIX if it is set when a target is created. This - property is ignored on the Mac for Frameworks and App Bundles. - - ARCHIVE_OUTPUT_DIRECTORY - Output directory in which to build ARCHIVE target files. - - This property specifies the directory into which archive target files - should be built. Multi-configuration generators (VS, Xcode) append a - per-configuration subdirectory to the specified directory. There are - three kinds of target files that may be built: archive, library, and - runtime. Executables are always treated as runtime targets. Static - libraries are always treated as archive targets. Module libraries are - always treated as library targets. For non-DLL platforms shared - libraries are treated as library targets. For DLL platforms the DLL - part of a shared library is treated as a runtime target and the - corresponding import library is treated as an archive target. All - Windows-based systems including Cygwin are DLL platforms. This - property is initialized by the value of the variable - CMAKE_ARCHIVE_OUTPUT_DIRECTORY if it is set when a target is created. - - ARCHIVE_OUTPUT_DIRECTORY_ - Per-configuration output directory for ARCHIVE target files. - - This is a per-configuration version of ARCHIVE_OUTPUT_DIRECTORY, but - multi-configuration generators (VS, Xcode) do NOT append a - per-configuration subdirectory to the specified directory. This - property is initialized by the value of the variable - CMAKE_ARCHIVE_OUTPUT_DIRECTORY_ if it is set when a target is - created. - - ARCHIVE_OUTPUT_NAME - Output name for ARCHIVE target files. - - This property specifies the base name for archive target files. It - overrides OUTPUT_NAME and OUTPUT_NAME_ properties. There are - three kinds of target files that may be built: archive, library, and - runtime. Executables are always treated as runtime targets. Static - libraries are always treated as archive targets. Module libraries are - always treated as library targets. For non-DLL platforms shared - libraries are treated as library targets. For DLL platforms the DLL - part of a shared library is treated as a runtime target and the - corresponding import library is treated as an archive target. All - Windows-based systems including Cygwin are DLL platforms. - - ARCHIVE_OUTPUT_NAME_ - Per-configuration output name for ARCHIVE target files. - - This is the configuration-specific version of ARCHIVE_OUTPUT_NAME. - - AUTOMOC - Should the target be processed with automoc (for Qt projects). - - AUTOMOC is a boolean specifying whether CMake will handle the Qt moc - preprocessor automatically, i.e. without having to use the - QT4_WRAP_CPP() macro. Currently Qt4 is supported. When this property - is set to TRUE, CMake will scan the source files at build time and - invoke moc accordingly. If an #include statement like #include - "moc_foo.cpp" is found, the Q_OBJECT class declaration is expected in - the header, and moc is run on the header file. If an #include - statement like #include "foo.moc" is found, then a Q_OBJECT is - expected in the current source file and moc is run on the file itself. - Additionally, all header files are parsed for Q_OBJECT macros, and if - found, moc is also executed on those files. The resulting moc files, - which are not included as shown above in any of the source files are - included in a generated _automoc.cpp file, which is - compiled as part of the target.This property is initialized by the - value of the variable CMAKE_AUTOMOC if it is set when a target is - created. - - Additional command line options for moc can be set via the - AUTOMOC_MOC_OPTIONS property. - - By setting the CMAKE_AUTOMOC_RELAXED_MODE variable to TRUE the rules - for searching the files which will be processed by moc can be relaxed. - See the documentation for this variable for more details. - - AUTOMOC_MOC_OPTIONS - Additional options for moc when using automoc (see the AUTOMOC - property) - - This property is only used if the AUTOMOC property is set to TRUE for - this target. In this case, it holds additional command line options - which will be used when moc is executed during the build, i.e. it is - equivalent to the optional OPTIONS argument of the qt4_wrap_cpp() - macro. - - By default it is empty. - - BUILD_WITH_INSTALL_RPATH - Should build tree targets have install tree rpaths. - - BUILD_WITH_INSTALL_RPATH is a boolean specifying whether to link the - target in the build tree with the INSTALL_RPATH. This takes - precedence over SKIP_BUILD_RPATH and avoids the need for relinking - before installation. This property is initialized by the value of the - variable CMAKE_BUILD_WITH_INSTALL_RPATH if it is set when a target is - created. - - BUNDLE - This target is a CFBundle on the Mac. - - If a module library target has this property set to true it will be - built as a CFBundle when built on the mac. It will have the directory - structure required for a CFBundle and will be suitable to be used for - creating Browser Plugins or other application resources. - - BUNDLE_EXTENSION - The file extension used to name a BUNDLE target on the Mac. - - The default value is "bundle" - you can also use "plugin" or whatever - file extension is required by the host app for your bundle. - - COMPILE_DEFINITIONS - Preprocessor definitions for compiling a target's sources. - - The COMPILE_DEFINITIONS property may be set to a semicolon-separated - list of preprocessor definitions using the syntax VAR or VAR=value. - Function-style definitions are not supported. CMake will - automatically escape the value correctly for the native build system - (note that CMake language syntax may require escapes to specify some - values). This property may be set on a per-configuration basis using - the name COMPILE_DEFINITIONS_ where is an upper-case - name (ex. "COMPILE_DEFINITIONS_DEBUG"). - - CMake will automatically drop some definitions that are not supported - by the native build tool. The VS6 IDE does not support definition - values with spaces (but NMake does). - - Disclaimer: Most native build tools have poor support for escaping - certain values. CMake has work-arounds for many cases but some values - may just not be possible to pass correctly. If a value does not seem - to be escaped correctly, do not attempt to work-around the problem by - adding escape sequences to the value. Your work-around may break in a - future version of CMake that has improved escape support. Instead - consider defining the macro in a (configured) header file. Then - report the limitation. Known limitations include: - - # - broken almost everywhere - ; - broken in VS IDE and Borland Makefiles - , - broken in VS IDE - % - broken in some cases in NMake - & | - broken in some cases on MinGW - ^ < > \" - broken in most Make tools on Windows - - CMake does not reject these values outright because they do work in - some cases. Use with caution. - - COMPILE_DEFINITIONS_ - Per-configuration preprocessor definitions on a target. - - This is the configuration-specific version of COMPILE_DEFINITIONS. - - COMPILE_FLAGS - Additional flags to use when compiling this target's sources. - - The COMPILE_FLAGS property sets additional compiler flags used to - build sources within the target. Use COMPILE_DEFINITIONS to pass - additional preprocessor definitions. - - DEBUG_POSTFIX - See target property _POSTFIX. - - This property is a special case of the more-general _POSTFIX - property for the DEBUG configuration. - - DEFINE_SYMBOL - Define a symbol when compiling this target's sources. - - DEFINE_SYMBOL sets the name of the preprocessor symbol defined when - compiling sources in a shared library. If not set here then it is set - to target_EXPORTS by default (with some substitutions if the target is - not a valid C identifier). This is useful for headers to know whether - they are being included from inside their library our outside to - properly setup dllexport/dllimport decorations. - - ENABLE_EXPORTS - Specify whether an executable exports symbols for loadable modules. - - Normally an executable does not export any symbols because it is the - final program. It is possible for an executable to export symbols to - be used by loadable modules. When this property is set to true CMake - will allow other targets to "link" to the executable with the - TARGET_LINK_LIBRARIES command. On all platforms a target-level - dependency on the executable is created for targets that link to it. - For DLL platforms an import library will be created for the exported - symbols and then used for linking. All Windows-based systems - including Cygwin are DLL platforms. For non-DLL platforms that - require all symbols to be resolved at link time, such as Mac OS X, the - module will "link" to the executable using a flag like - "-bundle_loader". For other non-DLL platforms the link rule is simply - ignored since the dynamic loader will automatically bind symbols when - the module is loaded. - - EXCLUDE_FROM_ALL - Exclude the target from the all target. - - A property on a target that indicates if the target is excluded from - the default build target. If it is not, then with a Makefile for - example typing make will cause this target to be built. The same - concept applies to the default build of other generators. Installing - a target with EXCLUDE_FROM_ALL set to true has undefined behavior. - - EchoString - A message to be displayed when the target is built. - - A message to display on some generators (such as makefiles) when the - target is built. - - FOLDER - Set the folder name. Use to organize targets in an IDE. - - Targets with no FOLDER property will appear as top level entities in - IDEs like Visual Studio. Targets with the same FOLDER property value - will appear next to each other in a folder of that name. To nest - folders, use FOLDER values such as 'GUI/Dialogs' with '/' characters - separating folder levels. - - FRAMEWORK - This target is a framework on the Mac. - - If a shared library target has this property set to true it will be - built as a framework when built on the mac. It will have the - directory structure required for a framework and will be suitable to - be used with the -framework option - - Fortran_FORMAT - Set to FIXED or FREE to indicate the Fortran source layout. - - This property tells CMake whether the Fortran source files in a target - use fixed-format or free-format. CMake will pass the corresponding - format flag to the compiler. Use the source-specific Fortran_FORMAT - property to change the format of a specific source file. If the - variable CMAKE_Fortran_FORMAT is set when a target is created its - value is used to initialize this property. - - Fortran_MODULE_DIRECTORY - Specify output directory for Fortran modules provided by the target. - - If the target contains Fortran source files that provide modules and - the compiler supports a module output directory this specifies the - directory in which the modules will be placed. When this property is - not set the modules will be placed in the build directory - corresponding to the target's source directory. If the variable - CMAKE_Fortran_MODULE_DIRECTORY is set when a target is created its - value is used to initialize this property. - - Note that some compilers will automatically search the module output - directory for modules USEd during compilation but others will not. If - your sources USE modules their location must be specified by - INCLUDE_DIRECTORIES regardless of this property. - - GENERATOR_FILE_NAME - Generator's file for this target. - - An internal property used by some generators to record the name of - project or dsp file associated with this target. - - GNUtoMS - Convert GNU import library (.dll.a) to MS format (.lib). - - When linking a shared library or executable that exports symbols using - GNU tools on Windows (MinGW/MSYS) with Visual Studio installed convert - the import library (.dll.a) from GNU to MS format (.lib). Both import - libraries will be installed by install(TARGETS) and exported by - install(EXPORT) and export() to be linked by applications with either - GNU- or MS-compatible tools. - - If the variable CMAKE_GNUtoMS is set when a target is created its - value is used to initialize this property. The variable must be set - prior to the first command that enables a language such as project() - or enable_language(). CMake provides the variable as an option to the - user automatically when configuring on Windows with GNU tools. - - HAS_CXX - Link the target using the C++ linker tool (obsolete). - - This is equivalent to setting the LINKER_LANGUAGE property to CXX. - See that property's documentation for details. - - IMPLICIT_DEPENDS_INCLUDE_TRANSFORM - Specify #include line transforms for dependencies in a target. - - This property specifies rules to transform macro-like #include lines - during implicit dependency scanning of C and C++ source files. The - list of rules must be semicolon-separated with each entry of the form - "A_MACRO(%)=value-with-%" (the % must be literal). During dependency - scanning occurrences of A_MACRO(...) on #include lines will be - replaced by the value given with the macro argument substituted for - '%'. For example, the entry - - MYDIR(%)= - - will convert lines of the form - - #include MYDIR(myheader.h) - - to - - #include - - allowing the dependency to be followed. - - This property applies to sources in the target on which it is set. - - IMPORTED - Read-only indication of whether a target is IMPORTED. - - The boolean value of this property is true for targets created with - the IMPORTED option to add_executable or add_library. It is false for - targets built within the project. - - IMPORTED_CONFIGURATIONS - Configurations provided for an IMPORTED target. - - Set this to the list of configuration names available for an IMPORTED - target. The names correspond to configurations defined in the project - from which the target is imported. If the importing project uses a - different set of configurations the names may be mapped using the - MAP_IMPORTED_CONFIG_ property. Ignored for non-imported - targets. - - IMPORTED_IMPLIB - Full path to the import library for an IMPORTED target. - - Set this to the location of the ".lib" part of a windows DLL. Ignored - for non-imported targets. - - IMPORTED_IMPLIB_ - -specific version of IMPORTED_IMPLIB property. - - Configuration names correspond to those provided by the project from - which the target is imported. - - IMPORTED_LINK_DEPENDENT_LIBRARIES - Dependent shared libraries of an imported shared library. - - Shared libraries may be linked to other shared libraries as part of - their implementation. On some platforms the linker searches for the - dependent libraries of shared libraries they are including in the - link. Set this property to the list of dependent shared libraries of - an imported library. The list should be disjoint from the list of - interface libraries in the IMPORTED_LINK_INTERFACE_LIBRARIES property. - On platforms requiring dependent shared libraries to be found at link - time CMake uses this list to add appropriate files or paths to the - link command line. Ignored for non-imported targets. - - IMPORTED_LINK_DEPENDENT_LIBRARIES_ - -specific version of IMPORTED_LINK_DEPENDENT_LIBRARIES. - - Configuration names correspond to those provided by the project from - which the target is imported. If set, this property completely - overrides the generic property for the named configuration. - - IMPORTED_LINK_INTERFACE_LANGUAGES - Languages compiled into an IMPORTED static library. - - Set this to the list of languages of source files compiled to produce - a STATIC IMPORTED library (such as "C" or "CXX"). CMake accounts for - these languages when computing how to link a target to the imported - library. For example, when a C executable links to an imported C++ - static library CMake chooses the C++ linker to satisfy language - runtime dependencies of the static library. - - This property is ignored for targets that are not STATIC libraries. - This property is ignored for non-imported targets. - - IMPORTED_LINK_INTERFACE_LANGUAGES_ - -specific version of IMPORTED_LINK_INTERFACE_LANGUAGES. - - Configuration names correspond to those provided by the project from - which the target is imported. If set, this property completely - overrides the generic property for the named configuration. - - IMPORTED_LINK_INTERFACE_LIBRARIES - Transitive link interface of an IMPORTED target. - - Set this to the list of libraries whose interface is included when an - IMPORTED library target is linked to another target. The libraries - will be included on the link line for the target. Unlike the - LINK_INTERFACE_LIBRARIES property, this property applies to all - imported target types, including STATIC libraries. This property is - ignored for non-imported targets. - - IMPORTED_LINK_INTERFACE_LIBRARIES_ - -specific version of IMPORTED_LINK_INTERFACE_LIBRARIES. - - Configuration names correspond to those provided by the project from - which the target is imported. If set, this property completely - overrides the generic property for the named configuration. - - IMPORTED_LINK_INTERFACE_MULTIPLICITY - Repetition count for cycles of IMPORTED static libraries. - - This is LINK_INTERFACE_MULTIPLICITY for IMPORTED targets. - - IMPORTED_LINK_INTERFACE_MULTIPLICITY_ - -specific version of IMPORTED_LINK_INTERFACE_MULTIPLICITY. - - If set, this property completely overrides the generic property for - the named configuration. - - IMPORTED_LOCATION - Full path to the main file on disk for an IMPORTED target. - - Set this to the location of an IMPORTED target file on disk. For - executables this is the location of the executable file. For bundles - on OS X this is the location of the executable file inside - Contents/MacOS under the application bundle folder. For static - libraries and modules this is the location of the library or module. - For shared libraries on non-DLL platforms this is the location of the - shared library. For frameworks on OS X this is the location of the - library file symlink just inside the framework folder. For DLLs this - is the location of the ".dll" part of the library. For UNKNOWN - libraries this is the location of the file to be linked. Ignored for - non-imported targets. - - Projects may skip IMPORTED_LOCATION if the configuration-specific - property IMPORTED_LOCATION_ is set. To get the location of an - imported target read one of the LOCATION or LOCATION_ - properties. - - IMPORTED_LOCATION_ - -specific version of IMPORTED_LOCATION property. - - Configuration names correspond to those provided by the project from - which the target is imported. - - IMPORTED_NO_SONAME - Specifies that an IMPORTED shared library target has no "soname". - - Set this property to true for an imported shared library file that has - no "soname" field. CMake may adjust generated link commands for some - platforms to prevent the linker from using the path to the library in - place of its missing soname. Ignored for non-imported targets. - - IMPORTED_NO_SONAME_ - -specific version of IMPORTED_NO_SONAME property. - - Configuration names correspond to those provided by the project from - which the target is imported. - - IMPORTED_SONAME - The "soname" of an IMPORTED target of shared library type. - - Set this to the "soname" embedded in an imported shared library. This - is meaningful only on platforms supporting the feature. Ignored for - non-imported targets. - - IMPORTED_SONAME_ - -specific version of IMPORTED_SONAME property. - - Configuration names correspond to those provided by the project from - which the target is imported. - - IMPORT_PREFIX - What comes before the import library name. - - Similar to the target property PREFIX, but used for import libraries - (typically corresponding to a DLL) instead of regular libraries. A - target property that can be set to override the prefix (such as "lib") - on an import library name. - - IMPORT_SUFFIX - What comes after the import library name. - - Similar to the target property SUFFIX, but used for import libraries - (typically corresponding to a DLL) instead of regular libraries. A - target property that can be set to override the suffix (such as - ".lib") on an import library name. - - INCLUDE_DIRECTORIES - List of preprocessor include file search directories. - - This property specifies the list of directories given so far to the - include_directories command. This property exists on directories and - targets. In addition to accepting values from the include_directories - command, values may be set directly on any directory or any target - using the set_property command. A target gets its initial value for - this property from the value of the directory property. A directory - gets its initial value from its parent directory if it has one. Both - directory and target property values are adjusted by calls to the - include_directories command. - - The target property values are used by the generators to set the - include paths for the compiler. See also the include_directories - command. - - INSTALL_NAME_DIR - Mac OSX directory name for installed targets. - - INSTALL_NAME_DIR is a string specifying the directory portion of the - "install_name" field of shared libraries on Mac OSX to use in the - installed targets. - - INSTALL_RPATH - The rpath to use for installed targets. - - A semicolon-separated list specifying the rpath to use in installed - targets (for platforms that support it). This property is initialized - by the value of the variable CMAKE_INSTALL_RPATH if it is set when a - target is created. - - INSTALL_RPATH_USE_LINK_PATH - Add paths to linker search and installed rpath. - - INSTALL_RPATH_USE_LINK_PATH is a boolean that if set to true will - append directories in the linker search path and outside the project - to the INSTALL_RPATH. This property is initialized by the value of - the variable CMAKE_INSTALL_RPATH_USE_LINK_PATH if it is set when a - target is created. - - INTERPROCEDURAL_OPTIMIZATION - Enable interprocedural optimization for a target. - - If set to true, enables interprocedural optimizations if they are - known to be supported by the compiler. - - INTERPROCEDURAL_OPTIMIZATION_ - Per-configuration interprocedural optimization for a target. - - This is a per-configuration version of INTERPROCEDURAL_OPTIMIZATION. - If set, this property overrides the generic property for the named - configuration. - - LABELS - Specify a list of text labels associated with a target. - - Target label semantics are currently unspecified. - - LIBRARY_OUTPUT_DIRECTORY - Output directory in which to build LIBRARY target files. - - This property specifies the directory into which library target files - should be built. Multi-configuration generators (VS, Xcode) append a - per-configuration subdirectory to the specified directory. There are - three kinds of target files that may be built: archive, library, and - runtime. Executables are always treated as runtime targets. Static - libraries are always treated as archive targets. Module libraries are - always treated as library targets. For non-DLL platforms shared - libraries are treated as library targets. For DLL platforms the DLL - part of a shared library is treated as a runtime target and the - corresponding import library is treated as an archive target. All - Windows-based systems including Cygwin are DLL platforms. This - property is initialized by the value of the variable - CMAKE_LIBRARY_OUTPUT_DIRECTORY if it is set when a target is created. - - LIBRARY_OUTPUT_DIRECTORY_ - Per-configuration output directory for LIBRARY target files. - - This is a per-configuration version of LIBRARY_OUTPUT_DIRECTORY, but - multi-configuration generators (VS, Xcode) do NOT append a - per-configuration subdirectory to the specified directory. This - property is initialized by the value of the variable - CMAKE_LIBRARY_OUTPUT_DIRECTORY_ if it is set when a target is - created. - - LIBRARY_OUTPUT_NAME - Output name for LIBRARY target files. - - This property specifies the base name for library target files. It - overrides OUTPUT_NAME and OUTPUT_NAME_ properties. There are - three kinds of target files that may be built: archive, library, and - runtime. Executables are always treated as runtime targets. Static - libraries are always treated as archive targets. Module libraries are - always treated as library targets. For non-DLL platforms shared - libraries are treated as library targets. For DLL platforms the DLL - part of a shared library is treated as a runtime target and the - corresponding import library is treated as an archive target. All - Windows-based systems including Cygwin are DLL platforms. - - LIBRARY_OUTPUT_NAME_ - Per-configuration output name for LIBRARY target files. - - This is the configuration-specific version of LIBRARY_OUTPUT_NAME. - - LINKER_LANGUAGE - Specifies language whose compiler will invoke the linker. - - For executables, shared libraries, and modules, this sets the language - whose compiler is used to link the target (such as "C" or "CXX"). A - typical value for an executable is the language of the source file - providing the program entry point (main). If not set, the language - with the highest linker preference value is the default. See - documentation of CMAKE__LINKER_PREFERENCE variables. - - LINK_DEPENDS - Additional files on which a target binary depends for linking. - - Specifies a semicolon-separated list of full-paths to files on which - the link rule for this target depends. The target binary will be - linked if any of the named files is newer than it. - - This property is ignored by non-Makefile generators. It is intended - to specify dependencies on "linker scripts" for custom Makefile link - rules. - - LINK_FLAGS - Additional flags to use when linking this target. - - The LINK_FLAGS property can be used to add extra flags to the link - step of a target. LINK_FLAGS_ will add to the configuration - , for example, DEBUG, RELEASE, MINSIZEREL, RELWITHDEBINFO. - - LINK_FLAGS_ - Per-configuration linker flags for a target. - - This is the configuration-specific version of LINK_FLAGS. - - LINK_INTERFACE_LIBRARIES - List public interface libraries for a shared library or executable. - - By default linking to a shared library target transitively links to - targets with which the library itself was linked. For an executable - with exports (see the ENABLE_EXPORTS property) no default transitive - link dependencies are used. This property replaces the default - transitive link dependencies with an explicit list. When the target - is linked into another target the libraries listed (and recursively - their link interface libraries) will be provided to the other target - also. If the list is empty then no transitive link dependencies will - be incorporated when this target is linked into another target even if - the default set is non-empty. This property is initialized by the - value of the variable CMAKE_LINK_INTERFACE_LIBRARIES if it is set when - a target is created. This property is ignored for STATIC libraries. - - LINK_INTERFACE_LIBRARIES_ - Per-configuration list of public interface libraries for a target. - - This is the configuration-specific version of - LINK_INTERFACE_LIBRARIES. If set, this property completely overrides - the generic property for the named configuration. - - LINK_INTERFACE_MULTIPLICITY - Repetition count for STATIC libraries with cyclic dependencies. - - When linking to a STATIC library target with cyclic dependencies the - linker may need to scan more than once through the archives in the - strongly connected component of the dependency graph. CMake by - default constructs the link line so that the linker will scan through - the component at least twice. This property specifies the minimum - number of scans if it is larger than the default. CMake uses the - largest value specified by any target in a component. - - LINK_INTERFACE_MULTIPLICITY_ - Per-configuration repetition count for cycles of STATIC libraries. - - This is the configuration-specific version of - LINK_INTERFACE_MULTIPLICITY. If set, this property completely - overrides the generic property for the named configuration. - - LINK_SEARCH_END_STATIC - End a link line such that static system libraries are used. - - Some linkers support switches such as -Bstatic and -Bdynamic to - determine whether to use static or shared libraries for -lXXX options. - CMake uses these options to set the link type for libraries whose full - paths are not known or (in some cases) are in implicit link - directories for the platform. By default CMake adds an option at the - end of the library list (if necessary) to set the linker search type - back to its starting type. This property switches the final linker - search type to -Bstatic regardless of how it started. See also - LINK_SEARCH_START_STATIC. - - LINK_SEARCH_START_STATIC - Assume the linker looks for static libraries by default. - - Some linkers support switches such as -Bstatic and -Bdynamic to - determine whether to use static or shared libraries for -lXXX options. - CMake uses these options to set the link type for libraries whose full - paths are not known or (in some cases) are in implicit link - directories for the platform. By default the linker search type is - assumed to be -Bdynamic at the beginning of the library list. This - property switches the assumption to -Bstatic. It is intended for use - when linking an executable statically (e.g. with the GNU -static - option). See also LINK_SEARCH_END_STATIC. - - LOCATION - Read-only location of a target on disk. - - For an imported target, this read-only property returns the value of - the LOCATION_ property for an unspecified configuration - provided by the target. - - For a non-imported target, this property is provided for compatibility - with CMake 2.4 and below. It was meant to get the location of an - executable target's output file for use in add_custom_command. The - path may contain a build-system-specific portion that is replaced at - build time with the configuration getting built (such as - "$(ConfigurationName)" in VS). In CMake 2.6 and above - add_custom_command automatically recognizes a target name in its - COMMAND and DEPENDS options and computes the target location. In - CMake 2.8.4 and above add_custom_command recognizes generator - expressions to refer to target locations anywhere in the command. - Therefore this property is not needed for creating custom commands. - - Do not set properties that affect the location of a target after - reading this property. These include properties whose names match - "(RUNTIME|LIBRARY|ARCHIVE)_OUTPUT_(NAME|DIRECTORY)(_)?" or - "(IMPLIB_)?(PREFIX|SUFFIX)". Failure to follow this rule is not - diagnosed and leaves the location of the target undefined. - - LOCATION_ - Read-only property providing a target location on disk. - - A read-only property that indicates where a target's main file is - located on disk for the configuration . The property is - defined only for library and executable targets. An imported target - may provide a set of configurations different from that of the - importing project. By default CMake looks for an exact-match but - otherwise uses an arbitrary available configuration. Use the - MAP_IMPORTED_CONFIG_ property to map imported configurations - explicitly. - - Do not set properties that affect the location of a target after - reading this property. These include properties whose names match - "(RUNTIME|LIBRARY|ARCHIVE)_OUTPUT_(NAME|DIRECTORY)(_)?" or - "(IMPLIB_)?(PREFIX|SUFFIX)". Failure to follow this rule is not - diagnosed and leaves the location of the target undefined. - - MACOSX_BUNDLE - Build an executable as an application bundle on Mac OS X. - - When this property is set to true the executable when built on Mac OS - X will be created as an application bundle. This makes it a GUI - executable that can be launched from the Finder. See the - MACOSX_BUNDLE_INFO_PLIST target property for information about - creation of the Info.plist file for the application bundle. This - property is initialized by the value of the variable - CMAKE_MACOSX_BUNDLE if it is set when a target is created. - - MACOSX_BUNDLE_INFO_PLIST - Specify a custom Info.plist template for a Mac OS X App Bundle. - - An executable target with MACOSX_BUNDLE enabled will be built as an - application bundle on Mac OS X. By default its Info.plist file is - created by configuring a template called MacOSXBundleInfo.plist.in - located in the CMAKE_MODULE_PATH. This property specifies an - alternative template file name which may be a full path. - - The following target properties may be set to specify content to be - configured into the file: - - MACOSX_BUNDLE_INFO_STRING - MACOSX_BUNDLE_ICON_FILE - MACOSX_BUNDLE_GUI_IDENTIFIER - MACOSX_BUNDLE_LONG_VERSION_STRING - MACOSX_BUNDLE_BUNDLE_NAME - MACOSX_BUNDLE_SHORT_VERSION_STRING - MACOSX_BUNDLE_BUNDLE_VERSION - MACOSX_BUNDLE_COPYRIGHT - - CMake variables of the same name may be set to affect all targets in a - directory that do not have each specific property set. If a custom - Info.plist is specified by this property it may of course hard-code - all the settings instead of using the target properties. - - MACOSX_FRAMEWORK_INFO_PLIST - Specify a custom Info.plist template for a Mac OS X Framework. - - An library target with FRAMEWORK enabled will be built as a framework - on Mac OS X. By default its Info.plist file is created by configuring - a template called MacOSXFrameworkInfo.plist.in located in the - CMAKE_MODULE_PATH. This property specifies an alternative template - file name which may be a full path. - - The following target properties may be set to specify content to be - configured into the file: - - MACOSX_FRAMEWORK_ICON_FILE - MACOSX_FRAMEWORK_IDENTIFIER - MACOSX_FRAMEWORK_SHORT_VERSION_STRING - MACOSX_FRAMEWORK_BUNDLE_VERSION - - CMake variables of the same name may be set to affect all targets in a - directory that do not have each specific property set. If a custom - Info.plist is specified by this property it may of course hard-code - all the settings instead of using the target properties. - - MAP_IMPORTED_CONFIG_ - Map from project configuration to IMPORTED target's configuration. - - Set this to the list of configurations of an imported target that may - be used for the current project's configuration. Targets - imported from another project may not provide the same set of - configuration names available in the current project. Setting this - property tells CMake what imported configurations are suitable for use - when building the configuration. The first configuration in - the list found to be provided by the imported target is selected. If - this property is set and no matching configurations are available, - then the imported target is considered to be not found. This property - is ignored for non-imported targets. - - NO_SONAME - Whether to set "soname" when linking a shared library or module. - - Enable this boolean property if a generated shared library or module - should not have "soname" set. Default is to set "soname" on all - shared libraries and modules as long as the platform supports it. - Generally, use this property only for leaf private libraries or - plugins. If you use it on normal shared libraries which other targets - link against, on some platforms a linker will insert a full path to - the library (as specified at link time) into the dynamic section of - the dependent binary. Therefore, once installed, dynamic loader may - eventually fail to locate the library for the binary. - - OSX_ARCHITECTURES - Target specific architectures for OS X. - - The OSX_ARCHITECTURES property sets the target binary architecture for - targets on OS X. This property is initialized by the value of the - variable CMAKE_OSX_ARCHITECTURES if it is set when a target is - created. Use OSX_ARCHITECTURES_ to set the binary - architectures on a per-configuration basis. is an upper-case - name (ex: "OSX_ARCHITECTURES_DEBUG"). - - OSX_ARCHITECTURES_ - Per-configuration OS X binary architectures for a target. - - This property is the configuration-specific version of - OSX_ARCHITECTURES. - - OUTPUT_NAME - Output name for target files. - - This sets the base name for output files created for an executable or - library target. If not set, the logical target name is used by - default. - - OUTPUT_NAME_ - Per-configuration target file base name. - - This is the configuration-specific version of OUTPUT_NAME. - - POSITION_INDEPENDENT_CODE - Whether to create a position-independent target - - The POSITION_INDEPENDENT_CODE property determines whether position - independent executables or shared libraries will be created. This - property is true by default for SHARED and MODULE library targets and - false otherwise. - - POST_INSTALL_SCRIPT - Deprecated install support. - - The PRE_INSTALL_SCRIPT and POST_INSTALL_SCRIPT properties are the old - way to specify CMake scripts to run before and after installing a - target. They are used only when the old INSTALL_TARGETS command is - used to install the target. Use the INSTALL command instead. - - PREFIX - What comes before the library name. - - A target property that can be set to override the prefix (such as - "lib") on a library name. - - PRE_INSTALL_SCRIPT - Deprecated install support. - - The PRE_INSTALL_SCRIPT and POST_INSTALL_SCRIPT properties are the old - way to specify CMake scripts to run before and after installing a - target. They are used only when the old INSTALL_TARGETS command is - used to install the target. Use the INSTALL command instead. - - PRIVATE_HEADER - Specify private header files in a FRAMEWORK shared library target. - - Shared library targets marked with the FRAMEWORK property generate - frameworks on OS X and normal shared libraries on other platforms. - This property may be set to a list of header files to be placed in the - PrivateHeaders directory inside the framework folder. On non-Apple - platforms these headers may be installed using the PRIVATE_HEADER - option to the install(TARGETS) command. - - PROJECT_LABEL - Change the name of a target in an IDE. - - Can be used to change the name of the target in an IDE like Visual - Studio. - - PUBLIC_HEADER - Specify public header files in a FRAMEWORK shared library target. - - Shared library targets marked with the FRAMEWORK property generate - frameworks on OS X and normal shared libraries on other platforms. - This property may be set to a list of header files to be placed in the - Headers directory inside the framework folder. On non-Apple platforms - these headers may be installed using the PUBLIC_HEADER option to the - install(TARGETS) command. - - RESOURCE - Specify resource files in a FRAMEWORK shared library target. - - Shared library targets marked with the FRAMEWORK property generate - frameworks on OS X and normal shared libraries on other platforms. - This property may be set to a list of files to be placed in the - Resources directory inside the framework folder. On non-Apple - platforms these files may be installed using the RESOURCE option to - the install(TARGETS) command. - - RULE_LAUNCH_COMPILE - Specify a launcher for compile rules. - - See the global property of the same name for details. This overrides - the global and directory property for a target. - - RULE_LAUNCH_CUSTOM - Specify a launcher for custom rules. - - See the global property of the same name for details. This overrides - the global and directory property for a target. - - RULE_LAUNCH_LINK - Specify a launcher for link rules. - - See the global property of the same name for details. This overrides - the global and directory property for a target. - - RUNTIME_OUTPUT_DIRECTORY - Output directory in which to build RUNTIME target files. - - This property specifies the directory into which runtime target files - should be built. Multi-configuration generators (VS, Xcode) append a - per-configuration subdirectory to the specified directory. There are - three kinds of target files that may be built: archive, library, and - runtime. Executables are always treated as runtime targets. Static - libraries are always treated as archive targets. Module libraries are - always treated as library targets. For non-DLL platforms shared - libraries are treated as library targets. For DLL platforms the DLL - part of a shared library is treated as a runtime target and the - corresponding import library is treated as an archive target. All - Windows-based systems including Cygwin are DLL platforms. This - property is initialized by the value of the variable - CMAKE_RUNTIME_OUTPUT_DIRECTORY if it is set when a target is created. - - RUNTIME_OUTPUT_DIRECTORY_ - Per-configuration output directory for RUNTIME target files. - - This is a per-configuration version of RUNTIME_OUTPUT_DIRECTORY, but - multi-configuration generators (VS, Xcode) do NOT append a - per-configuration subdirectory to the specified directory. This - property is initialized by the value of the variable - CMAKE_RUNTIME_OUTPUT_DIRECTORY_ if it is set when a target is - created. - - RUNTIME_OUTPUT_NAME - Output name for RUNTIME target files. - - This property specifies the base name for runtime target files. It - overrides OUTPUT_NAME and OUTPUT_NAME_ properties. There are - three kinds of target files that may be built: archive, library, and - runtime. Executables are always treated as runtime targets. Static - libraries are always treated as archive targets. Module libraries are - always treated as library targets. For non-DLL platforms shared - libraries are treated as library targets. For DLL platforms the DLL - part of a shared library is treated as a runtime target and the - corresponding import library is treated as an archive target. All - Windows-based systems including Cygwin are DLL platforms. - - RUNTIME_OUTPUT_NAME_ - Per-configuration output name for RUNTIME target files. - - This is the configuration-specific version of RUNTIME_OUTPUT_NAME. - - SKIP_BUILD_RPATH - Should rpaths be used for the build tree. - - SKIP_BUILD_RPATH is a boolean specifying whether to skip automatic - generation of an rpath allowing the target to run from the build tree. - This property is initialized by the value of the variable - CMAKE_SKIP_BUILD_RPATH if it is set when a target is created. - - SOURCES - Source names specified for a target. - - Read-only list of sources specified for a target. The names returned - are suitable for passing to the set_source_files_properties command. - - SOVERSION - What version number is this target. - - For shared libraries VERSION and SOVERSION can be used to specify the - build version and api version respectively. When building or - installing appropriate symlinks are created if the platform supports - symlinks and the linker supports so-names. If only one of both is - specified the missing is assumed to have the same version number. - SOVERSION is ignored if NO_SONAME property is set. For shared - libraries and executables on Windows the VERSION attribute is parsed - to extract a "major.minor" version number. These numbers are used as - the image version of the binary. - - STATIC_LIBRARY_FLAGS - Extra flags to use when linking static libraries. - - Extra flags to use when linking a static library. - - STATIC_LIBRARY_FLAGS_ - Per-configuration flags for creating a static library. - - This is the configuration-specific version of STATIC_LIBRARY_FLAGS. - - SUFFIX - What comes after the target name. - - A target property that can be set to override the suffix (such as - ".so" or ".exe") on the name of a library, module or executable. - - TYPE - The type of the target. - - This read-only property can be used to test the type of the given - target. It will be one of STATIC_LIBRARY, MODULE_LIBRARY, - SHARED_LIBRARY, EXECUTABLE or one of the internal target types. - - VERSION - What version number is this target. - - For shared libraries VERSION and SOVERSION can be used to specify the - build version and api version respectively. When building or - installing appropriate symlinks are created if the platform supports - symlinks and the linker supports so-names. If only one of both is - specified the missing is assumed to have the same version number. For - executables VERSION can be used to specify the build version. When - building or installing appropriate symlinks are created if the - platform supports symlinks. For shared libraries and executables on - Windows the VERSION attribute is parsed to extract a "major.minor" - version number. These numbers are used as the image version of the - binary. - - VS_DOTNET_REFERENCES - Visual Studio managed project .NET references - - Adds one or more semicolon-delimited .NET references to a generated - Visual Studio project. For example, "System;System.Windows.Forms". - - VS_GLOBAL_ - Visual Studio project-specific global variable. - - Tell the Visual Studio generator to set the global variable - '' to a given value in the generated Visual Studio project. - Ignored on other generators. Qt integration works better if - VS_GLOBAL_QtVersion is set to the version FindQt4.cmake found. For - example, "4.7.3" - - VS_GLOBAL_KEYWORD - Visual Studio project keyword. - - Sets the "keyword" attribute for a generated Visual Studio project. - Defaults to "Win32Proj". You may wish to override this value with - "ManagedCProj", for example, in a Visual Studio managed C++ unit test - project. - - VS_GLOBAL_PROJECT_TYPES - Visual Studio project type(s). - - Can be set to one or more UUIDs recognized by Visual Studio to - indicate the type of project. This value is copied verbatim into the - generated project file. Example for a managed C++ unit testing - project: - - {3AC096D0-A1C2-E12C-1390-A8335801FDAB};{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942} - - UUIDs are semicolon-delimited. - - VS_KEYWORD - Visual Studio project keyword. - - Can be set to change the visual studio keyword, for example QT - integration works better if this is set to Qt4VSv1.0. - - VS_SCC_AUXPATH - Visual Studio Source Code Control Aux Path. - - Can be set to change the visual studio source code control auxpath - property. - - VS_SCC_LOCALPATH - Visual Studio Source Code Control Local Path. - - Can be set to change the visual studio source code control local path - property. - - VS_SCC_PROJECTNAME - Visual Studio Source Code Control Project. - - Can be set to change the visual studio source code control project - name property. - - VS_SCC_PROVIDER - Visual Studio Source Code Control Provider. - - Can be set to change the visual studio source code control provider - property. - - VS_WINRT_EXTENSIONS - Visual Studio project C++/CX language extensions for Windows Runtime - - Can be set to enable C++/CX language extensions. - - VS_WINRT_REFERENCES - Visual Studio project Windows Runtime Metadata references - - Adds one or more semicolon-delimited WinRT references to a generated - Visual Studio project. For example, "Windows;Windows.UI.Core". - - WIN32_EXECUTABLE - Build an executable with a WinMain entry point on windows. - - When this property is set to true the executable when linked on - Windows will be created with a WinMain() entry point instead of of - just main().This makes it a GUI executable instead of a console - application. See the CMAKE_MFC_FLAG variable documentation to - configure use of MFC for WinMain executables. This property is - initialized by the value of the variable CMAKE_WIN32_EXECUTABLE if it - is set when a target is created. - - XCODE_ATTRIBUTE_ - Set Xcode target attributes directly. - - Tell the Xcode generator to set '' to a given value in - the generated Xcode project. Ignored on other generators. - ------------------------------------------------------------------------------- -Properties on Tests - - ATTACHED_FILES - Attach a list of files to a dashboard submission. - - Set this property to a list of files that will be encoded and - submitted to the dashboard as an addition to the test result. - - ATTACHED_FILES_ON_FAIL - Attach a list of files to a dashboard submission if the test fails. - - Same as ATTACHED_FILES, but these files will only be included if the - test does not pass. - - COST - Set this to a floating point value. Tests in a test set will be run - in descending order of cost. - - This property describes the cost of a test. You can explicitly set - this value; tests with higher COST values will run first. - - DEPENDS - Specifies that this test should only be run after the specified list - of tests. - - Set this to a list of tests that must finish before this test is run. - - ENVIRONMENT - Specify environment variables that should be defined for running a - test. - - If set to a list of environment variables and values of the form - MYVAR=value those environment variables will be defined while running - the test. The environment is restored to its previous state after the - test is done. - - FAIL_REGULAR_EXPRESSION - If the output matches this regular expression the test will fail. - - If set, if the output matches one of specified regular expressions, - the test will fail.For example: PASS_REGULAR_EXPRESSION - "[^a-z]Error;ERROR;Failed" - - LABELS - Specify a list of text labels associated with a test. - - The list is reported in dashboard submissions. - - MEASUREMENT - Specify a CDASH measurement and value to be reported for a test. - - If set to a name then that name will be reported to CDASH as a named - measurement with a value of 1. You may also specify a value by - setting MEASUREMENT to "measurement=value". - - PASS_REGULAR_EXPRESSION - The output must match this regular expression for the test to pass. - - If set, the test output will be checked against the specified regular - expressions and at least one of the regular expressions has to match, - otherwise the test will fail. - - PROCESSORS - How many process slots this test requires - - Denotes the number of processors that this test will require. This is - typically used for MPI tests, and should be used in conjunction with - the ctest_test PARALLEL_LEVEL option. - - REQUIRED_FILES - List of files required to run the test. - - If set to a list of files, the test will not be run unless all of the - files exist. - - RESOURCE_LOCK - Specify a list of resources that are locked by this test. - - If multiple tests specify the same resource lock, they are guaranteed - not to run concurrently. - - RUN_SERIAL - Do not run this test in parallel with any other test. - - Use this option in conjunction with the ctest_test PARALLEL_LEVEL - option to specify that this test should not be run in parallel with - any other tests. - - TIMEOUT - How many seconds to allow for this test. - - This property if set will limit a test to not take more than the - specified number of seconds to run. If it exceeds that the test - process will be killed and ctest will move to the next test. This - setting takes precedence over CTEST_TESTING_TIMEOUT. - - WILL_FAIL - If set to true, this will invert the pass/fail flag of the test. - - This property can be used for tests that are expected to fail and - return a non zero return code. - - WORKING_DIRECTORY - The directory from which the test executable will be called. - - If this is not set it is called from the directory the test executable - is located in. - ------------------------------------------------------------------------------- -Properties on Source Files - - ABSTRACT - Is this source file an abstract class. - - A property on a source file that indicates if the source file - represents a class that is abstract. This only makes sense for - languages that have a notion of an abstract class and it is only used - by some tools that wrap classes into other languages. - - COMPILE_DEFINITIONS - Preprocessor definitions for compiling a source file. - - The COMPILE_DEFINITIONS property may be set to a semicolon-separated - list of preprocessor definitions using the syntax VAR or VAR=value. - Function-style definitions are not supported. CMake will - automatically escape the value correctly for the native build system - (note that CMake language syntax may require escapes to specify some - values). This property may be set on a per-configuration basis using - the name COMPILE_DEFINITIONS_ where is an upper-case - name (ex. "COMPILE_DEFINITIONS_DEBUG"). - - CMake will automatically drop some definitions that are not supported - by the native build tool. The VS6 IDE does not support definition - values with spaces (but NMake does). Xcode does not support - per-configuration definitions on source files. - - Disclaimer: Most native build tools have poor support for escaping - certain values. CMake has work-arounds for many cases but some values - may just not be possible to pass correctly. If a value does not seem - to be escaped correctly, do not attempt to work-around the problem by - adding escape sequences to the value. Your work-around may break in a - future version of CMake that has improved escape support. Instead - consider defining the macro in a (configured) header file. Then - report the limitation. Known limitations include: - - # - broken almost everywhere - ; - broken in VS IDE and Borland Makefiles - , - broken in VS IDE - % - broken in some cases in NMake - & | - broken in some cases on MinGW - ^ < > \" - broken in most Make tools on Windows - - CMake does not reject these values outright because they do work in - some cases. Use with caution. - - COMPILE_DEFINITIONS_ - Per-configuration preprocessor definitions on a source file. - - This is the configuration-specific version of COMPILE_DEFINITIONS. - Note that Xcode does not support per-configuration source file flags - so this property will be ignored by the Xcode generator. - - COMPILE_FLAGS - Additional flags to be added when compiling this source file. - - These flags will be added to the list of compile flags when this - source file builds. Use COMPILE_DEFINITIONS to pass additional - preprocessor definitions. - - EXTERNAL_OBJECT - If set to true then this is an object file. - - If this property is set to true then the source file is really an - object file and should not be compiled. It will still be linked into - the target though. - - Fortran_FORMAT - Set to FIXED or FREE to indicate the Fortran source layout. - - This property tells CMake whether a given Fortran source file uses - fixed-format or free-format. CMake will pass the corresponding format - flag to the compiler. Consider using the target-wide Fortran_FORMAT - property if all source files in a target share the same format. - - GENERATED - Is this source file generated as part of the build process. - - If a source file is generated by the build process CMake will handle - it differently in terms of dependency checking etc. Otherwise having - a non-existent source file could create problems. - - HEADER_FILE_ONLY - Is this source file only a header file. - - A property on a source file that indicates if the source file is a - header file with no associated implementation. This is set - automatically based on the file extension and is used by CMake to - determine is certain dependency information should be computed. - - KEEP_EXTENSION - Make the output file have the same extension as the source file. - - If this property is set then the file extension of the output file - will be the same as that of the source file. Normally the output file - extension is computed based on the language of the source file, for - example .cxx will go to a .o extension. - - LABELS - Specify a list of text labels associated with a source file. - - This property has meaning only when the source file is listed in a - target whose LABELS property is also set. No other semantics are - currently specified. - - LANGUAGE - What programming language is the file. - - A property that can be set to indicate what programming language the - source file is. If it is not set the language is determined based on - the file extension. Typical values are CXX C etc. Setting this - property for a file means this file will be compiled. Do not set this - for header or files that should not be compiled. - - LOCATION - The full path to a source file. - - A read only property on a SOURCE FILE that contains the full path to - the source file. - - MACOSX_PACKAGE_LOCATION - Place a source file inside a Mac OS X bundle, CFBundle, or framework. - - Executable targets with the MACOSX_BUNDLE property set are built as - Mac OS X application bundles on Apple platforms. Shared library - targets with the FRAMEWORK property set are built as Mac OS X - frameworks on Apple platforms. Module library targets with the BUNDLE - property set are built as Mac OS X CFBundle bundles on Apple - platforms. Source files listed in the target with this property set - will be copied to a directory inside the bundle or framework content - folder specified by the property value. For bundles the content - folder is ".app/Contents". For frameworks the content folder is - ".framework/Versions/". For cfbundles the content - folder is ".bundle/Contents" (unless the extension is changed). - See the PUBLIC_HEADER, PRIVATE_HEADER, and RESOURCE target properties - for specifying files meant for Headers, PrivateHeaders, or Resources - directories. - - OBJECT_DEPENDS - Additional files on which a compiled object file depends. - - Specifies a semicolon-separated list of full-paths to files on which - any object files compiled from this source file depend. An object - file will be recompiled if any of the named files is newer than it. - - This property need not be used to specify the dependency of a source - file on a generated header file that it includes. Although the - property was originally introduced for this purpose, it is no longer - necessary. If the generated header file is created by a custom - command in the same target as the source file, the automatic - dependency scanning process will recognize the dependency. If the - generated header file is created by another target, an inter-target - dependency should be created with the add_dependencies command (if one - does not already exist due to linking relationships). - - OBJECT_OUTPUTS - Additional outputs for a Makefile rule. - - Additional outputs created by compilation of this source file. If any - of these outputs is missing the object will be recompiled. This is - supported only on Makefile generators and will be ignored on other - generators. - - SYMBOLIC - Is this just a name for a rule. - - If SYMBOLIC (boolean) is set to true the build system will be informed - that the source file is not actually created on disk but instead used - as a symbolic name for a build rule. - - WRAP_EXCLUDE - Exclude this source file from any code wrapping techniques. - - Some packages can wrap source files into alternate languages to - provide additional functionality. For example, C++ code can be - wrapped into Java or Python etc using SWIG etc. If WRAP_EXCLUDE is - set to true (1 etc) that indicates then this source file should not be - wrapped. - ------------------------------------------------------------------------------- -Properties on Cache Entries - - ADVANCED - True if entry should be hidden by default in GUIs. - - This is a boolean value indicating whether the entry is considered - interesting only for advanced configuration. The mark_as_advanced() - command modifies this property. - - HELPSTRING - Help associated with entry in GUIs. - - This string summarizes the purpose of an entry to help users set it - through a CMake GUI. - - MODIFIED - Internal management property. Do not set or get. - - This is an internal cache entry property managed by CMake to track - interactive user modification of entries. Ignore it. - - STRINGS - Enumerate possible STRING entry values for GUI selection. - - For cache entries with type STRING, this enumerates a set of values. - CMake GUIs may use this to provide a selection widget instead of a - generic string entry field. This is for convenience only. CMake does - not enforce that the value matches one of those listed. - - TYPE - Widget type for entry in GUIs. - - Cache entry values are always strings, but CMake GUIs present widgets - to help users set values. The GUIs use this property as a hint to - determine the widget type. Valid TYPE values are: - - BOOL = Boolean ON/OFF value. - PATH = Path to a directory. - FILEPATH = Path to a file. - STRING = Generic string value. - INTERNAL = Do not present in GUI at all. - STATIC = Value managed by CMake, do not change. - UNINITIALIZED = Type not yet specified. - - Generally the TYPE of a cache entry should be set by the command which - creates it (set, option, find_library, etc.). - - VALUE - Value of a cache entry. - - This property maps to the actual value of a cache entry. Setting this - property always sets the value without checking, so use with care. - ------------------------------------------------------------------------------- -Copyright - -Copyright 2000-2009 Kitware, Inc., Insight Software Consortium. All rights -reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - -Redistributions of source code must retain the above copyright notice, this -list of conditions and the following disclaimer. - -Redistributions in binary form must reproduce the above copyright notice, -this list of conditions and the following disclaimer in the documentation -and/or other materials provided with the distribution. - -Neither the names of Kitware, Inc., the Insight Software Consortium, nor the -names of their contributors may be used to endorse or promote products -derived from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE -LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR -CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF -SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS -INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN -CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) -ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE -POSSIBILITY OF SUCH DAMAGE. - ------------------------------------------------------------------------------- -See Also - -The following resources are available to get help using CMake: - - Home Page - http://www.cmake.org - - The primary starting point for learning about CMake. - - Frequently Asked Questions - http://www.cmake.org/Wiki/CMake_FAQ - - A Wiki is provided containing answers to frequently asked questions. - - Online Documentation - http://www.cmake.org/HTML/Documentation.html - - Links to available documentation may be found on this web page. - - Mailing List - http://www.cmake.org/HTML/MailingLists.html - - For help and discussion about using cmake, a mailing list is provided - at cmake@cmake.org. The list is member-post-only but one may sign up - on the CMake web page. Please first read the full documentation at - http://www.cmake.org before posting questions to the list. - -Summary of helpful links: - - Home: http://www.cmake.org - Docs: http://www.cmake.org/HTML/Documentation.html - Mail: http://www.cmake.org/HTML/MailingLists.html - FAQ: http://www.cmake.org/Wiki/CMake_FAQ - +cmake_minimum_required(VERSION 2.8) + + +project(libobjc) +enable_language(ASM) + +set(CMAKE_C_FLAGS_DEBUG "-g -O0 -fno-inline ${CMAKE_C_FLAGS_DEBUG}") +set(CMAKE_C_FLAGS_RELEASE "-O3 ${CMAKE_C_FLAGS_RELEASE}") +set(CMAKE_C_FLAGS "-std=gnu99 ${CMAKE_C_FLAGS}") + +set(libobjc_VERSION 4.6) + +add_definitions( + -DGNUSTEP -D__OBJC_RUNTIME_INTERNAL__=1 -D_XOPEN_SOURCE=500 -D__BSD_VISIBLE=1 -D_BSD_SOURCE=1) + +set(libobjc_ASM_SRCS + block_trampolines.S + objc_msgSend.S) +set(libobjc_OBJC_SRCS + NSBlocks.m + Protocol2.m + arc.m + associate.m + blocks_runtime.m + properties.m) +set(libobjc_C_SRCS + abi_version.c + alias_table.c + block_to_imp.c + caps.c + category_loader.c + class_table.c + dtable.c + eh_personality.c + encoding2.c + gc_none.c + hash_table.c + hooks.c + ivar.c + legacy_malloc.c + loader.c + mutation.m + protocol.c + runtime.c + sarray2.c + selector_table.c + sendmsg2.c + statics_loader.c + toydispatch.c) +set(libobjc_HDRS + objc/Availability.h + objc/Object.h + objc/Protocol.h + objc/blocks_private.h + objc/blocks_runtime.h + objc/capabilities.h + objc/developer.h + objc/encoding.h + objc/hooks.h + objc/objc-api.h + objc/objc-arc.h + objc/objc-auto.h + objc/objc.h + objc/runtime-deprecated.h + objc/runtime.h + objc/slot.h +) + +set(libobjcxx_CXX_SRCS objcxx_eh.cc) + +# For release builds, we disable spamming the terminal with warnings about +# selector type mismatches +if (CMAKE_BUILD_TYPE STREQUAL Release) + ADD_DEFINITIONS(-DNO_SELECTOR_MISMATCH_WARNINGS) +else () + ADD_DEFINITIONS(-DGC_DEBUG) +endif () + +set(TYPE_DEPENDENT_DISPATCH TRUE CACHE BOOL + "Enable type-dependent dispatch") +if (TYPE_DEPENDENT_DISPATCH) + add_definitions(-DTYPE_DEPENDENT_DISPATCH) +endif () + +set(LOW_MEMORY FALSE CACHE BOOL + "Enable low-memory profile *HIGHLY EXPERIMENTAL*") +if (LOW_MEMORY) + add_definitions(-D__OBJC_LOW_MEMORY__) +endif () + +set(BOEHM_GC FALSE CACHE BOOL + "Enable garbage collection support (not recommended)") +if (BOEHM_GC) + include(FindPkgConfig) + pkg_check_modules(GC REQUIRED bdw-gc) + link_directories(${GC_LIBRARY_DIRS}) + # If there's a threaded version, use it + find_library(LIBGC gc-threaded PATHS "${GC_LIBRARY_DIRS}") + if (LIBGC) + else () + find_library(LIBGC gc PATHS GC_LIBRARY_DIRS) + endif () + message(STATUS "Using Boehm GC library: ${LIBGC}") + include_directories(GC_INCLUDE_DIRS) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${GC_CFLAGS}") + set(CMAKE_OBJC_FLAGS "${CMAKE_OBJC_FLAGS} -fobjc-gc") + set(objc_LINK_FLAGS "${objc_LINK_FLAGS} ${GC_CFLAGS}") + add_definitions(-DENABLE_GC) +endif () + +set(LEGACY_COMPAT FALSE CACHE BOOL + "Enable legacy compatibility features") +if (LEGACY_COMPAT) + list(APPEND libobjc_C_SRCS legacy_malloc.c) +else () + add_definitions(-DNO_LEGACY) +endif () + +find_package(LLVM) +set(LLVM_OPTS ${LLVM_FOUND} CACHE BOOL + "Build LLVM Objective-C optimisations") +if (LLVM_OPTS) + add_subdirectory(opts) + message(STATUS "Found LLVM, enabling LLVM optimisations") +endif () + +set(LIBOBJC_NAME "objc" CACHE STRING + "Name of the Objective-C runtime library (e.g. objc2 for libobjc2)") + +set(INCLUDE_DIRECTORY "objc" CACHE STRING + "Subdirectory of the include path to install the headers.") + + +if (${CMAKE_C_COMPILER_ID} MATCHES Clang*) + set(CMAKE_OBJC_FLAGS "${CMAKE_OBJC_FLAGS} -Wno-deprecated-objc-isa-usage -Wno-objc-root-class") + if (${CMAKE_C_COMPILER_VERSION} VERSION_GREATER 3.1) + set(CMAKE_OBJC_FLAGS "${CMAKE_OBJC_FLAGS} -fobjc-runtime=gnustep-1.7") + endif () + if (${CMAKE_SYSTEM_PROCESSOR} STREQUAL "i686") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=i586") + endif () +else (${CMAKE_C_COMPILER_ID} MATCHES Clang*) + MESSAGE("WARNING: It is strongly recommended that you compile with clang") +endif (${CMAKE_C_COMPILER_ID} MATCHES Clang*) + + + +set_source_files_properties( + ${libobjc_OBJC_SRCS} + PROPERTIES LANGUAGE C + COMPILE_FLAGS "${CMAKE_OBJC_FLAGS}" +) + +# +# C++ Runtime interaction +# + +# Try to find libcxxrt.so. We can link to this to provide the C++ ABI layer, +# if it exists. +find_library(CXX_RUNTIME cxxrt) +# If it doesn't, then look for GNU libsupc++.so instead (either works, they're +# ABI compatible). +if (NOT CXX_RUNTIME) + find_library(CXX_RUNTIME supc++) +endif (NOT CXX_RUNTIME) + +# If we have a C++ ABI library, then we can produce a single libobjc that works +# for Objective-C and Objective-C++. If not, then we need to provide a +# separate libobjcxx. +if (CXX_RUNTIME) + message(STATUS "Using ${CXX_RUNTIME} as the C++ runtime library") + set(libobjc_CXX_SRCS ${libobjcxx_CXX_SRCS}) + # We don't want to link the STL implementation (e.g. libstdc++) if we have + # a separate C++ runtime. + set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "") +else (CXX_RUNTIME) + message(STATUS "No C++ runtime library found") + add_library(objcxx SHARED ${libobjcxx_CXX_SRCS}) + set_target_properties(objcxx PROPERTIES + LINKER_LANGUAGE C + SOVERSION ${libobjc_VERSION} + ) + set(CXX_RUNTIME "") +endif (CXX_RUNTIME) + +# Currently, we actually need pthreads, but we should use the platform's native +# threading implementation (we do for everything except thread-local storage) +set(CMAKE_THREAD_PREFER_PTHREAD) +include(FindThreads) +set(objc_LINK_FLAGS "${objc_LINK_FLAGS} ${CMAKE_THREAD_LIBS_INIT}") + + + +add_library(objc SHARED ${libobjc_C_SRCS} ${libobjc_ASM_SRCS} ${libobjc_OBJC_SRCS} ${libobjc_CXX_SRCS}) + +set_target_properties(objc PROPERTIES + LINKER_LANGUAGE C + SOVERSION ${libobjc_VERSION} + OUTPUT_NAME ${LIBOBJC_NAME} + LINK_FLAGS "${objc_LINK_FLAGS}" + ) +set(INSTALL_TARGETS objc) + + +set(BUILD_STATIC_LIBOBJC false CACHE BOOL + "Build the static version of libobjc") +if (BUILD_STATIC_LIBOBJC) + add_library(objc-static STATIC ${libobjc_C_SRCS} ${libobjc_ASM_SRCS} ${libobjc_OBJC_SRCS} ${libobjc_CXX_SRCS}) + set_target_properties(objc-static PROPERTIES + POSITION_INDEPENDENT_CODE true + OUTPUT_NAME ${LIBOBJC_NAME}) + list(APPEND INSTALL_TARGETS objc-static) +endif () + + + +# Explicitly link the C++ runtime and libgc if we are compiling with gc support. +target_link_libraries(objc ${CXX_RUNTIME}) +if (LIBGC) + target_link_libraries(objc ${LIBGC}) +endif () + +# +# Installation +# + + +find_program(GNUSTEP_CONFIG gnustep-config) +if (GNUSTEP_CONFIG) + EXEC_PROGRAM(gnustep-config + ARGS "--installation-domain-for=libobjc2" + OUTPUT_VARIABLE DEFAULT_INSTALL_TYPE) +endif () + + +# If we have GNUstep environment variables, then default to installing in the +# GNUstep local environment. +if (DEFAULT_INSTALL_TYPE) +else () + set(DEFAULT_INSTALL_TYPE "NONE") +endif () + +set(GNUSTEP_INSTALL_TYPE ${DEFAULT_INSTALL_TYPE} CACHE STRING + "GNUstep installation type. Options are NONE, SYSTEM, NETWORK or LOCAL.") +if (${GNUSTEP_INSTALL_TYPE} STREQUAL "NONE") + SET(LIB_INSTALL_PATH lib) + SET(HEADER_INSTALL_PATH "include") +else () + EXEC_PROGRAM(gnustep-config + ARGS "--variable=GNUSTEP_${GNUSTEP_INSTALL_TYPE}_LIBRARIES" + OUTPUT_VARIABLE LIB_INSTALL_PATH) + EXEC_PROGRAM(gnustep-config + ARGS "--variable=GNUSTEP_${GNUSTEP_INSTALL_TYPE}_HEADERS" + OUTPUT_VARIABLE HEADER_INSTALL_PATH) +endif () +message(STATUS "GNUstep install type set to ${GNUSTEP_INSTALL_TYPE}") + +install(TARGETS ${INSTALL_TARGETS} + LIBRARY DESTINATION ${LIB_INSTALL_PATH} + ARCHIVE DESTINATION ${LIB_INSTALL_PATH}) +install(FILES ${libobjc_HDRS} + DESTINATION "${HEADER_INSTALL_PATH}/${INCLUDE_DIRECTORY}") + + + +set(CPACK_GENERATOR TGZ CACHE STRING + "Installer types to generate. Sensible options include TGZ, RPM and DEB") + +set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "GNUstep Objective-C Runtime") +set(CPACK_PACKAGE_VENDOR "The GNUstep Project") +set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/README") +set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/COPYING") +set(CPACK_PACKAGE_VERSION_MAJOR "1") +set(CPACK_PACKAGE_VERSION_MINOR "7") +set(CPACK_PACKAGE_VERSION_PATCH "0") +set(CPACK_PACKAGE_CONTACT "GNUstep Developer ") +set(CPACK_PACKAGE_INSTALL_DIRECTORY "CMake ${CMake_VERSION_MAJOR}.${CMake_VERSION_MINOR}") +if (UNIX) + set(CPACK_STRIP_FILES true CACHE BOOL "Strip libraries when packaging") +endif () +include (CPack) + +# uninstall target +configure_file( + "${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in" + "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake" + IMMEDIATE @ONLY) + +add_custom_target(uninstall + COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake) + +#enable_testing() +#add_subdirectory(Test)