1cmakeprops(1)               General Commands Manual              cmakeprops(1)
2
3
4

NAME

6       cmakeprops - Reference of CMake properties.
7
8

PROPERTIES

10         CMake Properties - Properties supported by CMake, the Cross-Platform Makefile Generator.
11
12
13       This  is the documentation for the properties supported by CMake. Prop‐
14       erties can have different scopes. They can  either  be  assigned  to  a
15       source  file,  a directory, a target or globally to CMake. By modifying
16       the values of properties the behaviour of the build system can be  cus‐
17       tomized.
18
19

PROPERTIES OF GLOBAL SCOPE

21       ALLOW_DUPLICATE_CUSTOM_TARGETS
22              Allow duplicate custom targets to be created.
23
24              Normally CMake requires that all targets built in a project have
25              globally unique logical names (see  policy  CMP0002).   This  is
26              necessary to generate meaningful project file names in Xcode and
27              VS IDE generators.  It also allows the target names to be refer‐
28              enced unambiguously.
29
30
31              Makefile  generators  are capable of supporting duplicate custom
32              target names.  For projects that care only about Makefile gener‐
33              ators and do not wish to support Xcode or VS IDE generators, one
34              may set this property to true to allow duplicate custom targets.
35              The  property allows multiple add_custom_target command calls in
36              different directories to specify the same target name.  However,
37              setting this property will cause non-Makefile generators to pro‐
38              duce an error and refuse to generate the project.
39
40
41       AUTOMOC_TARGETS_FOLDER
42              Name of FOLDER for *_automoc targets that  are  added  automati‐
43              cally by CMake for targets for which AUTOMOC is enabled.
44
45              If  not set, CMake uses the FOLDER property of the parent target
46              as a default value for this property. See also the documentation
47              for the FOLDER target property and the AUTOMOC target property.
48
49
50       DEBUG_CONFIGURATIONS
51              Specify which configurations are for debugging.
52
53              The  value  must be a semi-colon separated list of configuration
54              names.  Currently  this  property  is  used  only  by  the  tar‐
55              get_link_libraries  command (see its documentation for details).
56              Additional uses may be defined in the future.
57
58
59              This property must be set at the top level of  the  project  and
60              before  the  first target_link_libraries command invocation.  If
61              any entry in the list does not match a valid  configuration  for
62              the project the behavior is undefined.
63
64
65       DISABLED_FEATURES
66              List of features which are disabled during the CMake run.
67
68              List  of  features  which  are disabled during the CMake run. By
69              default it contains the names of all  packages  which  were  not
70              found.  This  is  determined  using  the <NAME>_FOUND variables.
71              Packages which are searched QUIET are not listed. A project  can
72              add  its own features to this list. This property is used by the
73              macros in FeatureSummary.cmake.
74
75
76       ENABLED_FEATURES
77              List of features which are enabled during the CMake run.
78
79              List of features which are enabled  during  the  CMake  run.  By
80              default  it contains the names of all packages which were found.
81              This is determined using the  <NAME>_FOUND  variables.  Packages
82              which  are  searched QUIET are not listed. A project can add its
83              own features to this list. This property is used by  the  macros
84              in FeatureSummary.cmake.
85
86
87       ENABLED_LANGUAGES
88              Read-only  property  that contains the list of currently enabled
89              languages
90
91              Set to list of currently enabled languages.
92
93
94       FIND_LIBRARY_USE_LIB64_PATHS
95              Whether FIND_LIBRARY should automatically search lib64  directo‐
96              ries.
97
98              FIND_LIBRARY_USE_LIB64_PATHS is a boolean specifying whether the
99              FIND_LIBRARY command should automatically search the lib64 vari‐
100              ant  of  directories called lib in the search path when building
101              64-bit binaries.
102
103
104       FIND_LIBRARY_USE_OPENBSD_VERSIONING
105              Whether FIND_LIBRARY should find OpenBSD-style shared libraries.
106
107              This property is a boolean specifying whether  the  FIND_LIBRARY
108              command  should  find  shared  libraries with OpenBSD-style ver‐
109              sioned extension: ".so.<major>.<minor>".  The property is set to
110              true on OpenBSD and false on other platforms.
111
112
113       GLOBAL_DEPENDS_DEBUG_MODE
114              Enable global target dependency graph debug mode.
115
116              CMake  automatically analyzes the global inter-target dependency
117              graph at the beginning of native build system generation.   This
118              property causes it to display details of its analysis to stderr.
119
120
121       GLOBAL_DEPENDS_NO_CYCLES
122              Disallow global target dependency graph cycles.
123
124              CMake  automatically analyzes the global inter-target dependency
125              graph at the beginning of native build  system  generation.   It
126              reports  an  error if the dependency graph contains a cycle that
127              does not consist of all STATIC library targets.   This  property
128              tells CMake to disallow all cycles completely, even among static
129              libraries.
130
131
132       IN_TRY_COMPILE
133              Read-only property that is true during a try-compile  configura‐
134              tion.
135
136              True  when  building  a  project inside a TRY_COMPILE or TRY_RUN
137              command.
138
139
140       PACKAGES_FOUND
141              List of packages which were found during the CMake run.
142
143              List of packages which were found during the CMake run.  Whether
144              a  package  has  been found is determined using the <NAME>_FOUND
145              variables.
146
147
148       PACKAGES_NOT_FOUND
149              List of packages which were not found during the CMake run.
150
151              List of packages which were not  found  during  the  CMake  run.
152              Whether  a  package  has  been  found  is  determined  using the
153              <NAME>_FOUND variables.
154
155
156       PREDEFINED_TARGETS_FOLDER
157              Name of FOLDER for  targets  that  are  added  automatically  by
158              CMake.
159
160              If  not  set,  CMake  uses "CMakePredefinedTargets" as a default
161              value for this property. Targets such as  INSTALL,  PACKAGE  and
162              RUN_TESTS will be organized into this FOLDER. See also the docu‐
163              mentation for the FOLDER target property.
164
165
166       REPORT_UNDEFINED_PROPERTIES
167              If set, report any undefined properties to this file.
168
169              If this property is set to a filename then when  CMake  runs  it
170              will  report  any properties or variables that were accessed but
171              not defined into the filename specified in this property.
172
173
174       RULE_LAUNCH_COMPILE
175              Specify a launcher for compile rules.
176
177              Makefile generators prefix  compiler  commands  with  the  given
178              launcher  command  line.  This is intended to allow launchers to
179              intercept build problems with  high  granularity.   Non-Makefile
180              generators currently ignore this property.
181
182
183       RULE_LAUNCH_CUSTOM
184              Specify a launcher for custom rules.
185
186              Makefile  generators  prefix  custom  commands  with  the  given
187              launcher command line.  This is intended to allow  launchers  to
188              intercept  build  problems  with high granularity.  Non-Makefile
189              generators currently ignore this property.
190
191
192       RULE_LAUNCH_LINK
193              Specify a launcher for link rules.
194
195              Makefile generators prefix link and archive  commands  with  the
196              given  launcher command line.  This is intended to allow launch‐
197              ers  to  intercept  build  problems   with   high   granularity.
198              Non-Makefile generators currently ignore this property.
199
200
201       RULE_MESSAGES
202              Specify whether to report a message for each make rule.
203
204              This property specifies whether Makefile generators should add a
205              progress message describing what each build rule does.   If  the
206              property  is not set the default is ON.  Set the property to OFF
207              to disable granular messages and report only as each target com‐
208              pletes.   This is intended to allow scripted builds to avoid the
209              build time cost of detailed reports.  If  a  CMAKE_RULE_MESSAGES
210              cache entry exists its value initializes the value of this prop‐
211              erty.  Non-Makefile generators currently ignore this property.
212
213
214       TARGET_ARCHIVES_MAY_BE_SHARED_LIBS
215              Set if shared libraries may be named like archives.
216
217              On AIX shared libraries may be named "lib<name>.a".  This  prop‐
218              erty is set to true on such platforms.
219
220
221       TARGET_SUPPORTS_SHARED_LIBS
222              Does the target platform support shared libraries.
223
224              TARGET_SUPPORTS_SHARED_LIBS  is a boolean specifying whether the
225              target platform supports shared libraries. Basically all current
226              general  general  purpose  OS  do  so, the exception are usually
227              embedded systems with no or special OSs.
228
229
230       USE_FOLDERS
231              Use the FOLDER target property to organize targets into folders.
232
233              If not set, CMake treats this property as OFF by default.  CMake
234              generators  that  are  capable of organizing into a hierarchy of
235              folders use the values of the FOLDER  target  property  to  name
236              those  folders. See also the documentation for the FOLDER target
237              property.
238
239
240       __CMAKE_DELETE_CACHE_CHANGE_VARS_
241              Internal property
242
243              Used to detect compiler changes, Do not set.
244
245

PROPERTIES ON DIRECTORIES

247       ADDITIONAL_MAKE_CLEAN_FILES
248              Additional files to clean during the make clean stage.
249
250              A list of files that will be cleaned as  a  part  of  the  "make
251              clean" stage.
252
253
254       CACHE_VARIABLES
255              List of cache variables available in the current directory.
256
257              This  read-only property specifies the list of CMake cache vari‐
258              ables currently defined.  It is intended for debugging purposes.
259
260
261       CLEAN_NO_CUSTOM
262              Should the output of custom commands be left.
263
264              If this is true then the outputs of  custom  commands  for  this
265              directory will not be removed during the "make clean" stage.
266
267
268       COMPILE_DEFINITIONS
269              Preprocessor definitions for compiling a directory's sources.
270
271              The COMPILE_DEFINITIONS property may be set to a semicolon-sepa‐
272              rated list of preprocessor definitions using the syntax  VAR  or
273              VAR=value.  Function-style definitions are not supported.  CMake
274              will automatically escape the value  correctly  for  the  native
275              build  system  (note  that  CMake  language  syntax  may require
276              escapes to specify some values).  This property may be set on  a
277              per-configuration basis using the name COMPILE_DEFINITIONS_<CON‐
278              FIG> where <CONFIG> is an upper-case name (ex.  "COMPILE_DEFINI‐
279              TIONS_DEBUG").  This property will be initialized in each direc‐
280              tory by its value in the directory's parent.
281
282
283              CMake will automatically drop some definitions that are not sup‐
284              ported  by  the native build tool.  The VS6 IDE does not support
285              definition values with spaces (but NMake does).
286
287
288              Disclaimer: Most native build tools have poor support for escap‐
289              ing  certain  values.  CMake has work-arounds for many cases but
290              some values may just not be possible to pass  correctly.   If  a
291              value  does  not seem to be escaped correctly, do not attempt to
292              work-around the problem by adding escape sequences to the value.
293              Your work-around may break in a future version of CMake that has
294              improved escape support.  Instead consider defining the macro in
295              a  (configured) header file.  Then report the limitation.  Known
296              limitations include:
297
298
299                #          - broken almost everywhere
300                ;          - broken in VS IDE 7.0 and Borland Makefiles
301                ,          - broken in VS IDE
302                %          - broken in some cases in NMake
303                & |        - broken in some cases on MinGW
304                ^ < > \"   - broken in most Make tools on Windows
305
306              CMake does not reject these values outright because they do work
307              in some cases.  Use with caution.
308
309
310       COMPILE_DEFINITIONS_<CONFIG>
311              Per-configuration preprocessor definitions in a directory.
312
313              This  is  the  configuration-specific version of COMPILE_DEFINI‐
314              TIONS.  This property will be initialized in each  directory  by
315              its value in the directory's parent.
316
317
318
319       COMPILE_OPTIONS
320              List of options to pass to the compiler.
321
322              This property specifies the list of directories given so far for
323              this property.  This property exists on directories and targets.
324
325
326              The target property values are used by the generators to set the
327              options for the compiler.
328
329
330              Contents of COMPILE_OPTIONS may use "generator expressions" with
331              the syntax "$<...>".  Generator expressions are evaluated during
332              build  system generation to produce information specific to each
333              build configuration.  Valid expressions are:
334
335
336                $<0:...>                  = empty string (ignores "...")
337                $<1:...>                  = content of "..."
338                $<CONFIG:cfg>             = '1' if config is "cfg", else '0'
339                $<CONFIGURATION>          = configuration name
340                $<BOOL:...>               = '1' if the '...' is true, else '0'
341                $<STREQUAL:a,b>           = '1' if a is STREQUAL b, else '0'
342                $<ANGLE-R>                = A literal '>'. Used to compare strings which contain a '>' for example.
343                $<COMMA>                  = A literal ','. Used to compare strings which contain a ',' for example.
344                $<SEMICOLON>              = A literal ';'. Used to prevent list expansion on an argument with ';'.
345                $<JOIN:list,...>          = joins the list with the content of "..."
346                $<TARGET_NAME:...>        = Marks ... as being the name of a target.  This is required if exporting targets to multiple dependent export sets.  The '...' must be a literal name of a target- it may not contain generator expressions.
347                $<INSTALL_INTERFACE:...>  = content of "..." when the property is exported using install(EXPORT), and empty otherwise.
348                $<BUILD_INTERFACE:...>    = content of "..." when the property is exported using export(), or when the target is used by another target in the same buildsystem. Expands to the empty string otherwise.
349                $<C_COMPILER_ID>          = The CMake-id of the C compiler used.
350                $<C_COMPILER_ID:comp>     = '1' if the CMake-id of the C compiler matches comp, otherwise '0'.
351                $<CXX_COMPILER_ID>        = The CMake-id of the CXX compiler used.
352                $<CXX_COMPILER_ID:comp>   = '1' if the CMake-id of the CXX compiler matches comp, otherwise '0'.
353                $<VERSION_GREATER:v1,v2>  = '1' if v1 is a version greater than v2, else '0'.
354                $<VERSION_LESS:v1,v2>     = '1' if v1 is a version less than v2, else '0'.
355                $<VERSION_EQUAL:v1,v2>    = '1' if v1 is the same version as v2, else '0'.
356                $<C_COMPILER_VERSION>     = The version of the C compiler used.
357                $<C_COMPILER_VERSION:ver> = '1' if the version of the C compiler matches ver, otherwise '0'.
358                $<CXX_COMPILER_VERSION>   = The version of the CXX compiler used.
359                $<CXX_COMPILER_VERSION:ver> = '1' if the version of the CXX compiler matches ver, otherwise '0'.
360                $<TARGET_FILE:tgt>        = main file (.exe, .so.1.2, .a)
361                $<TARGET_LINKER_FILE:tgt> = file used to link (.a, .lib, .so)
362                $<TARGET_SONAME_FILE:tgt> = file with soname (.so.3)
363
364              where "tgt" is the name of a target.   Target  file  expressions
365              produce a full path, but _DIR and _NAME versions can produce the
366              directory and file name components:
367
368
369                $<TARGET_FILE_DIR:tgt>/$<TARGET_FILE_NAME:tgt>
370                $<TARGET_LINKER_FILE_DIR:tgt>/$<TARGET_LINKER_FILE_NAME:tgt>
371                $<TARGET_SONAME_FILE_DIR:tgt>/$<TARGET_SONAME_FILE_NAME:tgt>
372
373
374
375
376                $<TARGET_PROPERTY:tgt,prop>   = The value of the property prop on the target tgt.
377
378              Note that tgt is not added as a dependency of  the  target  this
379              expression is evaluated on.
380
381
382                $<TARGET_POLICY:pol>          = '1' if the policy was NEW when the 'head' target was created, else '0'.  If the policy was not set, the warning message for the policy will be emitted.  This generator expression only works for a subset of policies.
383                $<INSTALL_PREFIX>         = Content of the install prefix when the target is exported via INSTALL(EXPORT) and empty otherwise.
384
385              Boolean expressions:
386
387
388                $<AND:?[,?]...>           = '1' if all '?' are '1', else '0'
389                $<OR:?[,?]...>            = '0' if all '?' are '0', else '1'
390                $<NOT:?>                  = '0' if '?' is '1', else '1'
391
392              where '?' is always either '0' or '1'.
393
394
395              Expressions with an implicit 'this' target:
396
397
398                $<TARGET_PROPERTY:prop>   = The value of the property prop on the target on which the generator expression is evaluated.
399
400
401       DEFINITIONS
402              For  CMake  2.4  compatibility  only.   Use  COMPILE_DEFINITIONS
403              instead.
404
405              This read-only property specifies the list of flags given so far
406              to  the  add_definitions  command.  It is intended for debugging
407              purposes.  Use the COMPILE_DEFINITIONS instead.
408
409
410       EXCLUDE_FROM_ALL
411              Exclude the directory from the all target of its parent.
412
413              A property on a directory that  indicates  if  its  targets  are
414              excluded  from the default build target. If it is not, then with
415              a Makefile for example typing make will cause the targets to  be
416              built.  The  same  concept applies to the default build of other
417              generators.
418
419
420       IMPLICIT_DEPENDS_INCLUDE_TRANSFORM
421              Specify #include line transforms for dependencies  in  a  direc‐
422              tory.
423
424              This  property  specifies rules to transform macro-like #include
425              lines during implicit dependency scanning of C  and  C++  source
426              files.   The list of rules must be semicolon-separated with each
427              entry of the form "A_MACRO(%)=value-with-%" (the % must be  lit‐
428              eral).   During  dependency scanning occurrences of A_MACRO(...)
429              on #include lines will be replaced by the value given  with  the
430              macro argument substituted for '%'.  For example, the entry
431
432
433                MYDIR(%)=<mydir/%>
434
435              will convert lines of the form
436
437
438                #include MYDIR(myheader.h)
439
440              to
441
442
443                #include <mydir/myheader.h>
444
445              allowing the dependency to be followed.
446
447
448              This  property applies to sources in all targets within a direc‐
449              tory.  The property value is initialized in  each  directory  by
450              its value in the directory's parent.
451
452
453       INCLUDE_DIRECTORIES
454              List of preprocessor include file search directories.
455
456              This  property specifies the list of directories given so far to
457              the include_directories command.  This property exists on direc‐
458              tories  and  targets.   In addition to accepting values from the
459              include_directories command, values may be set directly  on  any
460              directory  or any target using the set_property command.  A tar‐
461              get gets its initial value for this property from the  value  of
462              the directory property.  A directory gets its initial value from
463              its parent directory if it has one.  Both directory  and  target
464              property values are adjusted by calls to the include_directories
465              command.
466
467
468              The target property values are used by the generators to set the
469              include  paths  for the compiler.  See also the include_directo‐
470              ries command.
471
472
473       INCLUDE_REGULAR_EXPRESSION
474              Include file scanning regular expression.
475
476              This read-only property specifies the  regular  expression  used
477              during dependency scanning to match include files that should be
478              followed.  See the include_regular_expression command.
479
480
481       INTERPROCEDURAL_OPTIMIZATION
482              Enable interprocedural optimization for targets in a directory.
483
484              If set to true, enables interprocedural  optimizations  if  they
485              are known to be supported by the compiler.
486
487
488       INTERPROCEDURAL_OPTIMIZATION_<CONFIG>
489              Per-configuration interprocedural optimization for a directory.
490
491              This is a per-configuration version of INTERPROCEDURAL_OPTIMIZA‐
492              TION.  If set, this property overrides the generic property  for
493              the named configuration.
494
495
496       LINK_DIRECTORIES
497              List of linker search directories.
498
499              This  read-only property specifies the list of directories given
500              so far to the link_directories  command.   It  is  intended  for
501              debugging purposes.
502
503
504       LISTFILE_STACK
505              The current stack of listfiles being processed.
506
507              This  property  is  mainly useful when trying to debug errors in
508              your CMake scripts. It returns a list of  what  list  files  are
509              currently  being processed, in order. So if one listfile does an
510              INCLUDE command then that is effectively  pushing  the  included
511              listfile onto the stack.
512
513
514       MACROS List of macro commands available in the current directory.
515
516              This  read-only property specifies the list of CMake macros cur‐
517              rently defined.  It is intended for debugging purposes.  See the
518              macro command.
519
520
521       PARENT_DIRECTORY
522              Source directory that added current subdirectory.
523
524              This  read-only  property  specifies  the  source directory that
525              added the current source directory  as  a  subdirectory  of  the
526              build.    In   the   top-level   directory   the  value  is  the
527              empty-string.
528
529
530       RULE_LAUNCH_COMPILE
531              Specify a launcher for compile rules.
532
533              See the global property of the  same  name  for  details.   This
534              overrides the global property for a directory.
535
536
537       RULE_LAUNCH_CUSTOM
538              Specify a launcher for custom rules.
539
540              See  the  global  property  of  the same name for details.  This
541              overrides the global property for a directory.
542
543
544       RULE_LAUNCH_LINK
545              Specify a launcher for link rules.
546
547              See the global property of the  same  name  for  details.   This
548              overrides the global property for a directory.
549
550
551       TEST_INCLUDE_FILE
552              A cmake file that will be included when ctest is run.
553
554              If you specify TEST_INCLUDE_FILE, that file will be included and
555              processed when ctest is run on the directory.
556
557
558       VARIABLES
559              List of variables defined in the current directory.
560
561              This read-only property specifies the list  of  CMake  variables
562              currently defined.  It is intended for debugging purposes.
563
564
565       VS_GLOBAL_SECTION_POST_<section>
566              Specify a postSolution global section in Visual Studio.
567
568              Setting a property like this generates an entry of the following
569              form in the solution file:
570
571
572                GlobalSection(<section>) = postSolution
573                  <contents based on property value>
574                EndGlobalSection
575
576              The property must  be  set  to  a  semicolon-separated  list  of
577              key=value  pairs.  Each  such  pair  will be transformed into an
578              entry in the solution global section. Whitespace around key  and
579              value  is  ignored.  List elements which do not contain an equal
580              sign are skipped.
581
582
583              This property only works for Visual Studio 7 and  above;  it  is
584              ignored  on other generators. The property only applies when set
585              on a directory whose CMakeLists.txt contains  a  project()  com‐
586              mand.
587
588
589              Note  that  CMake generates postSolution sections Extensibility‐
590              Globals and ExtensibilityAddIns by default. If you set the  cor‐
591              responding  property,  it will override the default section. For
592              example,   setting   VS_GLOBAL_SECTION_POST_ExtensibilityGlobals
593              will  override  the default contents of the ExtensibilityGlobals
594              section, while keeping ExtensibilityAddIns on its default.
595
596
597       VS_GLOBAL_SECTION_PRE_<section>
598              Specify a preSolution global section in Visual Studio.
599
600              Setting a property like this generates an entry of the following
601              form in the solution file:
602
603
604                GlobalSection(<section>) = preSolution
605                  <contents based on property value>
606                EndGlobalSection
607
608              The  property  must  be  set  to  a  semicolon-separated list of
609              key=value pairs. Each such pair  will  be  transformed  into  an
610              entry  in the solution global section. Whitespace around key and
611              value is ignored. List elements which do not  contain  an  equal
612              sign are skipped.
613
614
615              This  property  only  works for Visual Studio 7 and above; it is
616              ignored on other generators. The property only applies when  set
617              on  a  directory  whose CMakeLists.txt contains a project() com‐
618              mand.
619
620

PROPERTIES ON TARGETS

622       <CONFIG>_OUTPUT_NAME
623              Old per-configuration target file base name.
624
625              This is a configuration-specific version  of  OUTPUT_NAME.   Use
626              OUTPUT_NAME_<CONFIG> instead.
627
628
629       <CONFIG>_POSTFIX
630              Postfix  to  append  to  the  target file name for configuration
631              <CONFIG>.
632
633              When building with configuration  <CONFIG>  the  value  of  this
634              property is appended to the target file name built on disk.  For
635              non-executable targets, this  property  is  initialized  by  the
636              value of the variable CMAKE_<CONFIG>_POSTFIX if it is set when a
637              target is created.  This property is  ignored  on  the  Mac  for
638              Frameworks and App Bundles.
639
640
641       <LANG>_VISIBILITY_PRESET
642              Value for symbol visibility compile flags
643
644              The   <LANG>_VISIBILITY_PRESET  property  determines  the  value
645              passed in a visibility related compile option, such  as  -fvisi‐
646              bility=  for  <LANG>.   This  property  only  has  an affect for
647              libraries and executables with exports.  This property  is  ini‐
648              tialized  by  the  value  of  the variable CMAKE_<LANG>_VISIBIL‐
649              ITY_PRESET if it is set when a target is created.
650
651
652       ALIASED_TARGET
653              Name of target aliased by this target.
654
655              If this is an ALIAS target, this property contains the  name  of
656              the target aliased.
657
658
659       ARCHIVE_OUTPUT_DIRECTORY
660              Output directory in which to build ARCHIVE target files.
661
662              This  property specifies the directory into which archive target
663              files  should  be  built.  Multi-configuration  generators  (VS,
664              Xcode)  append a per-configuration subdirectory to the specified
665              directory.  There are three kinds of target files  that  may  be
666              built:  archive,  library,  and runtime.  Executables are always
667              treated as runtime targets. Static libraries are always  treated
668              as  archive  targets.  Module  libraries  are  always treated as
669              library targets. For  non-DLL  platforms  shared  libraries  are
670              treated  as library targets. For DLL platforms the DLL part of a
671              shared library is treated as a runtime  target  and  the  corre‐
672              sponding  import  library  is  treated as an archive target. All
673              Windows-based systems including Cygwin are DLL platforms.   This
674              property  is  initialized by the value of the variable CMAKE_AR‐
675              CHIVE_OUTPUT_DIRECTORY if it is set when a target is created.
676
677
678       ARCHIVE_OUTPUT_DIRECTORY_<CONFIG>
679              Per-configuration output directory for ARCHIVE target files.
680
681              This is a per-configuration version of ARCHIVE_OUTPUT_DIRECTORY,
682              but  multi-configuration  generators (VS, Xcode) do NOT append a
683              per-configuration subdirectory to the specified directory.  This
684              property  is  initialized by the value of the variable CMAKE_AR‐
685              CHIVE_OUTPUT_DIRECTORY_<CONFIG> if it is set when  a  target  is
686              created.
687
688
689       ARCHIVE_OUTPUT_NAME
690              Output name for ARCHIVE target files.
691
692              This  property specifies the base name for archive target files.
693              It overrides OUTPUT_NAME  and  OUTPUT_NAME_<CONFIG>  properties.
694              There  are  three  kinds  of target files that may be built: ar‐
695              chive, library, and runtime.  Executables are always treated  as
696              runtime  targets. Static libraries are always treated as archive
697              targets. Module libraries are always treated as library targets.
698              For  non-DLL  platforms  shared libraries are treated as library
699              targets. For DLL platforms the DLL part of a shared  library  is
700              treated as a runtime target and the corresponding import library
701              is treated as  an  archive  target.  All  Windows-based  systems
702              including Cygwin are DLL platforms.
703
704
705       ARCHIVE_OUTPUT_NAME_<CONFIG>
706              Per-configuration output name for ARCHIVE target files.
707
708              This  is  the  configuration-specific  version  of  ARCHIVE_OUT‐
709              PUT_NAME.
710
711
712       AUTOMOC
713              Should the target be processed with automoc (for Qt projects).
714
715              AUTOMOC is a boolean specifying whether CMake will handle the Qt
716              moc  preprocessor  automatically, i.e. without having to use the
717              QT4_WRAP_CPP() or QT5_WRAP_CPP() macro. Currently  Qt4  and  Qt5
718              are  supported.   When  this property is set to TRUE, CMake will
719              scan the source files at build time and invoke moc  accordingly.
720              If  an  #include statement like #include "moc_foo.cpp" is found,
721              the Q_OBJECT class declaration is expected in  the  header,  and
722              moc  is  run  on  the header file. If an #include statement like
723              #include "foo.moc" is found, then a Q_OBJECT is expected in  the
724              current source file and moc is run on the file itself. Addition‐
725              ally, all header files are parsed for Q_OBJECT  macros,  and  if
726              found,  moc  is  also executed on those files. The resulting moc
727              files, which are not included as  shown  above  in  any  of  the
728              source  files  are  included  in  a generated <targetname>_auto‐
729              moc.cpp file, which is compiled as part of the target.This prop‐
730              erty  is  initialized by the value of the variable CMAKE_AUTOMOC
731              if it is set when a target is created.
732
733
734              Additional command line options for moc can be set via the AUTO‐
735              MOC_MOC_OPTIONS property.
736
737
738              By  setting  the CMAKE_AUTOMOC_RELAXED_MODE variable to TRUE the
739              rules for searching the files which will be processed by moc can
740              be  relaxed.  See  the  documentation for this variable for more
741              details.
742
743
744              The global property AUTOMOC_TARGETS_FOLDER can be used to  group
745              the automoc targets together in an IDE, e.g. in MSVS.
746
747
748       AUTOMOC_MOC_OPTIONS
749              Additional  options  for moc when using automoc (see the AUTOMOC
750              property)
751
752              This property is only used if the AUTOMOC  property  is  set  to
753              TRUE  for this target. In this case, it holds additional command
754              line options which will be used when moc is executed during  the
755              build, i.e. it is equivalent to the optional OPTIONS argument of
756              the qt4_wrap_cpp() macro.
757
758
759              By default it is empty.
760
761
762       BUILD_WITH_INSTALL_RPATH
763              Should build tree targets have install tree rpaths.
764
765              BUILD_WITH_INSTALL_RPATH is a boolean specifying whether to link
766              the target in the build tree with the INSTALL_RPATH.  This takes
767              precedence over SKIP_BUILD_RPATH and avoids the need for relink‐
768              ing  before  installation.   This property is initialized by the
769              value of the variable CMAKE_BUILD_WITH_INSTALL_RPATH  if  it  is
770              set when a target is created.
771
772
773       BUNDLE This target is a CFBundle on the Mac.
774
775              If a module library target has this property set to true it will
776              be built as a CFBundle when built on the mac. It will  have  the
777              directory structure required for a CFBundle and will be suitable
778              to be used for creating Browser  Plugins  or  other  application
779              resources.
780
781
782       BUNDLE_EXTENSION
783              The file extension used to name a BUNDLE target on the Mac.
784
785              The  default  value  is  "bundle" - you can also use "plugin" or
786              whatever file extension is required by the  host  app  for  your
787              bundle.
788
789
790       COMPATIBLE_INTERFACE_BOOL
791              Properties which must be compatible with their link interface
792
793              The  COMPATIBLE_INTERFACE_BOOL  property  may  contain a list of
794              propertiesfor this target which must be consistent  when  evalu‐
795              ated as a boolean in the INTERFACE of all linked dependees.  For
796              example, if a property "FOO" appears in the list, then for  each
797              dependee,  the  "INTERFACE_FOO"  property  content in all of its
798              dependencies must be consistent with each other,  and  with  the
799              "FOO"  property  in the dependee.  Consistency in this sense has
800              the meaning that if the property is set, then it must  have  the
801              same  boolean  value  as  all others, and if the property is not
802              set, then it is ignored.  Note that for each dependee,  the  set
803              of properties from this property must not intersect with the set
804              of properties from the COMPATIBLE_INTERFACE_STRING property.
805
806
807       COMPATIBLE_INTERFACE_STRING
808              Properties which  must  be  string-compatible  with  their  link
809              interface
810
811              The  COMPATIBLE_INTERFACE_STRING  property may contain a list of
812              properties for this target which must be the same when evaluated
813              as a string in the INTERFACE of all linked dependees.  For exam‐
814              ple, if a property "FOO" appears in  the  list,  then  for  each
815              dependee,  the  "INTERFACE_FOO"  property  content in all of its
816              dependencies must be equal with each other, and with  the  "FOO"
817              property  in  the dependee.  If the property is not set, then it
818              is ignored.  Note that for each dependee, the set of  properties
819              from this property must not intersect with the set of properties
820              from the COMPATIBLE_INTERFACE_BOOL property.
821
822
823       COMPILE_DEFINITIONS
824              Preprocessor definitions for compiling a target's sources.
825
826              The COMPILE_DEFINITIONS property may be set to a semicolon-sepa‐
827              rated  list  of preprocessor definitions using the syntax VAR or
828              VAR=value.  Function-style definitions are not supported.  CMake
829              will  automatically  escape  the  value correctly for the native
830              build system  (note  that  CMake  language  syntax  may  require
831              escapes  to specify some values).  This property may be set on a
832              per-configuration basis using the name COMPILE_DEFINITIONS_<CON‐
833              FIG>  where <CONFIG> is an upper-case name (ex. "COMPILE_DEFINI‐
834              TIONS_DEBUG").
835
836
837              CMake will automatically drop some definitions that are not sup‐
838              ported  by  the native build tool.  The VS6 IDE does not support
839              definition values with spaces (but NMake does).
840
841
842              Contents of COMPILE_DEFINITIONS may use "generator  expressions"
843              with  the  syntax "$<...>".  Generator expressions are evaluated
844              during build system generation to produce  information  specific
845              to each build configuration.  Valid expressions are:
846
847
848                $<0:...>                  = empty string (ignores "...")
849                $<1:...>                  = content of "..."
850                $<CONFIG:cfg>             = '1' if config is "cfg", else '0'
851                $<CONFIGURATION>          = configuration name
852                $<BOOL:...>               = '1' if the '...' is true, else '0'
853                $<STREQUAL:a,b>           = '1' if a is STREQUAL b, else '0'
854                $<ANGLE-R>                = A literal '>'. Used to compare strings which contain a '>' for example.
855                $<COMMA>                  = A literal ','. Used to compare strings which contain a ',' for example.
856                $<SEMICOLON>              = A literal ';'. Used to prevent list expansion on an argument with ';'.
857                $<JOIN:list,...>          = joins the list with the content of "..."
858                $<TARGET_NAME:...>        = Marks ... as being the name of a target.  This is required if exporting targets to multiple dependent export sets.  The '...' must be a literal name of a target- it may not contain generator expressions.
859                $<INSTALL_INTERFACE:...>  = content of "..." when the property is exported using install(EXPORT), and empty otherwise.
860                $<BUILD_INTERFACE:...>    = content of "..." when the property is exported using export(), or when the target is used by another target in the same buildsystem. Expands to the empty string otherwise.
861                $<C_COMPILER_ID>          = The CMake-id of the C compiler used.
862                $<C_COMPILER_ID:comp>     = '1' if the CMake-id of the C compiler matches comp, otherwise '0'.
863                $<CXX_COMPILER_ID>        = The CMake-id of the CXX compiler used.
864                $<CXX_COMPILER_ID:comp>   = '1' if the CMake-id of the CXX compiler matches comp, otherwise '0'.
865                $<VERSION_GREATER:v1,v2>  = '1' if v1 is a version greater than v2, else '0'.
866                $<VERSION_LESS:v1,v2>     = '1' if v1 is a version less than v2, else '0'.
867                $<VERSION_EQUAL:v1,v2>    = '1' if v1 is the same version as v2, else '0'.
868                $<C_COMPILER_VERSION>     = The version of the C compiler used.
869                $<C_COMPILER_VERSION:ver> = '1' if the version of the C compiler matches ver, otherwise '0'.
870                $<CXX_COMPILER_VERSION>   = The version of the CXX compiler used.
871                $<CXX_COMPILER_VERSION:ver> = '1' if the version of the CXX compiler matches ver, otherwise '0'.
872                $<TARGET_FILE:tgt>        = main file (.exe, .so.1.2, .a)
873                $<TARGET_LINKER_FILE:tgt> = file used to link (.a, .lib, .so)
874                $<TARGET_SONAME_FILE:tgt> = file with soname (.so.3)
875
876              where  "tgt"  is  the name of a target.  Target file expressions
877              produce a full path, but _DIR and _NAME versions can produce the
878              directory and file name components:
879
880
881                $<TARGET_FILE_DIR:tgt>/$<TARGET_FILE_NAME:tgt>
882                $<TARGET_LINKER_FILE_DIR:tgt>/$<TARGET_LINKER_FILE_NAME:tgt>
883                $<TARGET_SONAME_FILE_DIR:tgt>/$<TARGET_SONAME_FILE_NAME:tgt>
884
885
886
887
888                $<TARGET_PROPERTY:tgt,prop>   = The value of the property prop on the target tgt.
889
890              Note  that  tgt  is not added as a dependency of the target this
891              expression is evaluated on.
892
893
894                $<TARGET_POLICY:pol>          = '1' if the policy was NEW when the 'head' target was created, else '0'.  If the policy was not set, the warning message for the policy will be emitted.  This generator expression only works for a subset of policies.
895                $<INSTALL_PREFIX>         = Content of the install prefix when the target is exported via INSTALL(EXPORT) and empty otherwise.
896
897              Boolean expressions:
898
899
900                $<AND:?[,?]...>           = '1' if all '?' are '1', else '0'
901                $<OR:?[,?]...>            = '0' if all '?' are '0', else '1'
902                $<NOT:?>                  = '0' if '?' is '1', else '1'
903
904              where '?' is always either '0' or '1'.
905
906
907              Expressions with an implicit 'this' target:
908
909
910                $<TARGET_PROPERTY:prop>   = The value of the property prop on the target on which the generator expression is evaluated.
911
912              Disclaimer: Most native build tools have poor support for escap‐
913              ing  certain  values.  CMake has work-arounds for many cases but
914              some values may just not be possible to pass  correctly.   If  a
915              value  does  not seem to be escaped correctly, do not attempt to
916              work-around the problem by adding escape sequences to the value.
917              Your work-around may break in a future version of CMake that has
918              improved escape support.  Instead consider defining the macro in
919              a  (configured) header file.  Then report the limitation.  Known
920              limitations include:
921
922
923                #          - broken almost everywhere
924                ;          - broken in VS IDE 7.0 and Borland Makefiles
925                ,          - broken in VS IDE
926                %          - broken in some cases in NMake
927                & |        - broken in some cases on MinGW
928                ^ < > \"   - broken in most Make tools on Windows
929
930              CMake does not reject these values outright because they do work
931              in some cases.  Use with caution.
932
933
934       COMPILE_DEFINITIONS_<CONFIG>
935              Per-configuration preprocessor definitions on a target.
936
937              This  is  the  configuration-specific version of COMPILE_DEFINI‐
938              TIONS.
939
940
941       COMPILE_FLAGS
942              Additional flags to use when compiling this target's sources.
943
944              The COMPILE_FLAGS property sets additional compiler  flags  used
945              to  build sources within the target.  Use COMPILE_DEFINITIONS to
946              pass additional preprocessor definitions.
947
948
949       COMPILE_OPTIONS
950              List of options to pass to the compiler.
951
952              This property specifies the list of options specified so far for
953              this property.  This property exists on directories and targets.
954
955
956              The target property values are used by the generators to set the
957              options for the compiler.
958
959
960              Contents of COMPILE_OPTIONS may use "generator expressions" with
961              the syntax "$<...>".  Generator expressions are evaluated during
962              build system generation to produce information specific to  each
963              build configuration.  Valid expressions are:
964
965
966                $<0:...>                  = empty string (ignores "...")
967                $<1:...>                  = content of "..."
968                $<CONFIG:cfg>             = '1' if config is "cfg", else '0'
969                $<CONFIGURATION>          = configuration name
970                $<BOOL:...>               = '1' if the '...' is true, else '0'
971                $<STREQUAL:a,b>           = '1' if a is STREQUAL b, else '0'
972                $<ANGLE-R>                = A literal '>'. Used to compare strings which contain a '>' for example.
973                $<COMMA>                  = A literal ','. Used to compare strings which contain a ',' for example.
974                $<SEMICOLON>              = A literal ';'. Used to prevent list expansion on an argument with ';'.
975                $<JOIN:list,...>          = joins the list with the content of "..."
976                $<TARGET_NAME:...>        = Marks ... as being the name of a target.  This is required if exporting targets to multiple dependent export sets.  The '...' must be a literal name of a target- it may not contain generator expressions.
977                $<INSTALL_INTERFACE:...>  = content of "..." when the property is exported using install(EXPORT), and empty otherwise.
978                $<BUILD_INTERFACE:...>    = content of "..." when the property is exported using export(), or when the target is used by another target in the same buildsystem. Expands to the empty string otherwise.
979                $<C_COMPILER_ID>          = The CMake-id of the C compiler used.
980                $<C_COMPILER_ID:comp>     = '1' if the CMake-id of the C compiler matches comp, otherwise '0'.
981                $<CXX_COMPILER_ID>        = The CMake-id of the CXX compiler used.
982                $<CXX_COMPILER_ID:comp>   = '1' if the CMake-id of the CXX compiler matches comp, otherwise '0'.
983                $<VERSION_GREATER:v1,v2>  = '1' if v1 is a version greater than v2, else '0'.
984                $<VERSION_LESS:v1,v2>     = '1' if v1 is a version less than v2, else '0'.
985                $<VERSION_EQUAL:v1,v2>    = '1' if v1 is the same version as v2, else '0'.
986                $<C_COMPILER_VERSION>     = The version of the C compiler used.
987                $<C_COMPILER_VERSION:ver> = '1' if the version of the C compiler matches ver, otherwise '0'.
988                $<CXX_COMPILER_VERSION>   = The version of the CXX compiler used.
989                $<CXX_COMPILER_VERSION:ver> = '1' if the version of the CXX compiler matches ver, otherwise '0'.
990                $<TARGET_FILE:tgt>        = main file (.exe, .so.1.2, .a)
991                $<TARGET_LINKER_FILE:tgt> = file used to link (.a, .lib, .so)
992                $<TARGET_SONAME_FILE:tgt> = file with soname (.so.3)
993
994              where  "tgt"  is  the name of a target.  Target file expressions
995              produce a full path, but _DIR and _NAME versions can produce the
996              directory and file name components:
997
998
999                $<TARGET_FILE_DIR:tgt>/$<TARGET_FILE_NAME:tgt>
1000                $<TARGET_LINKER_FILE_DIR:tgt>/$<TARGET_LINKER_FILE_NAME:tgt>
1001                $<TARGET_SONAME_FILE_DIR:tgt>/$<TARGET_SONAME_FILE_NAME:tgt>
1002
1003
1004
1005
1006                $<TARGET_PROPERTY:tgt,prop>   = The value of the property prop on the target tgt.
1007
1008              Note  that  tgt  is not added as a dependency of the target this
1009              expression is evaluated on.
1010
1011
1012                $<TARGET_POLICY:pol>          = '1' if the policy was NEW when the 'head' target was created, else '0'.  If the policy was not set, the warning message for the policy will be emitted.  This generator expression only works for a subset of policies.
1013                $<INSTALL_PREFIX>         = Content of the install prefix when the target is exported via INSTALL(EXPORT) and empty otherwise.
1014
1015              Boolean expressions:
1016
1017
1018                $<AND:?[,?]...>           = '1' if all '?' are '1', else '0'
1019                $<OR:?[,?]...>            = '0' if all '?' are '0', else '1'
1020                $<NOT:?>                  = '0' if '?' is '1', else '1'
1021
1022              where '?' is always either '0' or '1'.
1023
1024
1025              Expressions with an implicit 'this' target:
1026
1027
1028                $<TARGET_PROPERTY:prop>   = The value of the property prop on the target on which the generator expression is evaluated.
1029
1030
1031       DEBUG_POSTFIX
1032              See target property <CONFIG>_POSTFIX.
1033
1034              This property is  a  special  case  of  the  more-general  <CON‐
1035              FIG>_POSTFIX property for the DEBUG configuration.
1036
1037
1038       DEFINE_SYMBOL
1039              Define a symbol when compiling this target's sources.
1040
1041              DEFINE_SYMBOL  sets  the name of the preprocessor symbol defined
1042              when compiling sources in a shared library. If not set here then
1043              it  is set to target_EXPORTS by default (with some substitutions
1044              if the target is not a valid C identifier). This is  useful  for
1045              headers  to  know  whether  they  are being included from inside
1046              their library or outside to properly  setup  dllexport/dllimport
1047              decorations.
1048
1049
1050       ENABLE_EXPORTS
1051              Specify  whether an executable exports symbols for loadable mod‐
1052              ules.
1053
1054              Normally an executable does not export any symbols because it is
1055              the  final  program.  It is possible for an executable to export
1056              symbols to be used by loadable modules.  When this  property  is
1057              set to true CMake will allow other targets to "link" to the exe‐
1058              cutable with the TARGET_LINK_LIBRARIES command.   On  all  plat‐
1059              forms a target-level dependency on the executable is created for
1060              targets that link to it.  For DLL platforms  an  import  library
1061              will be created for the exported symbols and then used for link‐
1062              ing.  All Windows-based systems including Cygwin are  DLL  plat‐
1063              forms.   For  non-DLL  platforms  that require all symbols to be
1064              resolved at link time, such as Mac OS X, the module will  "link"
1065              to the executable using a flag like "-bundle_loader".  For other
1066              non-DLL platforms the link rule  is  simply  ignored  since  the
1067              dynamic  loader  will automatically bind symbols when the module
1068              is loaded.
1069
1070
1071       EXCLUDE_FROM_ALL
1072              Exclude the target from the all target.
1073
1074              A property on a target that indicates if the target is  excluded
1075              from  the  default build target. If it is not, then with a Make‐
1076              file for example typing make will cause this target to be built.
1077              The  same  concept applies to the default build of other genera‐
1078              tors. Installing a target with EXCLUDE_FROM_ALL set to true  has
1079              undefined behavior.
1080
1081
1082       EXCLUDE_FROM_DEFAULT_BUILD
1083              Exclude target from "Build Solution".
1084
1085              This  property  is  only  used by Visual Studio generators 7 and
1086              above. When set to TRUE, the target will not be built  when  you
1087              press "Build Solution".
1088
1089
1090       EXCLUDE_FROM_DEFAULT_BUILD_<CONFIG>
1091              Per-configuration  version of target exclusion from "Build Solu‐
1092              tion".
1093
1094              This    is     the     configuration-specific     version     of
1095              EXCLUDE_FROM_DEFAULT_BUILD.         If        the        generic
1096              EXCLUDE_FROM_DEFAULT_BUILD   is   also   set   on   a    target,
1097              EXCLUDE_FROM_DEFAULT_BUILD_<CONFIG> takes precedence in configu‐
1098              rations for which it has a value.
1099
1100
1101       EXPORT_NAME
1102              Exported name for target files.
1103
1104              This sets the name for the IMPORTED  target  generated  when  it
1105              this target is is exported.  If not set, the logical target name
1106              is used by default.
1107
1108
1109       EchoString
1110              A message to be displayed when the target is built.
1111
1112              A message to display on some generators (such as makefiles) when
1113              the target is built.
1114
1115
1116       FOLDER Set the folder name. Use to organize targets in an IDE.
1117
1118              Targets  with  no FOLDER property will appear as top level enti‐
1119              ties in IDEs like Visual Studio. Targets with  the  same  FOLDER
1120              property  value  will  appear  next to each other in a folder of
1121              that  name.  To  nest  folders,  use  FOLDER  values   such   as
1122              'GUI/Dialogs' with '/' characters separating folder levels.
1123
1124
1125       FRAMEWORK
1126              This target is a framework on the Mac.
1127
1128              If a shared library target has this property set to true it will
1129              be built as a framework when built on the mac. It will have  the
1130              directory  structure  required for a framework and will be suit‐
1131              able to be used with the -framework option
1132
1133
1134       Fortran_FORMAT
1135              Set to FIXED or FREE to indicate the Fortran source layout.
1136
1137              This property tells CMake whether the Fortran source files in  a
1138              target  use  fixed-format  or  free-format.  CMake will pass the
1139              corresponding format flag to the compiler.  Use the  source-spe‐
1140              cific Fortran_FORMAT property to change the format of a specific
1141              source file.  If the variable CMAKE_Fortran_FORMAT is set when a
1142              target is created its value is used to initialize this property.
1143
1144
1145       Fortran_MODULE_DIRECTORY
1146              Specify  output  directory  for  Fortran modules provided by the
1147              target.
1148
1149              If the target contains Fortran source files that provide modules
1150              and  the compiler supports a module output directory this speci‐
1151              fies the directory in which the modules will  be  placed.   When
1152              this property is not set the modules will be placed in the build
1153              directory corresponding to the target's  source  directory.   If
1154              the variable CMAKE_Fortran_MODULE_DIRECTORY is set when a target
1155              is created its value is used to initialize this property.
1156
1157
1158              Note that some compilers will automatically  search  the  module
1159              output  directory for modules USEd during compilation but others
1160              will not.  If your sources USE modules their  location  must  be
1161              specified by INCLUDE_DIRECTORIES regardless of this property.
1162
1163
1164       GENERATOR_FILE_NAME
1165              Generator's file for this target.
1166
1167              An  internal property used by some generators to record the name
1168              of the project or dsp file associated  with  this  target.  Note
1169              that  at  configure  time, this property is only set for targets
1170              created by include_external_msproject().
1171
1172
1173       GNUtoMS
1174              Convert GNU import library (.dll.a) to MS format (.lib).
1175
1176              When linking a shared library or executable that exports symbols
1177              using  GNU  tools  on  Windows  (MinGW/MSYS)  with Visual Studio
1178              installed convert the import library (.dll.a)  from  GNU  to  MS
1179              format  (.lib).   Both  import  libraries  will  be installed by
1180              install(TARGETS) and exported by install(EXPORT) and export() to
1181              be  linked  by  applications  with  either GNU- or MS-compatible
1182              tools.
1183
1184
1185              If the variable CMAKE_GNUtoMS is set when a  target  is  created
1186              its  value  is  used  to initialize this property.  The variable
1187              must be set prior to the first command that enables  a  language
1188              such  as  project()  or  enable_language().   CMake provides the
1189              variable as an option to the user automatically when configuring
1190              on Windows with GNU tools.
1191
1192
1193       HAS_CXX
1194              Link the target using the C++ linker tool (obsolete).
1195
1196              This  is  equivalent  to setting the LINKER_LANGUAGE property to
1197              CXX.  See that property's documentation for details.
1198
1199
1200       IMPLICIT_DEPENDS_INCLUDE_TRANSFORM
1201              Specify #include line transforms for dependencies in a target.
1202
1203              This property specifies rules to transform  macro-like  #include
1204              lines  during  implicit  dependency scanning of C and C++ source
1205              files.  The list of rules must be semicolon-separated with  each
1206              entry  of the form "A_MACRO(%)=value-with-%" (the % must be lit‐
1207              eral).  During dependency scanning occurrences  of  A_MACRO(...)
1208              on  #include  lines will be replaced by the value given with the
1209              macro argument substituted for '%'.  For example, the entry
1210
1211
1212                MYDIR(%)=<mydir/%>
1213
1214              will convert lines of the form
1215
1216
1217                #include MYDIR(myheader.h)
1218
1219              to
1220
1221
1222                #include <mydir/myheader.h>
1223
1224              allowing the dependency to be followed.
1225
1226
1227              This property applies to sources in the target on  which  it  is
1228              set.
1229
1230
1231       IMPORTED
1232              Read-only indication of whether a target is IMPORTED.
1233
1234              The  boolean  value of this property is true for targets created
1235              with the IMPORTED option to add_executable or  add_library.   It
1236              is false for targets built within the project.
1237
1238
1239       IMPORTED_CONFIGURATIONS
1240              Configurations provided for an IMPORTED target.
1241
1242              Set  this  to  the  list of configuration names available for an
1243              IMPORTED target.  The names correspond to configurations defined
1244              in  the  project  from  which  the  target  is imported.  If the
1245              importing project uses a different  set  of  configurations  the
1246              names may be mapped using the MAP_IMPORTED_CONFIG_<CONFIG> prop‐
1247              erty.  Ignored for non-imported targets.
1248
1249
1250       IMPORTED_IMPLIB
1251              Full path to the import library for an IMPORTED target.
1252
1253              Set this to the location of the ".lib" part of  a  windows  DLL.
1254              Ignored for non-imported targets.
1255
1256
1257       IMPORTED_IMPLIB_<CONFIG>
1258              <CONFIG>-specific version of IMPORTED_IMPLIB property.
1259
1260              Configuration  names correspond to those provided by the project
1261              from which the target is imported.
1262
1263
1264       IMPORTED_LINK_DEPENDENT_LIBRARIES
1265              Dependent shared libraries of an imported shared library.
1266
1267              Shared libraries may be linked to other shared libraries as part
1268              of  their implementation.  On some platforms the linker searches
1269              for the dependent libraries of shared libraries they are includ‐
1270              ing  in  the  link.   Set this property to the list of dependent
1271              shared libraries of an imported library.   The  list  should  be
1272              disjoint  from  the  list  of  interface libraries in the INTER‐
1273              FACE_LINK_LIBRARIES property.  On platforms requiring  dependent
1274              shared  libraries  to be found at link time CMake uses this list
1275              to add appropriate files or paths  to  the  link  command  line.
1276              Ignored for non-imported targets.
1277
1278
1279       IMPORTED_LINK_DEPENDENT_LIBRARIES_<CONFIG>
1280              <CONFIG>-specific version of IMPORTED_LINK_DEPENDENT_LIBRARIES.
1281
1282              Configuration  names correspond to those provided by the project
1283              from which the target is imported.  If set, this  property  com‐
1284              pletely  overrides the generic property for the named configura‐
1285              tion.
1286
1287
1288       IMPORTED_LINK_INTERFACE_LANGUAGES
1289              Languages compiled into an IMPORTED static library.
1290
1291              Set this to the list of languages of source  files  compiled  to
1292              produce a STATIC IMPORTED library (such as "C" or "CXX").  CMake
1293              accounts for these languages when computing how to link a target
1294              to the imported library.  For example, when a C executable links
1295              to an imported C++ static library CMake chooses the  C++  linker
1296              to satisfy language runtime dependencies of the static library.
1297
1298
1299              This  property  is  ignored  for  targets  that  are  not STATIC
1300              libraries.  This property is ignored for non-imported targets.
1301
1302
1303       IMPORTED_LINK_INTERFACE_LANGUAGES_<CONFIG>
1304              <CONFIG>-specific version of IMPORTED_LINK_INTERFACE_LANGUAGES.
1305
1306              Configuration names correspond to those provided by the  project
1307              from  which  the target is imported.  If set, this property com‐
1308              pletely overrides the generic property for the named  configura‐
1309              tion.
1310
1311
1312       IMPORTED_LINK_INTERFACE_LIBRARIES
1313              Transitive link interface of an IMPORTED target.
1314
1315              Set  this  to  the list of libraries whose interface is included
1316              when an IMPORTED library target is  linked  to  another  target.
1317              The  libraries will be included on the link line for the target.
1318              Unlike  the  LINK_INTERFACE_LIBRARIES  property,  this  property
1319              applies   to   all   imported  target  types,  including  STATIC
1320              libraries.  This property is ignored for non-imported targets.
1321
1322
1323              This property is ignored if the  target  also  has  a  non-empty
1324              INTERFACE_LINK_LIBRARIES property.
1325
1326
1327              This   property   is  deprecated.  Use  INTERFACE_LINK_LIBRARIES
1328              instead.
1329
1330
1331       IMPORTED_LINK_INTERFACE_LIBRARIES_<CONFIG>
1332              <CONFIG>-specific version of IMPORTED_LINK_INTERFACE_LIBRARIES.
1333
1334              Configuration names correspond to those provided by the  project
1335              from  which  the target is imported.  If set, this property com‐
1336              pletely overrides the generic property for the named  configura‐
1337              tion.
1338
1339
1340              This  property  is  ignored  if  the target also has a non-empty
1341              INTERFACE_LINK_LIBRARIES property.
1342
1343
1344              This  property  is  deprecated.   Use   INTERFACE_LINK_LIBRARIES
1345              instead.
1346
1347
1348       IMPORTED_LINK_INTERFACE_MULTIPLICITY
1349              Repetition count for cycles of IMPORTED static libraries.
1350
1351              This is LINK_INTERFACE_MULTIPLICITY for IMPORTED targets.
1352
1353
1354       IMPORTED_LINK_INTERFACE_MULTIPLICITY_<CONFIG>
1355              <CONFIG>-specific  version of IMPORTED_LINK_INTERFACE_MULTIPLIC‐
1356              ITY.
1357
1358              If set, this property completely overrides the generic  property
1359              for the named configuration.
1360
1361
1362       IMPORTED_LOCATION
1363              Full path to the main file on disk for an IMPORTED target.
1364
1365              Set  this  to  the  location of an IMPORTED target file on disk.
1366              For executables this is the location  of  the  executable  file.
1367              For  bundles on OS X this is the location of the executable file
1368              inside Contents/MacOS under the application bundle folder.   For
1369              static libraries and modules this is the location of the library
1370              or module.  For shared libraries on non-DLL  platforms  this  is
1371              the location of the shared library.  For frameworks on OS X this
1372              is the location of the library  file  symlink  just  inside  the
1373              framework  folder.   For DLLs this is the location of the ".dll"
1374              part of the library.  For UNKNOWN libraries this is the location
1375              of the file to be linked.  Ignored for non-imported targets.
1376
1377
1378              Projects  may  skip  IMPORTED_LOCATION if the configuration-spe‐
1379              cific property IMPORTED_LOCATION_<CONFIG> is set.   To  get  the
1380              location of an imported target read one of the LOCATION or LOCA‐
1381              TION_<CONFIG> properties.
1382
1383
1384       IMPORTED_LOCATION_<CONFIG>
1385              <CONFIG>-specific version of IMPORTED_LOCATION property.
1386
1387              Configuration names correspond to those provided by the  project
1388              from which the target is imported.
1389
1390
1391       IMPORTED_NO_SONAME
1392              Specifies  that  an  IMPORTED shared library target has no "son‐
1393              ame".
1394
1395              Set this property to true for an imported  shared  library  file
1396              that  has  no  "soname"  field.  CMake may adjust generated link
1397              commands for some platforms to prevent the linker from using the
1398              path to the library in place of its missing soname.  Ignored for
1399              non-imported targets.
1400
1401
1402       IMPORTED_NO_SONAME_<CONFIG>
1403              <CONFIG>-specific version of IMPORTED_NO_SONAME property.
1404
1405              Configuration names correspond to those provided by the  project
1406              from which the target is imported.
1407
1408
1409       IMPORTED_SONAME
1410              The "soname" of an IMPORTED target of shared library type.
1411
1412              Set this to the "soname" embedded in an imported shared library.
1413              This is meaningful only on  platforms  supporting  the  feature.
1414              Ignored for non-imported targets.
1415
1416
1417       IMPORTED_SONAME_<CONFIG>
1418              <CONFIG>-specific version of IMPORTED_SONAME property.
1419
1420              Configuration  names correspond to those provided by the project
1421              from which the target is imported.
1422
1423
1424       IMPORT_PREFIX
1425              What comes before the import library name.
1426
1427              Similar to the target  property  PREFIX,  but  used  for  import
1428              libraries  (typically corresponding to a DLL) instead of regular
1429              libraries. A target property that can be  set  to  override  the
1430              prefix (such as "lib") on an import library name.
1431
1432
1433       IMPORT_SUFFIX
1434              What comes after the import library name.
1435
1436              Similar  to  the  target  property  SUFFIX,  but used for import
1437              libraries (typically corresponding to a DLL) instead of  regular
1438              libraries.  A  target  property  that can be set to override the
1439              suffix (such as ".lib") on an import library name.
1440
1441
1442       INCLUDE_DIRECTORIES
1443              List of preprocessor include file search directories.
1444
1445              This property specifies the list of directories given so far  to
1446              the  include_directories command. This property exists on direc‐
1447              tories and targets. In addition to  accepting  values  from  the
1448              include_directories  command,  values may be set directly on any
1449              directory or any target using the set_property command. A target
1450              gets  its  initial value for this property from the value of the
1451              directory property. A directory gets its initial value from  its
1452              parent  directory if it has one. Both directory and target prop‐
1453              erty values are adjusted by  calls  to  the  include_directories
1454              command.
1455
1456
1457              The target property values are used by the generators to set the
1458              include paths for the compiler.  See also  the  include_directo‐
1459              ries command.
1460
1461
1462              Contents  of INCLUDE_DIRECTORIES may use "generator expressions"
1463              with the syntax "$<...>".  Generator expressions  are  evaluated
1464              during  build  system generation to produce information specific
1465              to each build configuration.  Valid expressions are:
1466
1467
1468                $<0:...>                  = empty string (ignores "...")
1469                $<1:...>                  = content of "..."
1470                $<CONFIG:cfg>             = '1' if config is "cfg", else '0'
1471                $<CONFIGURATION>          = configuration name
1472                $<BOOL:...>               = '1' if the '...' is true, else '0'
1473                $<STREQUAL:a,b>           = '1' if a is STREQUAL b, else '0'
1474                $<ANGLE-R>                = A literal '>'. Used to compare strings which contain a '>' for example.
1475                $<COMMA>                  = A literal ','. Used to compare strings which contain a ',' for example.
1476                $<SEMICOLON>              = A literal ';'. Used to prevent list expansion on an argument with ';'.
1477                $<JOIN:list,...>          = joins the list with the content of "..."
1478                $<TARGET_NAME:...>        = Marks ... as being the name of a target.  This is required if exporting targets to multiple dependent export sets.  The '...' must be a literal name of a target- it may not contain generator expressions.
1479                $<INSTALL_INTERFACE:...>  = content of "..." when the property is exported using install(EXPORT), and empty otherwise.
1480                $<BUILD_INTERFACE:...>    = content of "..." when the property is exported using export(), or when the target is used by another target in the same buildsystem. Expands to the empty string otherwise.
1481                $<C_COMPILER_ID>          = The CMake-id of the C compiler used.
1482                $<C_COMPILER_ID:comp>     = '1' if the CMake-id of the C compiler matches comp, otherwise '0'.
1483                $<CXX_COMPILER_ID>        = The CMake-id of the CXX compiler used.
1484                $<CXX_COMPILER_ID:comp>   = '1' if the CMake-id of the CXX compiler matches comp, otherwise '0'.
1485                $<VERSION_GREATER:v1,v2>  = '1' if v1 is a version greater than v2, else '0'.
1486                $<VERSION_LESS:v1,v2>     = '1' if v1 is a version less than v2, else '0'.
1487                $<VERSION_EQUAL:v1,v2>    = '1' if v1 is the same version as v2, else '0'.
1488                $<C_COMPILER_VERSION>     = The version of the C compiler used.
1489                $<C_COMPILER_VERSION:ver> = '1' if the version of the C compiler matches ver, otherwise '0'.
1490                $<CXX_COMPILER_VERSION>   = The version of the CXX compiler used.
1491                $<CXX_COMPILER_VERSION:ver> = '1' if the version of the CXX compiler matches ver, otherwise '0'.
1492                $<TARGET_FILE:tgt>        = main file (.exe, .so.1.2, .a)
1493                $<TARGET_LINKER_FILE:tgt> = file used to link (.a, .lib, .so)
1494                $<TARGET_SONAME_FILE:tgt> = file with soname (.so.3)
1495
1496              where "tgt" is the name of a target.   Target  file  expressions
1497              produce a full path, but _DIR and _NAME versions can produce the
1498              directory and file name components:
1499
1500
1501                $<TARGET_FILE_DIR:tgt>/$<TARGET_FILE_NAME:tgt>
1502                $<TARGET_LINKER_FILE_DIR:tgt>/$<TARGET_LINKER_FILE_NAME:tgt>
1503                $<TARGET_SONAME_FILE_DIR:tgt>/$<TARGET_SONAME_FILE_NAME:tgt>
1504
1505
1506
1507
1508                $<TARGET_PROPERTY:tgt,prop>   = The value of the property prop on the target tgt.
1509
1510              Note that tgt is not added as a dependency of  the  target  this
1511              expression is evaluated on.
1512
1513
1514                $<TARGET_POLICY:pol>          = '1' if the policy was NEW when the 'head' target was created, else '0'.  If the policy was not set, the warning message for the policy will be emitted.  This generator expression only works for a subset of policies.
1515                $<INSTALL_PREFIX>         = Content of the install prefix when the target is exported via INSTALL(EXPORT) and empty otherwise.
1516
1517              Boolean expressions:
1518
1519
1520                $<AND:?[,?]...>           = '1' if all '?' are '1', else '0'
1521                $<OR:?[,?]...>            = '0' if all '?' are '0', else '1'
1522                $<NOT:?>                  = '0' if '?' is '1', else '1'
1523
1524              where '?' is always either '0' or '1'.
1525
1526
1527              Expressions with an implicit 'this' target:
1528
1529
1530                $<TARGET_PROPERTY:prop>   = The value of the property prop on the target on which the generator expression is evaluated.
1531
1532
1533       INSTALL_NAME_DIR
1534              Mac OSX directory name for installed targets.
1535
1536              INSTALL_NAME_DIR is a string specifying the directory portion of
1537              the "install_name" field of shared libraries on Mac OSX  to  use
1538              in the installed targets.
1539
1540
1541       INSTALL_RPATH
1542              The rpath to use for installed targets.
1543
1544              A  semicolon-separated  list  specifying  the  rpath  to  use in
1545              installed targets (for platforms that support it).   This  prop‐
1546              erty   is   initialized   by   the   value   of   the   variable
1547              CMAKE_INSTALL_RPATH if it is set when a target is created.
1548
1549
1550       INSTALL_RPATH_USE_LINK_PATH
1551              Add paths to linker search and installed rpath.
1552
1553              INSTALL_RPATH_USE_LINK_PATH is a boolean that  if  set  to  true
1554              will  append  directories  in the linker search path and outside
1555              the project to the INSTALL_RPATH.  This property is  initialized
1556              by  the  value of the variable CMAKE_INSTALL_RPATH_USE_LINK_PATH
1557              if it is set when a target is created.
1558
1559
1560       INTERFACE_COMPILE_DEFINITIONS
1561              List of public compile definitions for a library.
1562
1563              Targets may populate this property to publish the compile  defi‐
1564              nitions  required to compile against the headers for the target.
1565              Consuming targets can add entries to their  own  COMPILE_DEFINI‐
1566              TIONS   property  such  as  $<TARGET_PROPERTY:foo,INTERFACE_COM‐
1567              PILE_DEFINITIONS> to use the compile  definitions  specified  in
1568              the interface of 'foo'.
1569
1570
1571              Generator  expressions are evaluated during build system genera‐
1572              tion to produce information specific to  each  build  configura‐
1573              tion.  Valid expressions are:
1574
1575
1576                $<0:...>                  = empty string (ignores "...")
1577                $<1:...>                  = content of "..."
1578                $<CONFIG:cfg>             = '1' if config is "cfg", else '0'
1579                $<CONFIGURATION>          = configuration name
1580                $<BOOL:...>               = '1' if the '...' is true, else '0'
1581                $<STREQUAL:a,b>           = '1' if a is STREQUAL b, else '0'
1582                $<ANGLE-R>                = A literal '>'. Used to compare strings which contain a '>' for example.
1583                $<COMMA>                  = A literal ','. Used to compare strings which contain a ',' for example.
1584                $<SEMICOLON>              = A literal ';'. Used to prevent list expansion on an argument with ';'.
1585                $<JOIN:list,...>          = joins the list with the content of "..."
1586                $<TARGET_NAME:...>        = Marks ... as being the name of a target.  This is required if exporting targets to multiple dependent export sets.  The '...' must be a literal name of a target- it may not contain generator expressions.
1587                $<INSTALL_INTERFACE:...>  = content of "..." when the property is exported using install(EXPORT), and empty otherwise.
1588                $<BUILD_INTERFACE:...>    = content of "..." when the property is exported using export(), or when the target is used by another target in the same buildsystem. Expands to the empty string otherwise.
1589                $<C_COMPILER_ID>          = The CMake-id of the C compiler used.
1590                $<C_COMPILER_ID:comp>     = '1' if the CMake-id of the C compiler matches comp, otherwise '0'.
1591                $<CXX_COMPILER_ID>        = The CMake-id of the CXX compiler used.
1592                $<CXX_COMPILER_ID:comp>   = '1' if the CMake-id of the CXX compiler matches comp, otherwise '0'.
1593                $<VERSION_GREATER:v1,v2>  = '1' if v1 is a version greater than v2, else '0'.
1594                $<VERSION_LESS:v1,v2>     = '1' if v1 is a version less than v2, else '0'.
1595                $<VERSION_EQUAL:v1,v2>    = '1' if v1 is the same version as v2, else '0'.
1596                $<C_COMPILER_VERSION>     = The version of the C compiler used.
1597                $<C_COMPILER_VERSION:ver> = '1' if the version of the C compiler matches ver, otherwise '0'.
1598                $<CXX_COMPILER_VERSION>   = The version of the CXX compiler used.
1599                $<CXX_COMPILER_VERSION:ver> = '1' if the version of the CXX compiler matches ver, otherwise '0'.
1600                $<TARGET_FILE:tgt>        = main file (.exe, .so.1.2, .a)
1601                $<TARGET_LINKER_FILE:tgt> = file used to link (.a, .lib, .so)
1602                $<TARGET_SONAME_FILE:tgt> = file with soname (.so.3)
1603
1604              where  "tgt"  is  the name of a target.  Target file expressions
1605              produce a full path, but _DIR and _NAME versions can produce the
1606              directory and file name components:
1607
1608
1609                $<TARGET_FILE_DIR:tgt>/$<TARGET_FILE_NAME:tgt>
1610                $<TARGET_LINKER_FILE_DIR:tgt>/$<TARGET_LINKER_FILE_NAME:tgt>
1611                $<TARGET_SONAME_FILE_DIR:tgt>/$<TARGET_SONAME_FILE_NAME:tgt>
1612
1613
1614
1615
1616                $<TARGET_PROPERTY:tgt,prop>   = The value of the property prop on the target tgt.
1617
1618              Note  that  tgt  is not added as a dependency of the target this
1619              expression is evaluated on.
1620
1621
1622                $<TARGET_POLICY:pol>          = '1' if the policy was NEW when the 'head' target was created, else '0'.  If the policy was not set, the warning message for the policy will be emitted.  This generator expression only works for a subset of policies.
1623                $<INSTALL_PREFIX>         = Content of the install prefix when the target is exported via INSTALL(EXPORT) and empty otherwise.
1624
1625              Boolean expressions:
1626
1627
1628                $<AND:?[,?]...>           = '1' if all '?' are '1', else '0'
1629                $<OR:?[,?]...>            = '0' if all '?' are '0', else '1'
1630                $<NOT:?>                  = '0' if '?' is '1', else '1'
1631
1632              where '?' is always either '0' or '1'.
1633
1634
1635              Expressions with an implicit 'this' target:
1636
1637
1638                $<TARGET_PROPERTY:prop>   = The value of the property prop on the target on which the generator expression is evaluated.
1639
1640
1641       INTERFACE_COMPILE_OPTIONS
1642              List of interface options to pass to the compiler.
1643
1644              Targets may  populate  this  property  to  publish  the  compile
1645              options  required to compile against the headers for the target.
1646              Consuming targets can add entries to their  own  COMPILE_OPTIONS
1647              property     such     as    $<TARGET_PROPERTY:foo,INTERFACE_COM‐
1648              PILE_OPTIONS> to use the compile options specified in the inter‐
1649              face of 'foo'.
1650
1651
1652              Generator  expressions are evaluated during build system genera‐
1653              tion to produce information specific to  each  build  configura‐
1654              tion.  Valid expressions are:
1655
1656
1657                $<0:...>                  = empty string (ignores "...")
1658                $<1:...>                  = content of "..."
1659                $<CONFIG:cfg>             = '1' if config is "cfg", else '0'
1660                $<CONFIGURATION>          = configuration name
1661                $<BOOL:...>               = '1' if the '...' is true, else '0'
1662                $<STREQUAL:a,b>           = '1' if a is STREQUAL b, else '0'
1663                $<ANGLE-R>                = A literal '>'. Used to compare strings which contain a '>' for example.
1664                $<COMMA>                  = A literal ','. Used to compare strings which contain a ',' for example.
1665                $<SEMICOLON>              = A literal ';'. Used to prevent list expansion on an argument with ';'.
1666                $<JOIN:list,...>          = joins the list with the content of "..."
1667                $<TARGET_NAME:...>        = Marks ... as being the name of a target.  This is required if exporting targets to multiple dependent export sets.  The '...' must be a literal name of a target- it may not contain generator expressions.
1668                $<INSTALL_INTERFACE:...>  = content of "..." when the property is exported using install(EXPORT), and empty otherwise.
1669                $<BUILD_INTERFACE:...>    = content of "..." when the property is exported using export(), or when the target is used by another target in the same buildsystem. Expands to the empty string otherwise.
1670                $<C_COMPILER_ID>          = The CMake-id of the C compiler used.
1671                $<C_COMPILER_ID:comp>     = '1' if the CMake-id of the C compiler matches comp, otherwise '0'.
1672                $<CXX_COMPILER_ID>        = The CMake-id of the CXX compiler used.
1673                $<CXX_COMPILER_ID:comp>   = '1' if the CMake-id of the CXX compiler matches comp, otherwise '0'.
1674                $<VERSION_GREATER:v1,v2>  = '1' if v1 is a version greater than v2, else '0'.
1675                $<VERSION_LESS:v1,v2>     = '1' if v1 is a version less than v2, else '0'.
1676                $<VERSION_EQUAL:v1,v2>    = '1' if v1 is the same version as v2, else '0'.
1677                $<C_COMPILER_VERSION>     = The version of the C compiler used.
1678                $<C_COMPILER_VERSION:ver> = '1' if the version of the C compiler matches ver, otherwise '0'.
1679                $<CXX_COMPILER_VERSION>   = The version of the CXX compiler used.
1680                $<CXX_COMPILER_VERSION:ver> = '1' if the version of the CXX compiler matches ver, otherwise '0'.
1681                $<TARGET_FILE:tgt>        = main file (.exe, .so.1.2, .a)
1682                $<TARGET_LINKER_FILE:tgt> = file used to link (.a, .lib, .so)
1683                $<TARGET_SONAME_FILE:tgt> = file with soname (.so.3)
1684
1685              where  "tgt"  is  the name of a target.  Target file expressions
1686              produce a full path, but _DIR and _NAME versions can produce the
1687              directory and file name components:
1688
1689
1690                $<TARGET_FILE_DIR:tgt>/$<TARGET_FILE_NAME:tgt>
1691                $<TARGET_LINKER_FILE_DIR:tgt>/$<TARGET_LINKER_FILE_NAME:tgt>
1692                $<TARGET_SONAME_FILE_DIR:tgt>/$<TARGET_SONAME_FILE_NAME:tgt>
1693
1694
1695
1696
1697                $<TARGET_PROPERTY:tgt,prop>   = The value of the property prop on the target tgt.
1698
1699              Note  that  tgt  is not added as a dependency of the target this
1700              expression is evaluated on.
1701
1702
1703                $<TARGET_POLICY:pol>          = '1' if the policy was NEW when the 'head' target was created, else '0'.  If the policy was not set, the warning message for the policy will be emitted.  This generator expression only works for a subset of policies.
1704                $<INSTALL_PREFIX>         = Content of the install prefix when the target is exported via INSTALL(EXPORT) and empty otherwise.
1705
1706              Boolean expressions:
1707
1708
1709                $<AND:?[,?]...>           = '1' if all '?' are '1', else '0'
1710                $<OR:?[,?]...>            = '0' if all '?' are '0', else '1'
1711                $<NOT:?>                  = '0' if '?' is '1', else '1'
1712
1713              where '?' is always either '0' or '1'.
1714
1715
1716              Expressions with an implicit 'this' target:
1717
1718
1719                $<TARGET_PROPERTY:prop>   = The value of the property prop on the target on which the generator expression is evaluated.
1720
1721
1722       INTERFACE_INCLUDE_DIRECTORIES
1723              List of public include directories for a library.
1724
1725              Targets may populate this property to publish the include direc‐
1726              tories  required  to compile against the headers for the target.
1727              Consuming targets can add entries to their own  INCLUDE_DIRECTO‐
1728              RIES     property     such    as    $<TARGET_PROPERTY:foo,INTER‐
1729              FACE_INCLUDE_DIRECTORIES> to use the include directories  speci‐
1730              fied in the interface of 'foo'.
1731
1732
1733              Generator  expressions are evaluated during build system genera‐
1734              tion to produce information specific to  each  build  configura‐
1735              tion.  Valid expressions are:
1736
1737
1738                $<0:...>                  = empty string (ignores "...")
1739                $<1:...>                  = content of "..."
1740                $<CONFIG:cfg>             = '1' if config is "cfg", else '0'
1741                $<CONFIGURATION>          = configuration name
1742                $<BOOL:...>               = '1' if the '...' is true, else '0'
1743                $<STREQUAL:a,b>           = '1' if a is STREQUAL b, else '0'
1744                $<ANGLE-R>                = A literal '>'. Used to compare strings which contain a '>' for example.
1745                $<COMMA>                  = A literal ','. Used to compare strings which contain a ',' for example.
1746                $<SEMICOLON>              = A literal ';'. Used to prevent list expansion on an argument with ';'.
1747                $<JOIN:list,...>          = joins the list with the content of "..."
1748                $<TARGET_NAME:...>        = Marks ... as being the name of a target.  This is required if exporting targets to multiple dependent export sets.  The '...' must be a literal name of a target- it may not contain generator expressions.
1749                $<INSTALL_INTERFACE:...>  = content of "..." when the property is exported using install(EXPORT), and empty otherwise.
1750                $<BUILD_INTERFACE:...>    = content of "..." when the property is exported using export(), or when the target is used by another target in the same buildsystem. Expands to the empty string otherwise.
1751                $<C_COMPILER_ID>          = The CMake-id of the C compiler used.
1752                $<C_COMPILER_ID:comp>     = '1' if the CMake-id of the C compiler matches comp, otherwise '0'.
1753                $<CXX_COMPILER_ID>        = The CMake-id of the CXX compiler used.
1754                $<CXX_COMPILER_ID:comp>   = '1' if the CMake-id of the CXX compiler matches comp, otherwise '0'.
1755                $<VERSION_GREATER:v1,v2>  = '1' if v1 is a version greater than v2, else '0'.
1756                $<VERSION_LESS:v1,v2>     = '1' if v1 is a version less than v2, else '0'.
1757                $<VERSION_EQUAL:v1,v2>    = '1' if v1 is the same version as v2, else '0'.
1758                $<C_COMPILER_VERSION>     = The version of the C compiler used.
1759                $<C_COMPILER_VERSION:ver> = '1' if the version of the C compiler matches ver, otherwise '0'.
1760                $<CXX_COMPILER_VERSION>   = The version of the CXX compiler used.
1761                $<CXX_COMPILER_VERSION:ver> = '1' if the version of the CXX compiler matches ver, otherwise '0'.
1762                $<TARGET_FILE:tgt>        = main file (.exe, .so.1.2, .a)
1763                $<TARGET_LINKER_FILE:tgt> = file used to link (.a, .lib, .so)
1764                $<TARGET_SONAME_FILE:tgt> = file with soname (.so.3)
1765
1766              where  "tgt"  is  the name of a target.  Target file expressions
1767              produce a full path, but _DIR and _NAME versions can produce the
1768              directory and file name components:
1769
1770
1771                $<TARGET_FILE_DIR:tgt>/$<TARGET_FILE_NAME:tgt>
1772                $<TARGET_LINKER_FILE_DIR:tgt>/$<TARGET_LINKER_FILE_NAME:tgt>
1773                $<TARGET_SONAME_FILE_DIR:tgt>/$<TARGET_SONAME_FILE_NAME:tgt>
1774
1775
1776
1777
1778                $<TARGET_PROPERTY:tgt,prop>   = The value of the property prop on the target tgt.
1779
1780              Note  that  tgt  is not added as a dependency of the target this
1781              expression is evaluated on.
1782
1783
1784                $<TARGET_POLICY:pol>          = '1' if the policy was NEW when the 'head' target was created, else '0'.  If the policy was not set, the warning message for the policy will be emitted.  This generator expression only works for a subset of policies.
1785                $<INSTALL_PREFIX>         = Content of the install prefix when the target is exported via INSTALL(EXPORT) and empty otherwise.
1786
1787              Boolean expressions:
1788
1789
1790                $<AND:?[,?]...>           = '1' if all '?' are '1', else '0'
1791                $<OR:?[,?]...>            = '0' if all '?' are '0', else '1'
1792                $<NOT:?>                  = '0' if '?' is '1', else '1'
1793
1794              where '?' is always either '0' or '1'.
1795
1796
1797              Expressions with an implicit 'this' target:
1798
1799
1800                $<TARGET_PROPERTY:prop>   = The value of the property prop on the target on which the generator expression is evaluated.
1801
1802
1803       INTERFACE_LINK_LIBRARIES
1804              List public interface libraries for a library.
1805
1806              This property contains the list of transitive link dependencies.
1807              When  the  target  is  linked  into another target the libraries
1808              listed (and recursively their link interface libraries) will  be
1809              provided  to the other target also.  This property is overridden
1810              by     the     LINK_INTERFACE_LIBRARIES      or      LINK_INTER‐
1811              FACE_LIBRARIES_<CONFIG>  property  if  policy  CMP0022 is OLD or
1812              unset.
1813
1814
1815
1816
1817
1818              Generator expressions are evaluated during build system  genera‐
1819              tion  to  produce  information specific to each build configura‐
1820              tion.  Valid expressions are:
1821
1822
1823                $<0:...>                  = empty string (ignores "...")
1824                $<1:...>                  = content of "..."
1825                $<CONFIG:cfg>             = '1' if config is "cfg", else '0'
1826                $<CONFIGURATION>          = configuration name
1827                $<BOOL:...>               = '1' if the '...' is true, else '0'
1828                $<STREQUAL:a,b>           = '1' if a is STREQUAL b, else '0'
1829                $<ANGLE-R>                = A literal '>'. Used to compare strings which contain a '>' for example.
1830                $<COMMA>                  = A literal ','. Used to compare strings which contain a ',' for example.
1831                $<SEMICOLON>              = A literal ';'. Used to prevent list expansion on an argument with ';'.
1832                $<JOIN:list,...>          = joins the list with the content of "..."
1833                $<TARGET_NAME:...>        = Marks ... as being the name of a target.  This is required if exporting targets to multiple dependent export sets.  The '...' must be a literal name of a target- it may not contain generator expressions.
1834                $<INSTALL_INTERFACE:...>  = content of "..." when the property is exported using install(EXPORT), and empty otherwise.
1835                $<BUILD_INTERFACE:...>    = content of "..." when the property is exported using export(), or when the target is used by another target in the same buildsystem. Expands to the empty string otherwise.
1836                $<C_COMPILER_ID>          = The CMake-id of the C compiler used.
1837                $<C_COMPILER_ID:comp>     = '1' if the CMake-id of the C compiler matches comp, otherwise '0'.
1838                $<CXX_COMPILER_ID>        = The CMake-id of the CXX compiler used.
1839                $<CXX_COMPILER_ID:comp>   = '1' if the CMake-id of the CXX compiler matches comp, otherwise '0'.
1840                $<VERSION_GREATER:v1,v2>  = '1' if v1 is a version greater than v2, else '0'.
1841                $<VERSION_LESS:v1,v2>     = '1' if v1 is a version less than v2, else '0'.
1842                $<VERSION_EQUAL:v1,v2>    = '1' if v1 is the same version as v2, else '0'.
1843                $<C_COMPILER_VERSION>     = The version of the C compiler used.
1844                $<C_COMPILER_VERSION:ver> = '1' if the version of the C compiler matches ver, otherwise '0'.
1845                $<CXX_COMPILER_VERSION>   = The version of the CXX compiler used.
1846                $<CXX_COMPILER_VERSION:ver> = '1' if the version of the CXX compiler matches ver, otherwise '0'.
1847                $<TARGET_FILE:tgt>        = main file (.exe, .so.1.2, .a)
1848                $<TARGET_LINKER_FILE:tgt> = file used to link (.a, .lib, .so)
1849                $<TARGET_SONAME_FILE:tgt> = file with soname (.so.3)
1850
1851              where "tgt" is the name of a target.   Target  file  expressions
1852              produce a full path, but _DIR and _NAME versions can produce the
1853              directory and file name components:
1854
1855
1856                $<TARGET_FILE_DIR:tgt>/$<TARGET_FILE_NAME:tgt>
1857                $<TARGET_LINKER_FILE_DIR:tgt>/$<TARGET_LINKER_FILE_NAME:tgt>
1858                $<TARGET_SONAME_FILE_DIR:tgt>/$<TARGET_SONAME_FILE_NAME:tgt>
1859
1860
1861
1862
1863                $<TARGET_PROPERTY:tgt,prop>   = The value of the property prop on the target tgt.
1864
1865              Note that tgt is not added as a dependency of  the  target  this
1866              expression is evaluated on.
1867
1868
1869                $<TARGET_POLICY:pol>          = '1' if the policy was NEW when the 'head' target was created, else '0'.  If the policy was not set, the warning message for the policy will be emitted.  This generator expression only works for a subset of policies.
1870                $<INSTALL_PREFIX>         = Content of the install prefix when the target is exported via INSTALL(EXPORT) and empty otherwise.
1871
1872              Boolean expressions:
1873
1874
1875                $<AND:?[,?]...>           = '1' if all '?' are '1', else '0'
1876                $<OR:?[,?]...>            = '0' if all '?' are '0', else '1'
1877                $<NOT:?>                  = '0' if '?' is '1', else '1'
1878
1879              where '?' is always either '0' or '1'.
1880
1881
1882              Expressions with an implicit 'this' target:
1883
1884
1885                $<TARGET_PROPERTY:prop>   = The value of the property prop on the target on which the generator expression is evaluated.
1886
1887
1888       INTERFACE_POSITION_INDEPENDENT_CODE
1889              Whether consumers need to create a position-independent target
1890
1891              The  INTERFACE_POSITION_INDEPENDENT_CODE  property  informs con‐
1892              sumers of this target whether they must set their POSITION_INDE‐
1893              PENDENT_CODE  property  to  ON.   If this property is set to ON,
1894              then the POSITION_INDEPENDENT_CODE  property  on  all  consumers
1895              will  be  set to ON.  Similarly, if this property is set to OFF,
1896              then the POSITION_INDEPENDENT_CODE  property  on  all  consumers
1897              will  be  set  to OFF.  If this property is undefined, then con‐
1898              sumers will determine their  POSITION_INDEPENDENT_CODE  property
1899              by  other  means.   Consumers  must ensure that the targets that
1900              they link to have a  consistent  requirement  for  their  INTER‐
1901              FACE_POSITION_INDEPENDENT_CODE property.
1902
1903
1904       INTERFACE_SYSTEM_INCLUDE_DIRECTORIES
1905              List of public system include directories for a library.
1906
1907              Targets may populate this property to publish the include direc‐
1908              tories which contain system headers, and  therefore  should  not
1909              result  in  compiler warnings.  Consuming targets will then mark
1910              the same include directories as system headers.
1911
1912
1913              Generator expressions are evaluated during build system  genera‐
1914              tion  to  produce  information specific to each build configura‐
1915              tion.  Valid expressions are:
1916
1917
1918                $<0:...>                  = empty string (ignores "...")
1919                $<1:...>                  = content of "..."
1920                $<CONFIG:cfg>             = '1' if config is "cfg", else '0'
1921                $<CONFIGURATION>          = configuration name
1922                $<BOOL:...>               = '1' if the '...' is true, else '0'
1923                $<STREQUAL:a,b>           = '1' if a is STREQUAL b, else '0'
1924                $<ANGLE-R>                = A literal '>'. Used to compare strings which contain a '>' for example.
1925                $<COMMA>                  = A literal ','. Used to compare strings which contain a ',' for example.
1926                $<SEMICOLON>              = A literal ';'. Used to prevent list expansion on an argument with ';'.
1927                $<JOIN:list,...>          = joins the list with the content of "..."
1928                $<TARGET_NAME:...>        = Marks ... as being the name of a target.  This is required if exporting targets to multiple dependent export sets.  The '...' must be a literal name of a target- it may not contain generator expressions.
1929                $<INSTALL_INTERFACE:...>  = content of "..." when the property is exported using install(EXPORT), and empty otherwise.
1930                $<BUILD_INTERFACE:...>    = content of "..." when the property is exported using export(), or when the target is used by another target in the same buildsystem. Expands to the empty string otherwise.
1931                $<C_COMPILER_ID>          = The CMake-id of the C compiler used.
1932                $<C_COMPILER_ID:comp>     = '1' if the CMake-id of the C compiler matches comp, otherwise '0'.
1933                $<CXX_COMPILER_ID>        = The CMake-id of the CXX compiler used.
1934                $<CXX_COMPILER_ID:comp>   = '1' if the CMake-id of the CXX compiler matches comp, otherwise '0'.
1935                $<VERSION_GREATER:v1,v2>  = '1' if v1 is a version greater than v2, else '0'.
1936                $<VERSION_LESS:v1,v2>     = '1' if v1 is a version less than v2, else '0'.
1937                $<VERSION_EQUAL:v1,v2>    = '1' if v1 is the same version as v2, else '0'.
1938                $<C_COMPILER_VERSION>     = The version of the C compiler used.
1939                $<C_COMPILER_VERSION:ver> = '1' if the version of the C compiler matches ver, otherwise '0'.
1940                $<CXX_COMPILER_VERSION>   = The version of the CXX compiler used.
1941                $<CXX_COMPILER_VERSION:ver> = '1' if the version of the CXX compiler matches ver, otherwise '0'.
1942                $<TARGET_FILE:tgt>        = main file (.exe, .so.1.2, .a)
1943                $<TARGET_LINKER_FILE:tgt> = file used to link (.a, .lib, .so)
1944                $<TARGET_SONAME_FILE:tgt> = file with soname (.so.3)
1945
1946              where "tgt" is the name of a target.   Target  file  expressions
1947              produce a full path, but _DIR and _NAME versions can produce the
1948              directory and file name components:
1949
1950
1951                $<TARGET_FILE_DIR:tgt>/$<TARGET_FILE_NAME:tgt>
1952                $<TARGET_LINKER_FILE_DIR:tgt>/$<TARGET_LINKER_FILE_NAME:tgt>
1953                $<TARGET_SONAME_FILE_DIR:tgt>/$<TARGET_SONAME_FILE_NAME:tgt>
1954
1955
1956
1957
1958                $<TARGET_PROPERTY:tgt,prop>   = The value of the property prop on the target tgt.
1959
1960              Note that tgt is not added as a dependency of  the  target  this
1961              expression is evaluated on.
1962
1963
1964                $<TARGET_POLICY:pol>          = '1' if the policy was NEW when the 'head' target was created, else '0'.  If the policy was not set, the warning message for the policy will be emitted.  This generator expression only works for a subset of policies.
1965                $<INSTALL_PREFIX>         = Content of the install prefix when the target is exported via INSTALL(EXPORT) and empty otherwise.
1966
1967              Boolean expressions:
1968
1969
1970                $<AND:?[,?]...>           = '1' if all '?' are '1', else '0'
1971                $<OR:?[,?]...>            = '0' if all '?' are '0', else '1'
1972                $<NOT:?>                  = '0' if '?' is '1', else '1'
1973
1974              where '?' is always either '0' or '1'.
1975
1976
1977              Expressions with an implicit 'this' target:
1978
1979
1980                $<TARGET_PROPERTY:prop>   = The value of the property prop on the target on which the generator expression is evaluated.
1981
1982
1983       INTERPROCEDURAL_OPTIMIZATION
1984              Enable interprocedural optimization for a target.
1985
1986              If  set  to  true, enables interprocedural optimizations if they
1987              are known to be supported by the compiler.
1988
1989
1990       INTERPROCEDURAL_OPTIMIZATION_<CONFIG>
1991              Per-configuration interprocedural optimization for a target.
1992
1993              This is a per-configuration version of INTERPROCEDURAL_OPTIMIZA‐
1994              TION.   If set, this property overrides the generic property for
1995              the named configuration.
1996
1997
1998       LABELS Specify a list of text labels associated with a target.
1999
2000              Target label semantics are currently unspecified.
2001
2002
2003       LIBRARY_OUTPUT_DIRECTORY
2004              Output directory in which to build LIBRARY target files.
2005
2006              This property specifies the directory into which library  target
2007              files  should  be  built.  Multi-configuration  generators  (VS,
2008              Xcode) append a per-configuration subdirectory to the  specified
2009              directory.   There  are  three kinds of target files that may be
2010              built: archive, library, and runtime.   Executables  are  always
2011              treated  as runtime targets. Static libraries are always treated
2012              as archive targets.  Module  libraries  are  always  treated  as
2013              library  targets.  For  non-DLL  platforms  shared libraries are
2014              treated as library targets. For DLL platforms the DLL part of  a
2015              shared  library  is  treated  as a runtime target and the corre‐
2016              sponding import library is treated as  an  archive  target.  All
2017              Windows-based  systems including Cygwin are DLL platforms.  This
2018              property  is  initialized  by  the   value   of   the   variable
2019              CMAKE_LIBRARY_OUTPUT_DIRECTORY  if  it  is  set when a target is
2020              created.
2021
2022
2023       LIBRARY_OUTPUT_DIRECTORY_<CONFIG>
2024              Per-configuration output directory for LIBRARY target files.
2025
2026              This is a per-configuration version of LIBRARY_OUTPUT_DIRECTORY,
2027              but  multi-configuration  generators (VS, Xcode) do NOT append a
2028              per-configuration subdirectory to the specified directory.  This
2029              property   is   initialized   by   the  value  of  the  variable
2030              CMAKE_LIBRARY_OUTPUT_DIRECTORY_<CONFIG> if it is set when a tar‐
2031              get is created.
2032
2033
2034       LIBRARY_OUTPUT_NAME
2035              Output name for LIBRARY target files.
2036
2037              This  property specifies the base name for library target files.
2038              It overrides OUTPUT_NAME  and  OUTPUT_NAME_<CONFIG>  properties.
2039              There  are  three  kinds  of target files that may be built: ar‐
2040              chive, library, and runtime.  Executables are always treated  as
2041              runtime  targets. Static libraries are always treated as archive
2042              targets. Module libraries are always treated as library targets.
2043              For  non-DLL  platforms  shared libraries are treated as library
2044              targets. For DLL platforms the DLL part of a shared  library  is
2045              treated as a runtime target and the corresponding import library
2046              is treated as  an  archive  target.  All  Windows-based  systems
2047              including Cygwin are DLL platforms.
2048
2049
2050       LIBRARY_OUTPUT_NAME_<CONFIG>
2051              Per-configuration output name for LIBRARY target files.
2052
2053              This  is  the  configuration-specific  version  of  LIBRARY_OUT‐
2054              PUT_NAME.
2055
2056
2057       LINKER_LANGUAGE
2058              Specifies language whose compiler will invoke the linker.
2059
2060              For executables, shared libraries, and modules,  this  sets  the
2061              language  whose compiler is used to link the target (such as "C"
2062              or "CXX").  A typical value for an executable is the language of
2063              the  source  file  providing the program entry point (main).  If
2064              not set, the language with the highest linker  preference  value
2065              is  the default.  See documentation of CMAKE_<LANG>_LINKER_PREF‐
2066              ERENCE variables.
2067
2068
2069              If this property is not set by the user, it will  be  calculated
2070              at generate-time by CMake.
2071
2072
2073       LINK_DEPENDS
2074              Additional files on which a target binary depends for linking.
2075
2076              Specifies  a  semicolon-separated list of full-paths to files on
2077              which the link rule for this target depends.  The target  binary
2078              will be linked if any of the named files is newer than it.
2079
2080
2081              This  property  is  ignored  by  non-Makefile generators.  It is
2082              intended to specify dependencies on "linker scripts" for  custom
2083              Makefile link rules.
2084
2085
2086       LINK_DEPENDS_NO_SHARED
2087              Do not depend on linked shared library files.
2088
2089              Set  this  property  to true to tell CMake generators not to add
2090              file-level dependencies on the shared library  files  linked  by
2091              this  target.   Modification to the shared libraries will not be
2092              sufficient to re-link this target.  Logical target-level  depen‐
2093              dencies will not be affected so the linked shared libraries will
2094              still be brought up to date before this target is built.
2095
2096
2097              This property is  initialized  by  the  value  of  the  variable
2098              CMAKE_LINK_DEPENDS_NO_SHARED  if it is set when a target is cre‐
2099              ated.
2100
2101
2102       LINK_FLAGS
2103              Additional flags to use when linking this target.
2104
2105              The LINK_FLAGS property can be used to add extra  flags  to  the
2106              link  step of a target. LINK_FLAGS_<CONFIG> will add to the con‐
2107              figuration <CONFIG>, for example,  DEBUG,  RELEASE,  MINSIZEREL,
2108              RELWITHDEBINFO.
2109
2110
2111       LINK_FLAGS_<CONFIG>
2112              Per-configuration linker flags for a target.
2113
2114              This is the configuration-specific version of LINK_FLAGS.
2115
2116
2117       LINK_INTERFACE_LIBRARIES
2118              List  public  interface  libraries  for a shared library or exe‐
2119              cutable.
2120
2121              By default linking to a shared library target transitively links
2122              to  targets  with  which  the library itself was linked.  For an
2123              executable with exports (see  the  ENABLE_EXPORTS  property)  no
2124              default  transitive  link  dependencies are used.  This property
2125              replaces  the  default  transitive  link  dependencies  with  an
2126              explicit  list.   When  the target is linked into another target
2127              the libraries  listed  (and  recursively  their  link  interface
2128              libraries)  will  be  provided to the other target also.  If the
2129              list is empty then  no  transitive  link  dependencies  will  be
2130              incorporated when this target is linked into another target even
2131              if the default set is non-empty.  This property  is  initialized
2132              by  the  value of the variable CMAKE_LINK_INTERFACE_LIBRARIES if
2133              it is set when a target is created.  This  property  is  ignored
2134              for STATIC libraries.
2135
2136
2137              This  property  is  overridden  by  the INTERFACE_LINK_LIBRARIES
2138              property if policy CMP0022 is NEW.
2139
2140
2141              This  property  is  deprecated.   Use   INTERFACE_LINK_LIBRARIES
2142              instead.
2143
2144
2145       LINK_INTERFACE_LIBRARIES_<CONFIG>
2146              Per-configuration  list of public interface libraries for a tar‐
2147              get.
2148
2149              This  is  the  configuration-specific  version  of   LINK_INTER‐
2150              FACE_LIBRARIES.   If set, this property completely overrides the
2151              generic property for the named configuration.
2152
2153
2154              This property  is  overridden  by  the  INTERFACE_LINK_LIBRARIES
2155              property if policy CMP0022 is NEW.
2156
2157
2158              This   property   is  deprecated.  Use  INTERFACE_LINK_LIBRARIES
2159              instead.
2160
2161
2162       LINK_INTERFACE_MULTIPLICITY
2163              Repetition count for STATIC libraries with cyclic dependencies.
2164
2165              When linking to a STATIC library target with cyclic dependencies
2166              the  linker may need to scan more than once through the archives
2167              in the strongly connected component  of  the  dependency  graph.
2168              CMake  by  default  constructs  the link line so that the linker
2169              will scan through the component at least twice.   This  property
2170              specifies  the  minimum number of scans if it is larger than the
2171              default.  CMake uses the largest value specified by  any  target
2172              in a component.
2173
2174
2175       LINK_INTERFACE_MULTIPLICITY_<CONFIG>
2176              Per-configuration   repetition   count   for  cycles  of  STATIC
2177              libraries.
2178
2179              This  is  the  configuration-specific  version  of   LINK_INTER‐
2180              FACE_MULTIPLICITY.   If  set, this property completely overrides
2181              the generic property for the named configuration.
2182
2183
2184       LINK_LIBRARIES
2185              List of direct link dependencies.
2186
2187              This property specifies the list of libraries or  targets  which
2188              will  be  used for linking. In addition to accepting values from
2189              the target_link_libraries command, values may be set directly on
2190              any target using the set_property command.
2191
2192
2193              The target property values are used by the generators to set the
2194              link  libraries  for  the   compiler.    See   also   the   tar‐
2195              get_link_libraries command.
2196
2197
2198              Contents  of LINK_LIBRARIES may use "generator expressions" with
2199              the syntax "$<...>".  Generator expressions are evaluated during
2200              build  system generation to produce information specific to each
2201              build configuration.  Valid expressions are:
2202
2203
2204                $<0:...>                  = empty string (ignores "...")
2205                $<1:...>                  = content of "..."
2206                $<CONFIG:cfg>             = '1' if config is "cfg", else '0'
2207                $<CONFIGURATION>          = configuration name
2208                $<BOOL:...>               = '1' if the '...' is true, else '0'
2209                $<STREQUAL:a,b>           = '1' if a is STREQUAL b, else '0'
2210                $<ANGLE-R>                = A literal '>'. Used to compare strings which contain a '>' for example.
2211                $<COMMA>                  = A literal ','. Used to compare strings which contain a ',' for example.
2212                $<SEMICOLON>              = A literal ';'. Used to prevent list expansion on an argument with ';'.
2213                $<JOIN:list,...>          = joins the list with the content of "..."
2214                $<TARGET_NAME:...>        = Marks ... as being the name of a target.  This is required if exporting targets to multiple dependent export sets.  The '...' must be a literal name of a target- it may not contain generator expressions.
2215                $<INSTALL_INTERFACE:...>  = content of "..." when the property is exported using install(EXPORT), and empty otherwise.
2216                $<BUILD_INTERFACE:...>    = content of "..." when the property is exported using export(), or when the target is used by another target in the same buildsystem. Expands to the empty string otherwise.
2217                $<C_COMPILER_ID>          = The CMake-id of the C compiler used.
2218                $<C_COMPILER_ID:comp>     = '1' if the CMake-id of the C compiler matches comp, otherwise '0'.
2219                $<CXX_COMPILER_ID>        = The CMake-id of the CXX compiler used.
2220                $<CXX_COMPILER_ID:comp>   = '1' if the CMake-id of the CXX compiler matches comp, otherwise '0'.
2221                $<VERSION_GREATER:v1,v2>  = '1' if v1 is a version greater than v2, else '0'.
2222                $<VERSION_LESS:v1,v2>     = '1' if v1 is a version less than v2, else '0'.
2223                $<VERSION_EQUAL:v1,v2>    = '1' if v1 is the same version as v2, else '0'.
2224                $<C_COMPILER_VERSION>     = The version of the C compiler used.
2225                $<C_COMPILER_VERSION:ver> = '1' if the version of the C compiler matches ver, otherwise '0'.
2226                $<CXX_COMPILER_VERSION>   = The version of the CXX compiler used.
2227                $<CXX_COMPILER_VERSION:ver> = '1' if the version of the CXX compiler matches ver, otherwise '0'.
2228                $<TARGET_FILE:tgt>        = main file (.exe, .so.1.2, .a)
2229                $<TARGET_LINKER_FILE:tgt> = file used to link (.a, .lib, .so)
2230                $<TARGET_SONAME_FILE:tgt> = file with soname (.so.3)
2231
2232              where "tgt" is the name of a target.   Target  file  expressions
2233              produce a full path, but _DIR and _NAME versions can produce the
2234              directory and file name components:
2235
2236
2237                $<TARGET_FILE_DIR:tgt>/$<TARGET_FILE_NAME:tgt>
2238                $<TARGET_LINKER_FILE_DIR:tgt>/$<TARGET_LINKER_FILE_NAME:tgt>
2239                $<TARGET_SONAME_FILE_DIR:tgt>/$<TARGET_SONAME_FILE_NAME:tgt>
2240
2241
2242
2243
2244                $<TARGET_PROPERTY:tgt,prop>   = The value of the property prop on the target tgt.
2245
2246              Note that tgt is not added as a dependency of  the  target  this
2247              expression is evaluated on.
2248
2249
2250                $<TARGET_POLICY:pol>          = '1' if the policy was NEW when the 'head' target was created, else '0'.  If the policy was not set, the warning message for the policy will be emitted.  This generator expression only works for a subset of policies.
2251                $<INSTALL_PREFIX>         = Content of the install prefix when the target is exported via INSTALL(EXPORT) and empty otherwise.
2252
2253              Boolean expressions:
2254
2255
2256                $<AND:?[,?]...>           = '1' if all '?' are '1', else '0'
2257                $<OR:?[,?]...>            = '0' if all '?' are '0', else '1'
2258                $<NOT:?>                  = '0' if '?' is '1', else '1'
2259
2260              where '?' is always either '0' or '1'.
2261
2262
2263              Expressions with an implicit 'this' target:
2264
2265
2266                $<TARGET_PROPERTY:prop>   = The value of the property prop on the target on which the generator expression is evaluated.
2267
2268
2269       LINK_SEARCH_END_STATIC
2270              End a link line such that static system libraries are used.
2271
2272              Some  linkers support switches such as -Bstatic and -Bdynamic to
2273              determine whether to use static or shared  libraries  for  -lXXX
2274              options.   CMake  uses  these  options  to set the link type for
2275              libraries whose full paths are not known or (in some cases)  are
2276              in implicit link directories for the platform.  By default CMake
2277              adds an option at the end of the library list (if necessary)  to
2278              set  the  linker  search  type  back to its starting type.  This
2279              property switches the  final  linker  search  type  to  -Bstatic
2280              regardless      of     how     it     started.      See     also
2281              LINK_SEARCH_START_STATIC.
2282
2283
2284       LINK_SEARCH_START_STATIC
2285              Assume the linker looks for static libraries by default.
2286
2287              Some linkers support switches such as -Bstatic and -Bdynamic  to
2288              determine  whether  to  use static or shared libraries for -lXXX
2289              options.  CMake uses these options to  set  the  link  type  for
2290              libraries  whose full paths are not known or (in some cases) are
2291              in implicit link directories for the platform.  By  default  the
2292              linker  search  type is assumed to be -Bdynamic at the beginning
2293              of the library list.  This property switches the  assumption  to
2294              -Bstatic.   It  is  intended  for use when linking an executable
2295              statically  (e.g.  with  the  GNU  -static  option).   See  also
2296              LINK_SEARCH_END_STATIC.
2297
2298
2299       LOCATION
2300              Read-only location of a target on disk.
2301
2302              For  an  imported  target,  this  read-only property returns the
2303              value of the LOCATION_<CONFIG> property for an unspecified  con‐
2304              figuration <CONFIG> provided by the target.
2305
2306
2307              For a non-imported target, this property is provided for compat‐
2308              ibility with CMake 2.4 and below.  It was meant to get the loca‐
2309              tion  of  an executable target's output file for use in add_cus‐
2310              tom_command.  The path may contain a build-system-specific  por‐
2311              tion  that is replaced at build time with the configuration get‐
2312              ting built (such as "$(ConfigurationName)" in VS). In CMake  2.6
2313              and  above  add_custom_command automatically recognizes a target
2314              name in its COMMAND and DEPENDS options and computes the  target
2315              location.   In  CMake  2.8.4 and above add_custom_command recog‐
2316              nizes generator expressions to refer to  target  locations  any‐
2317              where in the command.  Therefore this property is not needed for
2318              creating custom commands.
2319
2320
2321              Do not set properties that affect the location of a target after
2322              reading  this  property.   These  include properties whose names
2323              match  "(RUNTIME|LIBRARY|ARCHIVE)_OUTPUT_(NAME|DIRECTORY)(_<CON‐
2324              FIG>)?",   "(IMPLIB_)?(PREFIX|SUFFIX)",   or  "LINKER_LANGUAGE".
2325              Failure to follow this rule is  not  diagnosed  and  leaves  the
2326              location of the target undefined.
2327
2328
2329       LOCATION_<CONFIG>
2330              Read-only property providing a target location on disk.
2331
2332              A  read-only  property that indicates where a target's main file
2333              is located on disk for the configuration <CONFIG>.  The property
2334              is defined only for library and executable targets.  An imported
2335              target may provide a set of configurations different  from  that
2336              of  the  importing  project.   By  default  CMake  looks  for an
2337              exact-match but otherwise uses an arbitrary available configura‐
2338              tion.   Use  the  MAP_IMPORTED_CONFIG_<CONFIG>  property  to map
2339              imported configurations explicitly.
2340
2341
2342              Do not set properties that affect the location of a target after
2343              reading  this  property.   These  include properties whose names
2344              match  "(RUNTIME|LIBRARY|ARCHIVE)_OUTPUT_(NAME|DIRECTORY)(_<CON‐
2345              FIG>)?",   "(IMPLIB_)?(PREFIX|SUFFIX)",   or  "LINKER_LANGUAGE".
2346              Failure to follow this rule is  not  diagnosed  and  leaves  the
2347              location of the target undefined.
2348
2349
2350       MACOSX_BUNDLE
2351              Build an executable as an application bundle on Mac OS X.
2352
2353              When  this  property is set to true the executable when built on
2354              Mac OS X will be created as an application bundle.   This  makes
2355              it  a  GUI executable that can be launched from the Finder.  See
2356              the MACOSX_BUNDLE_INFO_PLIST  target  property  for  information
2357              about  creation  of the Info.plist file for the application bun‐
2358              dle.  This property is initialized by the value of the  variable
2359              CMAKE_MACOSX_BUNDLE if it is set when a target is created.
2360
2361
2362       MACOSX_BUNDLE_INFO_PLIST
2363              Specify a custom Info.plist template for a Mac OS X App Bundle.
2364
2365              An executable target with MACOSX_BUNDLE enabled will be built as
2366              an application bundle on Mac OS X.  By  default  its  Info.plist
2367              file  is  created by configuring a template called MacOSXBundle‐
2368              Info.plist.in located in the CMAKE_MODULE_PATH.   This  property
2369              specifies  an alternative template file name which may be a full
2370              path.
2371
2372
2373              The following target properties may be set to specify content to
2374              be configured into the file:
2375
2376
2377                MACOSX_BUNDLE_INFO_STRING
2378                MACOSX_BUNDLE_ICON_FILE
2379                MACOSX_BUNDLE_GUI_IDENTIFIER
2380                MACOSX_BUNDLE_LONG_VERSION_STRING
2381                MACOSX_BUNDLE_BUNDLE_NAME
2382                MACOSX_BUNDLE_SHORT_VERSION_STRING
2383                MACOSX_BUNDLE_BUNDLE_VERSION
2384                MACOSX_BUNDLE_COPYRIGHT
2385
2386              CMake  variables  of the same name may be set to affect all tar‐
2387              gets in a directory that do not have each specific property set.
2388              If  a  custom Info.plist is specified by this property it may of
2389              course hard-code all the settings instead of  using  the  target
2390              properties.
2391
2392
2393       MACOSX_FRAMEWORK_INFO_PLIST
2394              Specify a custom Info.plist template for a Mac OS X Framework.
2395
2396              A  library  target  with  FRAMEWORK  enabled  will be built as a
2397              framework on Mac OS X.  By default its Info.plist file  is  cre‐
2398              ated   by   configuring   a   template  called  MacOSXFramework‐
2399              Info.plist.in located in the CMAKE_MODULE_PATH.   This  property
2400              specifies  an alternative template file name which may be a full
2401              path.
2402
2403
2404              The following target properties may be set to specify content to
2405              be configured into the file:
2406
2407
2408                MACOSX_FRAMEWORK_ICON_FILE
2409                MACOSX_FRAMEWORK_IDENTIFIER
2410                MACOSX_FRAMEWORK_SHORT_VERSION_STRING
2411                MACOSX_FRAMEWORK_BUNDLE_VERSION
2412
2413              CMake  variables  of the same name may be set to affect all tar‐
2414              gets in a directory that do not have each specific property set.
2415              If  a  custom Info.plist is specified by this property it may of
2416              course hard-code all the settings instead of  using  the  target
2417              properties.
2418
2419
2420       MACOSX_RPATH
2421              Whether to use rpaths on Mac OS X.
2422
2423              When  this  property  is  set  to true, the directory portion of
2424              the"install_name" field of  shared  libraries  will  default  to
2425              "@rpath".Runtime  paths  will also be embedded in binaries using
2426              this target.This property is initialized by  the  value  of  the
2427              variable  CMAKE_MACOSX_RPATH  if it is set when a target is cre‐
2428              ated.
2429
2430
2431       MAP_IMPORTED_CONFIG_<CONFIG>
2432              Map from project configuration to IMPORTED  target's  configura‐
2433              tion.
2434
2435              Set  this  to  the  list of configurations of an imported target
2436              that may be used for the current project's  <CONFIG>  configura‐
2437              tion.  Targets imported from another project may not provide the
2438              same  set  of  configuration  names  available  in  the  current
2439              project.   Setting  this property tells CMake what imported con‐
2440              figurations are suitable for use when building the <CONFIG> con‐
2441              figuration.   The  first  configuration  in the list found to be
2442              provided by the imported target is selected.  If  this  property
2443              is  set  and  no matching configurations are available, then the
2444              imported target is considered to be not found.  This property is
2445              ignored for non-imported targets.
2446
2447
2448       NAME   Logical name for the target.
2449
2450              Read-only logical name for the target as used by CMake.
2451
2452
2453       NO_SONAME
2454              Whether to set "soname" when linking a shared library or module.
2455
2456              Enable  this  boolean  property if a generated shared library or
2457              module should not have "soname" set. Default is to set  "soname"
2458              on all shared libraries and modules as long as the platform sup‐
2459              ports it. Generally, use this property  only  for  leaf  private
2460              libraries  or  plugins. If you use it on normal shared libraries
2461              which other targets link against, on  some  platforms  a  linker
2462              will  insert  a  full  path to the library (as specified at link
2463              time) into the dynamic section of the dependent  binary.  There‐
2464              fore,  once  installed,  dynamic  loader  may eventually fail to
2465              locate the library for the binary.
2466
2467
2468       OSX_ARCHITECTURES
2469              Target specific architectures for OS X.
2470
2471              The OSX_ARCHITECTURES property sets the target binary  architec‐
2472              ture  for  targets on OS X.  This property is initialized by the
2473              value of the variable CMAKE_OSX_ARCHITECTURES if it is set  when
2474              a  target is created.  Use OSX_ARCHITECTURES_<CONFIG> to set the
2475              binary architectures on a per-configuration basis.  <CONFIG>  is
2476              an upper-case name (ex: "OSX_ARCHITECTURES_DEBUG").
2477
2478
2479       OSX_ARCHITECTURES_<CONFIG>
2480              Per-configuration OS X binary architectures for a target.
2481
2482              This   property   is   the   configuration-specific  version  of
2483              OSX_ARCHITECTURES.
2484
2485
2486       OUTPUT_NAME
2487              Output name for target files.
2488
2489              This sets the base name for output files  created  for  an  exe‐
2490              cutable  or library target.  If not set, the logical target name
2491              is used by default.
2492
2493
2494       OUTPUT_NAME_<CONFIG>
2495              Per-configuration target file base name.
2496
2497              This is the configuration-specific version of OUTPUT_NAME.
2498
2499
2500       PDB_NAME
2501              Output name for MS debug symbols .pdb file from linker.
2502
2503              Set the base name for debug symbols file  created  for  an  exe‐
2504              cutable  or shared library target.  If not set, the logical tar‐
2505              get name is used by default.
2506
2507
2508              This property is not implemented by the Visual Studio 6  genera‐
2509              tor.
2510
2511
2512       PDB_NAME_<CONFIG>
2513              Per-configuration name for MS debug symbols .pdb file.
2514
2515              This is the configuration-specific version of PDB_NAME.
2516
2517
2518              This  property is not implemented by the Visual Studio 6 genera‐
2519              tor.
2520
2521
2522       PDB_OUTPUT_DIRECTORY
2523              Output directory for MS debug symbols .pdb file from linker.
2524
2525              This property specifies the directory into which  the  MS  debug
2526              symbols will be placed by the linker.  This property is initial‐
2527              ized by the value of the variable CMAKE_PDB_OUTPUT_DIRECTORY  if
2528              it is set when a target is created.
2529
2530
2531              This  property is not implemented by the Visual Studio 6 genera‐
2532              tor.
2533
2534
2535       PDB_OUTPUT_DIRECTORY_<CONFIG>
2536              Per-configuration output directory for  MS  debug  symbols  .pdb
2537              files.
2538
2539              This is a per-configuration version of PDB_OUTPUT_DIRECTORY, but
2540              multi-configuration generators  (VS,  Xcode)  do  NOT  append  a
2541              per-configuration  subdirectory to the specified directory. This
2542              property  is  initialized  by  the   value   of   the   variable
2543              CMAKE_PDB_OUTPUT_DIRECTORY_<CONFIG>  if  it is set when a target
2544              is created.
2545
2546
2547              This property is not implemented by the Visual Studio 6  genera‐
2548              tor.
2549
2550
2551       POSITION_INDEPENDENT_CODE
2552              Whether to create a position-independent target
2553
2554              The  POSITION_INDEPENDENT_CODE property determines whether posi‐
2555              tion independent executables or shared libraries  will  be  cre‐
2556              ated.   This  property  is true by default for SHARED and MODULE
2557              library targets and false otherwise.  This property is  initial‐
2558              ized  by  the  value  of  the  variable  CMAKE_POSITION_INDEPEN‐
2559              DENT_CODE if it is set when a target is created.
2560
2561
2562       POST_INSTALL_SCRIPT
2563              Deprecated install support.
2564
2565              The PRE_INSTALL_SCRIPT and  POST_INSTALL_SCRIPT  properties  are
2566              the  old  way  to  specify CMake scripts to run before and after
2567              installing  a  target.   They  are  used  only  when   the   old
2568              INSTALL_TARGETS  command is used to install the target.  Use the
2569              INSTALL command instead.
2570
2571
2572       PREFIX What comes before the library name.
2573
2574              A target property that can be set to override the  prefix  (such
2575              as "lib") on a library name.
2576
2577
2578       PRE_INSTALL_SCRIPT
2579              Deprecated install support.
2580
2581              The  PRE_INSTALL_SCRIPT  and  POST_INSTALL_SCRIPT properties are
2582              the old way to specify CMake scripts to  run  before  and  after
2583              installing   a   target.   They  are  used  only  when  the  old
2584              INSTALL_TARGETS command is used to install the target.  Use  the
2585              INSTALL command instead.
2586
2587
2588       PRIVATE_HEADER
2589              Specify  private header files in a FRAMEWORK shared library tar‐
2590              get.
2591
2592              Shared library targets marked with the FRAMEWORK property gener‐
2593              ate  frameworks  on  OS  X  and normal shared libraries on other
2594              platforms.  This property may be set to a list of  header  files
2595              to  be  placed in the PrivateHeaders directory inside the frame‐
2596              work folder.   On  non-Apple  platforms  these  headers  may  be
2597              installed  using  the  PRIVATE_HEADER option to the install(TAR‐
2598              GETS) command.
2599
2600
2601       PROJECT_LABEL
2602              Change the name of a target in an IDE.
2603
2604              Can be used to change the name of the target in an IDE like Vis‐
2605              ual Studio.
2606
2607
2608       PUBLIC_HEADER
2609              Specify  public  header files in a FRAMEWORK shared library tar‐
2610              get.
2611
2612              Shared library targets marked with the FRAMEWORK property gener‐
2613              ate  frameworks  on  OS  X  and normal shared libraries on other
2614              platforms.  This property may be set to a list of  header  files
2615              to  be  placed  in  the  Headers  directory inside the framework
2616              folder.  On non-Apple platforms these headers may  be  installed
2617              using the PUBLIC_HEADER option to the install(TARGETS) command.
2618
2619
2620       RESOURCE
2621              Specify resource files in a FRAMEWORK shared library target.
2622
2623              Shared library targets marked with the FRAMEWORK property gener‐
2624              ate frameworks on OS X and  normal  shared  libraries  on  other
2625              platforms.   This  property  may be set to a list of files to be
2626              placed in the Resources directory inside the  framework  folder.
2627              On  non-Apple  platforms  these files may be installed using the
2628              RESOURCE option to the install(TARGETS) command.
2629
2630
2631       RULE_LAUNCH_COMPILE
2632              Specify a launcher for compile rules.
2633
2634              See the global property of the  same  name  for  details.   This
2635              overrides the global and directory property for a target.
2636
2637
2638       RULE_LAUNCH_CUSTOM
2639              Specify a launcher for custom rules.
2640
2641              See  the  global  property  of  the same name for details.  This
2642              overrides the global and directory property for a target.
2643
2644
2645       RULE_LAUNCH_LINK
2646              Specify a launcher for link rules.
2647
2648              See the global property of the  same  name  for  details.   This
2649              overrides the global and directory property for a target.
2650
2651
2652       RUNTIME_OUTPUT_DIRECTORY
2653              Output directory in which to build RUNTIME target files.
2654
2655              This  property specifies the directory into which runtime target
2656              files  should  be  built.  Multi-configuration  generators  (VS,
2657              Xcode)  append a per-configuration subdirectory to the specified
2658              directory.  There are three kinds of target files  that  may  be
2659              built:  archive,  library,  and runtime.  Executables are always
2660              treated as runtime targets. Static libraries are always  treated
2661              as  archive  targets.  Module  libraries  are  always treated as
2662              library targets. For  non-DLL  platforms  shared  libraries  are
2663              treated  as library targets. For DLL platforms the DLL part of a
2664              shared library is treated as a runtime  target  and  the  corre‐
2665              sponding  import  library  is  treated as an archive target. All
2666              Windows-based systems including Cygwin are DLL platforms.   This
2667              property  is initialized by the value of the variable CMAKE_RUN‐
2668              TIME_OUTPUT_DIRECTORY if it is set when a target is created.
2669
2670
2671       RUNTIME_OUTPUT_DIRECTORY_<CONFIG>
2672              Per-configuration output directory for RUNTIME target files.
2673
2674              This is a per-configuration version of RUNTIME_OUTPUT_DIRECTORY,
2675              but  multi-configuration  generators (VS, Xcode) do NOT append a
2676              per-configuration subdirectory to the specified directory.  This
2677              property  is initialized by the value of the variable CMAKE_RUN‐
2678              TIME_OUTPUT_DIRECTORY_<CONFIG> if it is set  when  a  target  is
2679              created.
2680
2681
2682       RUNTIME_OUTPUT_NAME
2683              Output name for RUNTIME target files.
2684
2685              This  property specifies the base name for runtime target files.
2686              It overrides OUTPUT_NAME  and  OUTPUT_NAME_<CONFIG>  properties.
2687              There  are  three  kinds  of target files that may be built: ar‐
2688              chive, library, and runtime.  Executables are always treated  as
2689              runtime  targets. Static libraries are always treated as archive
2690              targets. Module libraries are always treated as library targets.
2691              For  non-DLL  platforms  shared libraries are treated as library
2692              targets. For DLL platforms the DLL part of a shared  library  is
2693              treated as a runtime target and the corresponding import library
2694              is treated as  an  archive  target.  All  Windows-based  systems
2695              including Cygwin are DLL platforms.
2696
2697
2698       RUNTIME_OUTPUT_NAME_<CONFIG>
2699              Per-configuration output name for RUNTIME target files.
2700
2701              This  is  the  configuration-specific  version  of  RUNTIME_OUT‐
2702              PUT_NAME.
2703
2704
2705       SKIP_BUILD_RPATH
2706              Should rpaths be used for the build tree.
2707
2708              SKIP_BUILD_RPATH is a boolean specifying whether to  skip  auto‐
2709              matic generation of an rpath allowing the target to run from the
2710              build tree.  This property is initialized by the  value  of  the
2711              variable  CMAKE_SKIP_BUILD_RPATH  if  it is set when a target is
2712              created.
2713
2714
2715       SOURCES
2716              Source names specified for a target.
2717
2718              Read-only list of sources specified for  a  target.   The  names
2719              returned  are suitable for passing to the set_source_files_prop‐
2720              erties command.
2721
2722
2723       SOVERSION
2724              What version number is this target.
2725
2726              For shared libraries VERSION and SOVERSION can be used to  spec‐
2727              ify  the build version and API version respectively. When build‐
2728              ing or installing appropriate symlinks are created if the  plat‐
2729              form supports symlinks and the linker supports so-names. If only
2730              one of both is specified the missing is assumed to have the same
2731              version  number.  SOVERSION  is ignored if NO_SONAME property is
2732              set. For shared libraries and executables on Windows the VERSION
2733              attribute  is  parsed to extract a "major.minor" version number.
2734              These numbers are used as the image version of the binary.
2735
2736
2737       STATIC_LIBRARY_FLAGS
2738              Extra flags to use when linking static libraries.
2739
2740              Extra flags to use when linking a static library.
2741
2742
2743       STATIC_LIBRARY_FLAGS_<CONFIG>
2744              Per-configuration flags for creating a static library.
2745
2746              This    is     the     configuration-specific     version     of
2747              STATIC_LIBRARY_FLAGS.
2748
2749
2750       SUFFIX What comes after the target name.
2751
2752              A  target  property that can be set to override the suffix (such
2753              as ".so" or ".exe") on the name of a  library,  module  or  exe‐
2754              cutable.
2755
2756
2757       TYPE   The type of the target.
2758
2759              This  read-only  property  can  be  used to test the type of the
2760              given target. It will be one of STATIC_LIBRARY,  MODULE_LIBRARY,
2761              SHARED_LIBRARY, EXECUTABLE or one of the internal target types.
2762
2763
2764       VERSION
2765              What version number is this target.
2766
2767              For  shared libraries VERSION and SOVERSION can be used to spec‐
2768              ify the build version and API version respectively. When  build‐
2769              ing  or installing appropriate symlinks are created if the plat‐
2770              form supports symlinks and the linker supports so-names. If only
2771              one of both is specified the missing is assumed to have the same
2772              version number. For executables VERSION can be used  to  specify
2773              the  build version. When building or installing appropriate sym‐
2774              links are created if the platform supports symlinks. For  shared
2775              libraries  and  executables  on Windows the VERSION attribute is
2776              parsed to extract a "major.minor" version number. These  numbers
2777              are used as the image version of the binary.
2778
2779
2780       VISIBILITY_INLINES_HIDDEN
2781              Whether  to  add  a compile flag to hide symbols of inline func‐
2782              tions
2783
2784              The VISIBILITY_INLINES_HIDDEN property determines whether a flag
2785              for  hiding  symbols for inline functions. the value passed used
2786              in a visibility related compile option, such  as  -fvisibility=.
2787              This  property  only has an affect for libraries and executables
2788              with exports.  This property is initialized by the value of  the
2789              variable  CMAKE_VISIBILITY_INLINES_HIDDEN  if  it  is set when a
2790              target is created.
2791
2792
2793       VS_DOTNET_REFERENCES
2794              Visual Studio managed project .NET references
2795
2796              Adds one or more semicolon-delimited .NET references to a gener‐
2797              ated  Visual  Studio  project.  For example, "System;System.Win‐
2798              dows.Forms".
2799
2800
2801       VS_DOTNET_TARGET_FRAMEWORK_VERSION
2802              Specify the .NET target framework version.
2803
2804              Used to specify the .NET target framework version  for  C++/CLI.
2805              For example, "v4.5".
2806
2807
2808       VS_GLOBAL_<variable>
2809              Visual Studio project-specific global variable.
2810
2811              Tell  the  Visual  Studio  generator  to set the global variable
2812              '<variable>' to a given value in  the  generated  Visual  Studio
2813              project.  Ignored on other generators. Qt integration works bet‐
2814              ter if VS_GLOBAL_QtVersion is set to the  version  FindQt4.cmake
2815              found. For example, "4.7.3"
2816
2817
2818       VS_GLOBAL_KEYWORD
2819              Visual Studio project keyword.
2820
2821              Sets  the  "keyword"  attribute  for  a  generated Visual Studio
2822              project. Defaults to "Win32Proj". You may wish to override  this
2823              value  with "ManagedCProj", for example, in a Visual Studio man‐
2824              aged C++ unit test project.
2825
2826
2827       VS_GLOBAL_PROJECT_TYPES
2828              Visual Studio project type(s).
2829
2830              Can be set to one or more UUIDs recognized by Visual  Studio  to
2831              indicate the type of project. This value is copied verbatim into
2832              the generated project file. Example for a managed C++ unit test‐
2833              ing project:
2834
2835
2836               {3AC096D0-A1C2-E12C-1390-A8335801FDAB};{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}
2837
2838              UUIDs are semicolon-delimited.
2839
2840
2841       VS_GLOBAL_ROOTNAMESPACE
2842              Visual Studio project root namespace.
2843
2844              Sets the "RootNamespace" attribute for a generated Visual Studio
2845              project.  The attribute will be generated only if this is set.
2846
2847
2848       VS_KEYWORD
2849              Visual Studio project keyword.
2850
2851              Can be set to change the visual studio keyword, for  example  Qt
2852              integration works better if this is set to Qt4VSv1.0.
2853
2854
2855       VS_SCC_AUXPATH
2856              Visual Studio Source Code Control Aux Path.
2857
2858              Can  be set to change the visual studio source code control aux‐
2859              path property.
2860
2861
2862       VS_SCC_LOCALPATH
2863              Visual Studio Source Code Control Local Path.
2864
2865              Can be set to change the visual studio source code control local
2866              path property.
2867
2868
2869       VS_SCC_PROJECTNAME
2870              Visual Studio Source Code Control Project.
2871
2872              Can  be  set  to  change  the  visual studio source code control
2873              project name property.
2874
2875
2876       VS_SCC_PROVIDER
2877              Visual Studio Source Code Control Provider.
2878
2879              Can be set to change  the  visual  studio  source  code  control
2880              provider property.
2881
2882
2883       VS_WINRT_EXTENSIONS
2884              Visual  Studio  project  C++/CX  language extensions for Windows
2885              Runtime
2886
2887              Can be set to enable C++/CX language extensions.
2888
2889
2890       VS_WINRT_REFERENCES
2891              Visual Studio project Windows Runtime Metadata references
2892
2893              Adds one or more semicolon-delimited WinRT references to a  gen‐
2894              erated   Visual   Studio  project.  For  example,  "Windows;Win‐
2895              dows.UI.Core".
2896
2897
2898       WIN32_EXECUTABLE
2899              Build an executable with a WinMain entry point on windows.
2900
2901              When this property is set to true the executable when linked  on
2902              Windows  will be created with a WinMain() entry point instead of
2903              just main().  This makes it a GUI executable instead of  a  con‐
2904              sole application.  See the CMAKE_MFC_FLAG variable documentation
2905              to configure use of MFC for WinMain executables.  This  property
2906              is  initialized  by  the  value of the variable CMAKE_WIN32_EXE‐
2907              CUTABLE if it is set when a target is created.
2908
2909
2910       XCODE_ATTRIBUTE_<an-attribute>
2911              Set Xcode target attributes directly.
2912
2913              Tell the Xcode generator to  set  '<an-attribute>'  to  a  given
2914              value  in the generated Xcode project.  Ignored on other genera‐
2915              tors.
2916
2917

PROPERTIES ON TESTS

2919       ATTACHED_FILES
2920              Attach a list of files to a dashboard submission.
2921
2922              Set this property to a list of files that will  be  encoded  and
2923              submitted to the dashboard as an addition to the test result.
2924
2925
2926       ATTACHED_FILES_ON_FAIL
2927              Attach  a  list  of  files to a dashboard submission if the test
2928              fails.
2929
2930              Same as ATTACHED_FILES, but these files will only be included if
2931              the test does not pass.
2932
2933
2934       COST   Set  this to a floating point value. Tests in a test set will be
2935              run in descending order of cost.
2936
2937              This property describes the cost of a test. You  can  explicitly
2938              set this value; tests with higher COST values will run first.
2939
2940
2941       DEPENDS
2942              Specifies  that this test should only be run after the specified
2943              list of tests.
2944
2945              Set this to a list of tests that must finish before this test is
2946              run.
2947
2948
2949       ENVIRONMENT
2950              Specify environment variables that should be defined for running
2951              a test.
2952
2953              If set to a list of environment variables and values of the form
2954              MYVAR=value  those  environment  variables will be defined while
2955              running the test. The environment is restored  to  its  previous
2956              state after the test is done.
2957
2958
2959       FAIL_REGULAR_EXPRESSION
2960              If  the  output  matches  this  regular expression the test will
2961              fail.
2962
2963              If set, if the output matches one of specified  regular  expres‐
2964              sions,  the  test will fail.For example: FAIL_REGULAR_EXPRESSION
2965              "[^a-z]Error;ERROR;Failed"
2966
2967
2968       LABELS Specify a list of text labels associated with a test.
2969
2970              The list is reported in dashboard submissions.
2971
2972
2973       MEASUREMENT
2974              Specify a CDASH measurement and value to be reported for a test.
2975
2976              If set to a name then that name will be reported to CDASH  as  a
2977              named  measurement  with  a  value  of 1. You may also specify a
2978              value by setting MEASUREMENT to "measurement=value".
2979
2980
2981       PASS_REGULAR_EXPRESSION
2982              The output must match this regular expression for  the  test  to
2983              pass.
2984
2985              If  set,  the  test output will be checked against the specified
2986              regular expressions and at least one of the regular  expressions
2987              has to match, otherwise the test will fail.
2988
2989
2990       PROCESSORS
2991              How many process slots this test requires
2992
2993              Denotes  the  number  of processors that this test will require.
2994              This is typically used for MPI tests, and should be used in con‐
2995              junction with the ctest_test PARALLEL_LEVEL option.
2996
2997
2998       REQUIRED_FILES
2999              List of files required to run the test.
3000
3001              If  set  to a list of files, the test will not be run unless all
3002              of the files exist.
3003
3004
3005       RESOURCE_LOCK
3006              Specify a list of resources that are locked by this test.
3007
3008              If multiple tests specify the same resource lock, they are guar‐
3009              anteed not to run concurrently.
3010
3011
3012       RUN_SERIAL
3013              Do not run this test in parallel with any other test.
3014
3015              Use  this  option  in  conjunction  with  the  ctest_test PARAL‐
3016              LEL_LEVEL option to specify that this test should not be run  in
3017              parallel with any other tests.
3018
3019
3020       TIMEOUT
3021              How many seconds to allow for this test.
3022
3023              This property if set will limit a test to not take more than the
3024              specified number of seconds to run. If it exceeds that the  test
3025              process  will  be  killed  and ctest will move to the next test.
3026              This setting takes precedence over CTEST_TESTING_TIMEOUT.
3027
3028
3029       WILL_FAIL
3030              If set to true, this will invert the pass/fail flag of the test.
3031
3032              This property can be used for tests that are  expected  to  fail
3033              and return a non zero return code.
3034
3035
3036       WORKING_DIRECTORY
3037              The directory from which the test executable will be called.
3038
3039              If this is not set it is called from the directory the test exe‐
3040              cutable is located in.
3041
3042

PROPERTIES ON SOURCE FILES

3044       ABSTRACT
3045              Is this source file an abstract class.
3046
3047              A property on a source file that indicates if  the  source  file
3048              represents  a  class that is abstract. This only makes sense for
3049              languages that have a notion of an abstract class and it is only
3050              used by some tools that wrap classes into other languages.
3051
3052
3053       COMPILE_DEFINITIONS
3054              Preprocessor definitions for compiling a source file.
3055
3056              The COMPILE_DEFINITIONS property may be set to a semicolon-sepa‐
3057              rated list of preprocessor definitions using the syntax  VAR  or
3058              VAR=value.  Function-style definitions are not supported.  CMake
3059              will automatically escape the value  correctly  for  the  native
3060              build  system  (note  that  CMake  language  syntax  may require
3061              escapes to specify some values).  This property may be set on  a
3062              per-configuration basis using the name COMPILE_DEFINITIONS_<CON‐
3063              FIG> where <CONFIG> is an upper-case name (ex.  "COMPILE_DEFINI‐
3064              TIONS_DEBUG").
3065
3066
3067              CMake will automatically drop some definitions that are not sup‐
3068              ported by the native build tool.  The VS6 IDE does  not  support
3069              definition  values with spaces (but NMake does).  Xcode does not
3070              support per-configuration definitions on source files.
3071
3072
3073              Disclaimer: Most native build tools have poor support for escap‐
3074              ing  certain  values.  CMake has work-arounds for many cases but
3075              some values may just not be possible to pass  correctly.   If  a
3076              value  does  not seem to be escaped correctly, do not attempt to
3077              work-around the problem by adding escape sequences to the value.
3078              Your work-around may break in a future version of CMake that has
3079              improved escape support.  Instead consider defining the macro in
3080              a  (configured) header file.  Then report the limitation.  Known
3081              limitations include:
3082
3083
3084                #          - broken almost everywhere
3085                ;          - broken in VS IDE 7.0 and Borland Makefiles
3086                ,          - broken in VS IDE
3087                %          - broken in some cases in NMake
3088                & |        - broken in some cases on MinGW
3089                ^ < > \"   - broken in most Make tools on Windows
3090
3091              CMake does not reject these values outright because they do work
3092              in some cases.  Use with caution.
3093
3094
3095       COMPILE_DEFINITIONS_<CONFIG>
3096              Per-configuration preprocessor definitions on a source file.
3097
3098              This  is  the  configuration-specific version of COMPILE_DEFINI‐
3099              TIONS.  Note  that  Xcode  does  not  support  per-configuration
3100              source  file flags so this property will be ignored by the Xcode
3101              generator.
3102
3103
3104       COMPILE_FLAGS
3105              Additional flags to be added when compiling this source file.
3106
3107              These flags will be added to the list of compile flags when this
3108              source  file builds.  Use COMPILE_DEFINITIONS to pass additional
3109              preprocessor definitions.
3110
3111
3112       EXTERNAL_OBJECT
3113              If set to true then this is an object file.
3114
3115              If this property is set to true then the source file  is  really
3116              an  object  file  and  should not be compiled.  It will still be
3117              linked into the target though.
3118
3119
3120       Fortran_FORMAT
3121              Set to FIXED or FREE to indicate the Fortran source layout.
3122
3123              This property tells CMake whether a given  Fortran  source  file
3124              uses  fixed-format  or  free-format.  CMake will pass the corre‐
3125              sponding format flag to the compiler.  Consider using  the  tar‐
3126              get-wide Fortran_FORMAT property if all source files in a target
3127              share the same format.
3128
3129
3130       GENERATED
3131              Is this source file generated as part of the build process.
3132
3133              If a source file is generated by the build  process  CMake  will
3134              handle  it differently in terms of dependency checking etc. Oth‐
3135              erwise having a non-existent source file could create problems.
3136
3137
3138       HEADER_FILE_ONLY
3139              Is this source file only a header file.
3140
3141              A property on a source file that indicates if the source file is
3142              a  header  file  with  no associated implementation. This is set
3143              automatically based on the file extension and is used  by  CMake
3144              to  determine  if  certain dependency information should be com‐
3145              puted.
3146
3147
3148       KEEP_EXTENSION
3149              Make the output file have the same extension as the source file.
3150
3151              If this property is set then the file extension  of  the  output
3152              file  will  be the same as that of the source file. Normally the
3153              output file extension is computed based on the language  of  the
3154              source file, for example .cxx will go to a .o extension.
3155
3156
3157       LABELS Specify a list of text labels associated with a source file.
3158
3159              This property has meaning only when the source file is listed in
3160              a target whose LABELS property is also set.  No other  semantics
3161              are currently specified.
3162
3163
3164       LANGUAGE
3165              What programming language is the file.
3166
3167              A property that can be set to indicate what programming language
3168              the source file is. If it is not set the language is  determined
3169              based  on the file extension. Typical values are CXX C etc. Set‐
3170              ting this property for a file means this file will be  compiled.
3171              Do  not  set  this  for headers or files that should not be com‐
3172              piled.
3173
3174
3175       LOCATION
3176              The full path to a source file.
3177
3178              A read only property on a SOURCE FILE  that  contains  the  full
3179              path to the source file.
3180
3181
3182       MACOSX_PACKAGE_LOCATION
3183              Place  a  source  file  inside  a  Mac OS X bundle, CFBundle, or
3184              framework.
3185
3186              Executable targets with the MACOSX_BUNDLE property set are built
3187              as  Mac  OS  X  application  bundles on Apple platforms.  Shared
3188              library targets with the FRAMEWORK property set are built as Mac
3189              OS X frameworks on Apple platforms.  Module library targets with
3190              the BUNDLE property set are built as Mac OS X  CFBundle  bundles
3191              on Apple platforms.  Source files listed in the target with this
3192              property set will be copied to a directory inside the bundle  or
3193              framework  content  folder specified by the property value.  For
3194              bundles the content folder is "<name>.app/Contents".  For frame‐
3195              works  the  content  folder  is "<name>.framework/Versions/<ver‐
3196              sion>".  For cfbundles the content folder is "<name>.bundle/Con‐
3197              tents"   (unless  the  extension  is  changed).   See  the  PUB‐
3198              LIC_HEADER, PRIVATE_HEADER, and RESOURCE target  properties  for
3199              specifying files meant for Headers, PrivateHeaders, or Resources
3200              directories.
3201
3202
3203       OBJECT_DEPENDS
3204              Additional files on which a compiled object file depends.
3205
3206              Specifies a semicolon-separated list of full-paths to  files  on
3207              which  any  object  files compiled from this source file depend.
3208              An object file will be recompiled if any of the named  files  is
3209              newer than it.
3210
3211
3212              This  property  need  not be used to specify the dependency of a
3213              source file  on  a  generated  header  file  that  it  includes.
3214              Although  the  property  was originally introduced for this pur‐
3215              pose, it is no longer necessary.  If the generated  header  file
3216              is  created by a custom command in the same target as the source
3217              file, the automatic dependency scanning process  will  recognize
3218              the  dependency.   If  the  generated  header file is created by
3219              another target, an inter-target  dependency  should  be  created
3220              with the add_dependencies command (if one does not already exist
3221              due to linking relationships).
3222
3223
3224       OBJECT_OUTPUTS
3225              Additional outputs for a Makefile rule.
3226
3227              Additional outputs created by compilation of this  source  file.
3228              If  any  of  these  outputs is missing the object will be recom‐
3229              piled. This is supported only on Makefile generators and will be
3230              ignored on other generators.
3231
3232
3233       SYMBOLIC
3234              Is this just a name for a rule.
3235
3236              If  SYMBOLIC  (boolean)  is set to true the build system will be
3237              informed that the source file is not actually  created  on  disk
3238              but instead used as a symbolic name for a build rule.
3239
3240
3241       WRAP_EXCLUDE
3242              Exclude this source file from any code wrapping techniques.
3243
3244              Some  packages can wrap source files into alternate languages to
3245              provide additional functionality. For example, C++ code  can  be
3246              wrapped  into Java or Python etc using SWIG etc. If WRAP_EXCLUDE
3247              is set to true (1 etc) that  indicates  that  this  source  file
3248              should not be wrapped.
3249
3250

PROPERTIES ON CACHE ENTRIES

3252       ADVANCED
3253              True if entry should be hidden by default in GUIs.
3254
3255              This  is a boolean value indicating whether the entry is consid‐
3256              ered  interesting  only   for   advanced   configuration.    The
3257              mark_as_advanced() command modifies this property.
3258
3259
3260       HELPSTRING
3261              Help associated with entry in GUIs.
3262
3263              This string summarizes the purpose of an entry to help users set
3264              it through a CMake GUI.
3265
3266
3267       MODIFIED
3268              Internal management property.  Do not set or get.
3269
3270              This is an internal cache entry property  managed  by  CMake  to
3271              track interactive user modification of entries.  Ignore it.
3272
3273
3274       STRINGS
3275              Enumerate possible STRING entry values for GUI selection.
3276
3277              For  cache  entries  with  type STRING, this enumerates a set of
3278              values.  CMake GUIs may use this to provide a  selection  widget
3279              instead  of  a  generic  string entry field.  This is for conve‐
3280              nience only.  CMake does not enforce that the value matches  one
3281              of those listed.
3282
3283
3284       TYPE   Widget type for entry in GUIs.
3285
3286              Cache  entry  values  are always strings, but CMake GUIs present
3287              widgets to help users set values.  The GUIs use this property as
3288              a hint to determine the widget type.  Valid TYPE values are:
3289
3290
3291                BOOL          = Boolean ON/OFF value.
3292                PATH          = Path to a directory.
3293                FILEPATH      = Path to a file.
3294                STRING        = Generic string value.
3295                INTERNAL      = Do not present in GUI at all.
3296                STATIC        = Value managed by CMake, do not change.
3297                UNINITIALIZED = Type not yet specified.
3298
3299              Generally the TYPE of a cache entry should be set by the command
3300              which creates it (set, option, find_library, etc.).
3301
3302
3303       VALUE  Value of a cache entry.
3304
3305              This property maps to the actual value of a cache  entry.   Set‐
3306              ting  this  property  always sets the value without checking, so
3307              use with care.
3308
3309
3311       Copyright 2000-2012 Kitware, Inc., Insight  Software  Consortium.   All
3312       rights reserved.
3313
3314
3315       Redistribution and use in source and binary forms, with or without mod‐
3316       ification, are permitted provided that  the  following  conditions  are
3317       met:
3318
3319
3320       Redistributions  of source code must retain the above copyright notice,
3321       this list of conditions and the following disclaimer.
3322
3323
3324       Redistributions in binary  form  must  reproduce  the  above  copyright
3325       notice,  this  list  of  conditions and the following disclaimer in the
3326       documentation and/or other materials provided with the distribution.
3327
3328
3329       Neither the names of Kitware, Inc., the  Insight  Software  Consortium,
3330       nor  the  names of their contributors may be used to endorse or promote
3331       products derived from this software without specific prior written per‐
3332       mission.
3333
3334
3335       THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
3336       IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT  NOT  LIMITED
3337       TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTIC‐
3338       ULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER  OR
3339       CONTRIBUTORS  BE  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
3340       EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,  BUT  NOT  LIMITED  TO,
3341       PROCUREMENT  OF  SUBSTITUTE  GOODS  OR  SERVICES; LOSS OF USE, DATA, OR
3342       PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY  OF
3343       LIABILITY,  WHETHER  IN  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
3344       NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT  OF  THE  USE  OF  THIS
3345       SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
3346
3347

SEE ALSO

3349       The following resources are available to get help using CMake:
3350
3351
3352       Home Page
3353              http://www.cmake.org
3354
3355              The primary starting point for learning about CMake.
3356
3357
3358       Frequently Asked Questions
3359              http://www.cmake.org/Wiki/CMake_FAQ
3360
3361              A  Wiki is provided containing answers to frequently asked ques‐
3362              tions.
3363
3364
3365       Online Documentation
3366              http://www.cmake.org/HTML/Documentation.html
3367
3368              Links to available documentation may be found on this web page.
3369
3370
3371       Mailing List
3372              http://www.cmake.org/HTML/MailingLists.html
3373
3374              For help and discussion about using cmake,  a  mailing  list  is
3375              provided  at  cmake@cmake.org.  The list is member-post-only but
3376              one may sign up on the CMake web page.  Please  first  read  the
3377              full  documentation at http://www.cmake.org before posting ques‐
3378              tions to the list.
3379
3380
3381
3382
3383cmake 2.8.12.2                 October 15, 2014                  cmakeprops(1)
Impressum