1 .\" Man page generated from reStructuredText.

     2 .

     3 .TH "CMAKE-POLICIES" "7" "October 14, 2015" "3.3.2" "CMake"

     4 .SH NAME

     5 cmake-policies \- CMake Policies Reference

     6 .

     7 .nr rst2man-indent-level 0

     8 .

     9 .de1 rstReportMargin

    10 \\$1 \\n[an-margin]

    11 level \\n[rst2man-indent-level]

    12 level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]

    13 -

    14 \\n[rst2man-indent0]

    15 \\n[rst2man-indent1]

    16 \\n[rst2man-indent2]

    17 ..

    18 .de1 INDENT

    19 .\" .rstReportMargin pre:

    20 . RS \\$1

    21 . nr rst2man-indent\\n[rst2man-indent-level] \\n[an-margin]

    22 . nr rst2man-indent-level +1

    23 .\" .rstReportMargin post:

    24 ..

    25 .de UNINDENT

    26 . RE

    27 .\" indent \\n[an-margin]

    28 .\" old: \\n[rst2man-indent\\n[rst2man-indent-level]]

    29 .nr rst2man-indent-level -1

    30 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]

    31 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u

    32 ..

    33 .SH INTRODUCTION

    34 .sp

    35 Policies in CMake are used to preserve backward compatible behavior

    36 across multiple releases.  When a new policy is introduced, newer CMake

    37 versions will begin to warn about the backward compatible behavior.  It

    38 is possible to disable the warning by explicitly requesting the OLD, or

    39 backward compatible behavior using the \fBcmake_policy()\fP command.

    40 It is also possible to request \fBNEW\fP, or non\-backward compatible behavior

    41 for a policy, also avoiding the warning.  Each policy can also be set to

    42 either \fBNEW\fP or \fBOLD\fP behavior explicitly on the command line with the

    43 \fBCMAKE_POLICY_DEFAULT_CMP<NNNN>\fP variable.

    44 .sp

    45 A policy is a deprecation mechanism and not a reliable feature toggle.

    46 A policy should almost never be set to \fBOLD\fP, except to silence warnings

    47 in an otherwise frozen or stable codebase, or temporarily as part of a

    48 larger migration path. The \fBOLD\fP behavior of each policy is undesirable

    49 and will be replaced with an error condition in a future release.

    50 .sp

    51 The \fBcmake_minimum_required()\fP command does more than report an

    52 error if a too\-old version of CMake is used to build a project.  It

    53 also sets all policies introduced in that CMake version or earlier to

    54 \fBNEW\fP behavior.  To manage policies without increasing the minimum required

    55 CMake version, the \fBif(POLICY)\fP command may be used:

    56 .INDENT 0.0

    57 .INDENT 3.5

    58 .sp

    59 .nf

    60 .ft C

    61 if(POLICY CMP0990)

    62   cmake_policy(SET CMP0990 NEW)

    63 endif()

    64 .ft P

    65 .fi

    66 .UNINDENT

    67 .UNINDENT

    68 .sp

    69 This has the effect of using the \fBNEW\fP behavior with newer CMake releases which

    70 users may be using and not issuing a compatibility warning.

    71 .sp

    72 The setting of a policy is confined in some cases to not propagate to the

    73 parent scope.  For example, if the files read by the \fBinclude()\fP command

    74 or the \fBfind_package()\fP command contain a use of \fBcmake_policy()\fP,

    75 that policy setting will not affect the caller by default.  Both commands accept

    76 an optional \fBNO_POLICY_SCOPE\fP keyword to control this behavior.

    77 .sp

    78 The \fBCMAKE_MINIMUM_REQUIRED_VERSION\fP variable may also be used

    79 to determine whether to report an error on use of deprecated macros or

    80 functions.

    81 .SH ALL POLICIES

    82 .SS CMP0000

    83 .sp

    84 A minimum required CMake version must be specified.

    85 .sp

    86 CMake requires that projects specify the version of CMake to which

    87 they have been written.  This policy has been put in place so users

    88 trying to build the project may be told when they need to update their

    89 CMake.  Specifying a version also helps the project build with CMake

    90 versions newer than that specified.  Use the cmake_minimum_required

    91 command at the top of your main CMakeLists.txt file:

    92 .INDENT 0.0

    93 .INDENT 3.5

    94 .sp

    95 .nf

    96 .ft C

    97 cmake_minimum_required(VERSION <major>.<minor>)

    98 .ft P

    99 .fi

   100 .UNINDENT

   101 .UNINDENT

   102 .sp

   103 where "<major>.<minor>" is the version of CMake you want to support

   104 (such as "2.6").  The command will ensure that at least the given

   105 version of CMake is running and help newer versions be compatible with

   106 the project.  See documentation of cmake_minimum_required for details.

   107 .sp

   108 Note that the command invocation must appear in the CMakeLists.txt

   109 file itself; a call in an included file is not sufficient.  However,

   110 the cmake_policy command may be called to set policy CMP0000 to OLD or

   111 NEW behavior explicitly.  The OLD behavior is to silently ignore the

   112 missing invocation.  The NEW behavior is to issue an error instead of

   113 a warning.  An included file may set CMP0000 explicitly to affect how

   114 this policy is enforced for the main CMakeLists.txt file.

   115 .sp

   116 This policy was introduced in CMake version 2.6.0.

   117 .sp

   118 \fBNOTE:\fP

   119 .INDENT 0.0

   120 .INDENT 3.5

   121 The \fBOLD\fP behavior of a policy is

   122 \fBdeprecated by definition\fP

   123 and may be removed in a future version of CMake.

   124 .UNINDENT

   125 .UNINDENT

   126 .SS CMP0001

   127 .sp

   128 CMAKE_BACKWARDS_COMPATIBILITY should no longer be used.

   129 .sp

   130 The OLD behavior is to check CMAKE_BACKWARDS_COMPATIBILITY and present

   131 it to the user.  The NEW behavior is to ignore

   132 CMAKE_BACKWARDS_COMPATIBILITY completely.

   133 .sp

   134 In CMake 2.4 and below the variable CMAKE_BACKWARDS_COMPATIBILITY was

   135 used to request compatibility with earlier versions of CMake.  In

   136 CMake 2.6 and above all compatibility issues are handled by policies

   137 and the cmake_policy command.  However, CMake must still check

   138 CMAKE_BACKWARDS_COMPATIBILITY for projects written for CMake 2.4 and

   139 below.

   140 .sp

   141 This policy was introduced in CMake version 2.6.0.  CMake version

   142 3.3.2 warns when the policy is not set and uses OLD behavior.  Use

   143 the cmake_policy command to set it to OLD or NEW explicitly.

   144 .sp

   145 \fBNOTE:\fP

   146 .INDENT 0.0

   147 .INDENT 3.5

   148 The \fBOLD\fP behavior of a policy is

   149 \fBdeprecated by definition\fP

   150 and may be removed in a future version of CMake.

   151 .UNINDENT

   152 .UNINDENT

   153 .SS CMP0002

   154 .sp

   155 Logical target names must be globally unique.

   156 .sp

   157 Targets names created with add_executable, add_library, or

   158 add_custom_target are logical build target names.  Logical target

   159 names must be globally unique because:

   160 .INDENT 0.0

   161 .INDENT 3.5

   162 .sp

   163 .nf

   164 .ft C

   165 \- Unique names may be referenced unambiguously both in CMake

   166   code and on make tool command lines.

   167 \- Logical names are used by Xcode and VS IDE generators

   168   to produce meaningful project names for the targets.

   169 .ft P

   170 .fi

   171 .UNINDENT

   172 .UNINDENT

   173 .sp

   174 The logical name of executable and library targets does not have to

   175 correspond to the physical file names built.  Consider using the

   176 OUTPUT_NAME target property to create two targets with the same

   177 physical name while keeping logical names distinct.  Custom targets

   178 must simply have globally unique names (unless one uses the global

   179 property ALLOW_DUPLICATE_CUSTOM_TARGETS with a Makefiles generator).

   180 .sp

   181 This policy was introduced in CMake version 2.6.0.  CMake version

   182 3.3.2 warns when the policy is not set and uses OLD behavior.  Use

   183 the cmake_policy command to set it to OLD or NEW explicitly.

   184 .sp

   185 \fBNOTE:\fP

   186 .INDENT 0.0

   187 .INDENT 3.5

   188 The \fBOLD\fP behavior of a policy is

   189 \fBdeprecated by definition\fP

   190 and may be removed in a future version of CMake.

   191 .UNINDENT

   192 .UNINDENT

   193 .SS CMP0003

   194 .sp

   195 Libraries linked via full path no longer produce linker search paths.

   196 .sp

   197 This policy affects how libraries whose full paths are NOT known are

   198 found at link time, but was created due to a change in how CMake deals

   199 with libraries whose full paths are known.  Consider the code

   200 .INDENT 0.0

   201 .INDENT 3.5

   202 .sp

   203 .nf

   204 .ft C

   205 target_link_libraries(myexe /path/to/libA.so)

   206 .ft P

   207 .fi

   208 .UNINDENT

   209 .UNINDENT

   210 .sp

   211 CMake 2.4 and below implemented linking to libraries whose full paths

   212 are known by splitting them on the link line into separate components

   213 consisting of the linker search path and the library name.  The

   214 example code might have produced something like

   215 .INDENT 0.0

   216 .INDENT 3.5

   217 .sp

   218 .nf

   219 .ft C

   220 \&... \-L/path/to \-lA ...

   221 .ft P

   222 .fi

   223 .UNINDENT

   224 .UNINDENT

   225 .sp

   226 in order to link to library A.  An analysis was performed to order

   227 multiple link directories such that the linker would find library A in

   228 the desired location, but there are cases in which this does not work.

   229 CMake versions 2.6 and above use the more reliable approach of passing

   230 the full path to libraries directly to the linker in most cases.  The

   231 example code now produces something like

   232 .INDENT 0.0

   233 .INDENT 3.5

   234 .sp

   235 .nf

   236 .ft C

   237 \&... /path/to/libA.so ....

   238 .ft P

   239 .fi

   240 .UNINDENT

   241 .UNINDENT

   242 .sp

   243 Unfortunately this change can break code like

   244 .INDENT 0.0

   245 .INDENT 3.5

   246 .sp

   247 .nf

   248 .ft C

   249 target_link_libraries(myexe /path/to/libA.so B)

   250 .ft P

   251 .fi

   252 .UNINDENT

   253 .UNINDENT

   254 .sp

   255 where "B" is meant to find "/path/to/libB.so".  This code is wrong

   256 because the user is asking the linker to find library B but has not

   257 provided a linker search path (which may be added with the

   258 link_directories command).  However, with the old linking

   259 implementation the code would work accidentally because the linker

   260 search path added for library A allowed library B to be found.

   261 .sp

   262 In order to support projects depending on linker search paths added by

   263 linking to libraries with known full paths, the OLD behavior for this

   264 policy will add the linker search paths even though they are not

   265 needed for their own libraries.  When this policy is set to OLD, CMake

   266 will produce a link line such as

   267 .INDENT 0.0

   268 .INDENT 3.5

   269 .sp

   270 .nf

   271 .ft C

   272 \&... \-L/path/to /path/to/libA.so \-lB ...

   273 .ft P

   274 .fi

   275 .UNINDENT

   276 .UNINDENT

   277 .sp

   278 which will allow library B to be found as it was previously.  When

   279 this policy is set to NEW, CMake will produce a link line such as

   280 .INDENT 0.0

   281 .INDENT 3.5

   282 .sp

   283 .nf

   284 .ft C

   285 \&... /path/to/libA.so \-lB ...

   286 .ft P

   287 .fi

   288 .UNINDENT

   289 .UNINDENT

   290 .sp

   291 which more accurately matches what the project specified.

   292 .sp

   293 The setting for this policy used when generating the link line is that

   294 in effect when the target is created by an add_executable or

   295 add_library command.  For the example described above, the code

   296 .INDENT 0.0

   297 .INDENT 3.5

   298 .sp

   299 .nf

   300 .ft C

   301 cmake_policy(SET CMP0003 OLD) # or cmake_policy(VERSION 2.4)

   302 add_executable(myexe myexe.c)

   303 target_link_libraries(myexe /path/to/libA.so B)

   304 .ft P

   305 .fi

   306 .UNINDENT

   307 .UNINDENT

   308 .sp

   309 will work and suppress the warning for this policy.  It may also be

   310 updated to work with the corrected linking approach:

   311 .INDENT 0.0

   312 .INDENT 3.5

   313 .sp

   314 .nf

   315 .ft C

   316 cmake_policy(SET CMP0003 NEW) # or cmake_policy(VERSION 2.6)

   317 link_directories(/path/to) # needed to find library B

   318 add_executable(myexe myexe.c)

   319 target_link_libraries(myexe /path/to/libA.so B)

   320 .ft P

   321 .fi

   322 .UNINDENT

   323 .UNINDENT

   324 .sp

   325 Even better, library B may be specified with a full path:

   326 .INDENT 0.0

   327 .INDENT 3.5

   328 .sp

   329 .nf

   330 .ft C

   331 add_executable(myexe myexe.c)

   332 target_link_libraries(myexe /path/to/libA.so /path/to/libB.so)

   333 .ft P

   334 .fi

   335 .UNINDENT

   336 .UNINDENT

   337 .sp

   338 When all items on the link line have known paths CMake does not check

   339 this policy so it has no effect.

   340 .sp

   341 Note that the warning for this policy will be issued for at most one

   342 target.  This avoids flooding users with messages for every target

   343 when setting the policy once will probably fix all targets.

   344 .sp

   345 This policy was introduced in CMake version 2.6.0.  CMake version

   346 3.3.2 warns when the policy is not set and uses OLD behavior.  Use

   347 the cmake_policy command to set it to OLD or NEW explicitly.

   348 .sp

   349 \fBNOTE:\fP

   350 .INDENT 0.0

   351 .INDENT 3.5

   352 The \fBOLD\fP behavior of a policy is

   353 \fBdeprecated by definition\fP

   354 and may be removed in a future version of CMake.

   355 .UNINDENT

   356 .UNINDENT

   357 .SS CMP0004

   358 .sp

   359 Libraries linked may not have leading or trailing whitespace.

   360 .sp

   361 CMake versions 2.4 and below silently removed leading and trailing

   362 whitespace from libraries linked with code like

   363 .INDENT 0.0

   364 .INDENT 3.5

   365 .sp

   366 .nf

   367 .ft C

   368 target_link_libraries(myexe " A ")

   369 .ft P

   370 .fi

   371 .UNINDENT

   372 .UNINDENT

   373 .sp

   374 This could lead to subtle errors in user projects.

   375 .sp

   376 The OLD behavior for this policy is to silently remove leading and

   377 trailing whitespace.  The NEW behavior for this policy is to diagnose

   378 the existence of such whitespace as an error.  The setting for this

   379 policy used when checking the library names is that in effect when the

   380 target is created by an add_executable or add_library command.

   381 .sp

   382 This policy was introduced in CMake version 2.6.0.  CMake version

   383 3.3.2 warns when the policy is not set and uses OLD behavior.  Use

   384 the cmake_policy command to set it to OLD or NEW explicitly.

   385 .sp

   386 \fBNOTE:\fP

   387 .INDENT 0.0

   388 .INDENT 3.5

   389 The \fBOLD\fP behavior of a policy is

   390 \fBdeprecated by definition\fP

   391 and may be removed in a future version of CMake.

   392 .UNINDENT

   393 .UNINDENT

   394 .SS CMP0005

   395 .sp

   396 Preprocessor definition values are now escaped automatically.

   397 .sp

   398 This policy determines whether or not CMake should generate escaped

   399 preprocessor definition values added via add_definitions.  CMake

   400 versions 2.4 and below assumed that only trivial values would be given

   401 for macros in add_definitions calls.  It did not attempt to escape

   402 non\-trivial values such as string literals in generated build rules.

   403 CMake versions 2.6 and above support escaping of most values, but

   404 cannot assume the user has not added escapes already in an attempt to

   405 work around limitations in earlier versions.

   406 .sp

   407 The OLD behavior for this policy is to place definition values given

   408 to add_definitions directly in the generated build rules without

   409 attempting to escape anything.  The NEW behavior for this policy is to

   410 generate correct escapes for all native build tools automatically.

   411 See documentation of the COMPILE_DEFINITIONS target property for

   412 limitations of the escaping implementation.

   413 .sp

   414 This policy was introduced in CMake version 2.6.0.  CMake version

   415 3.3.2 warns when the policy is not set and uses OLD behavior.  Use

   416 the cmake_policy command to set it to OLD or NEW explicitly.

   417 .sp

   418 \fBNOTE:\fP

   419 .INDENT 0.0

   420 .INDENT 3.5

   421 The \fBOLD\fP behavior of a policy is

   422 \fBdeprecated by definition\fP

   423 and may be removed in a future version of CMake.

   424 .UNINDENT

   425 .UNINDENT

   426 .SS CMP0006

   427 .sp

   428 Installing MACOSX_BUNDLE targets requires a BUNDLE DESTINATION.

   429 .sp

   430 This policy determines whether the install(TARGETS) command must be

   431 given a BUNDLE DESTINATION when asked to install a target with the

   432 MACOSX_BUNDLE property set.  CMake 2.4 and below did not distinguish

   433 application bundles from normal executables when installing targets.

   434 CMake 2.6 provides a BUNDLE option to the install(TARGETS) command

   435 that specifies rules specific to application bundles on the Mac.

   436 Projects should use this option when installing a target with the

   437 MACOSX_BUNDLE property set.

   438 .sp

   439 The OLD behavior for this policy is to fall back to the RUNTIME

   440 DESTINATION if a BUNDLE DESTINATION is not given.  The NEW behavior

   441 for this policy is to produce an error if a bundle target is installed

   442 without a BUNDLE DESTINATION.

   443 .sp

   444 This policy was introduced in CMake version 2.6.0.  CMake version

   445 3.3.2 warns when the policy is not set and uses OLD behavior.  Use

   446 the cmake_policy command to set it to OLD or NEW explicitly.

   447 .sp

   448 \fBNOTE:\fP

   449 .INDENT 0.0

   450 .INDENT 3.5

   451 The \fBOLD\fP behavior of a policy is

   452 \fBdeprecated by definition\fP

   453 and may be removed in a future version of CMake.

   454 .UNINDENT

   455 .UNINDENT

   456 .SS CMP0007

   457 .sp

   458 list command no longer ignores empty elements.

   459 .sp

   460 This policy determines whether the list command will ignore empty

   461 elements in the list.  CMake 2.4 and below list commands ignored all

   462 empty elements in the list.  For example, a;b;;c would have length 3

   463 and not 4.  The OLD behavior for this policy is to ignore empty list

   464 elements.  The NEW behavior for this policy is to correctly count

   465 empty elements in a list.

   466 .sp

   467 This policy was introduced in CMake version 2.6.0.  CMake version

   468 3.3.2 warns when the policy is not set and uses OLD behavior.  Use

   469 the cmake_policy command to set it to OLD or NEW explicitly.

   470 .sp

   471 \fBNOTE:\fP

   472 .INDENT 0.0

   473 .INDENT 3.5

   474 The \fBOLD\fP behavior of a policy is

   475 \fBdeprecated by definition\fP

   476 and may be removed in a future version of CMake.

   477 .UNINDENT

   478 .UNINDENT

   479 .SS CMP0008

   480 .sp

   481 Libraries linked by full\-path must have a valid library file name.

   482 .sp

   483 In CMake 2.4 and below it is possible to write code like

   484 .INDENT 0.0

   485 .INDENT 3.5

   486 .sp

   487 .nf

   488 .ft C

   489 target_link_libraries(myexe /full/path/to/somelib)

   490 .ft P

   491 .fi

   492 .UNINDENT

   493 .UNINDENT

   494 .sp

   495 where "somelib" is supposed to be a valid library file name such as

   496 "libsomelib.a" or "somelib.lib".  For Makefile generators this

   497 produces an error at build time because the dependency on the full

   498 path cannot be found.  For VS IDE and Xcode generators this used to

   499 work by accident because CMake would always split off the library

   500 directory and ask the linker to search for the library by name

   501 (\-lsomelib or somelib.lib).  Despite the failure with Makefiles, some

   502 projects have code like this and build only with VS and/or Xcode.

   503 This version of CMake prefers to pass the full path directly to the

   504 native build tool, which will fail in this case because it does not

   505 name a valid library file.

   506 .sp

   507 This policy determines what to do with full paths that do not appear

   508 to name a valid library file.  The OLD behavior for this policy is to

   509 split the library name from the path and ask the linker to search for

   510 it.  The NEW behavior for this policy is to trust the given path and

   511 pass it directly to the native build tool unchanged.

   512 .sp

   513 This policy was introduced in CMake version 2.6.1.  CMake version

   514 3.3.2 warns when the policy is not set and uses OLD behavior.  Use

   515 the cmake_policy command to set it to OLD or NEW explicitly.

   516 .sp

   517 \fBNOTE:\fP

   518 .INDENT 0.0

   519 .INDENT 3.5

   520 The \fBOLD\fP behavior of a policy is

   521 \fBdeprecated by definition\fP

   522 and may be removed in a future version of CMake.

   523 .UNINDENT

   524 .UNINDENT

   525 .SS CMP0009

   526 .sp

   527 FILE GLOB_RECURSE calls should not follow symlinks by default.

   528 .sp

   529 In CMake 2.6.1 and below, FILE GLOB_RECURSE calls would follow through

   530 symlinks, sometimes coming up with unexpectedly large result sets

   531 because of symlinks to top level directories that contain hundreds of

   532 thousands of files.

   533 .sp

   534 This policy determines whether or not to follow symlinks encountered

   535 during a FILE GLOB_RECURSE call.  The OLD behavior for this policy is

   536 to follow the symlinks.  The NEW behavior for this policy is not to

   537 follow the symlinks by default, but only if FOLLOW_SYMLINKS is given

   538 as an additional argument to the FILE command.

   539 .sp

   540 This policy was introduced in CMake version 2.6.2.  CMake version

   541 3.3.2 warns when the policy is not set and uses OLD behavior.  Use

   542 the cmake_policy command to set it to OLD or NEW explicitly.

   543 .sp

   544 \fBNOTE:\fP

   545 .INDENT 0.0

   546 .INDENT 3.5

   547 The \fBOLD\fP behavior of a policy is

   548 \fBdeprecated by definition\fP

   549 and may be removed in a future version of CMake.

   550 .UNINDENT

   551 .UNINDENT

   552 .SS CMP0010

   553 .sp

   554 Bad variable reference syntax is an error.

   555 .sp

   556 In CMake 2.6.2 and below, incorrect variable reference syntax such as

   557 a missing close\-brace ("${FOO") was reported but did not stop

   558 processing of CMake code.  This policy determines whether a bad

   559 variable reference is an error.  The OLD behavior for this policy is

   560 to warn about the error, leave the string untouched, and continue.

   561 The NEW behavior for this policy is to report an error.

   562 .sp

   563 If \fBCMP0053\fP is set to \fBNEW\fP, this policy has no effect

   564 and is treated as always being \fBNEW\fP\&.

   565 .sp

   566 This policy was introduced in CMake version 2.6.3.  CMake version

   567 3.3.2 warns when the policy is not set and uses OLD behavior.  Use

   568 the cmake_policy command to set it to OLD or NEW explicitly.

   569 .sp

   570 \fBNOTE:\fP

   571 .INDENT 0.0

   572 .INDENT 3.5

   573 The \fBOLD\fP behavior of a policy is

   574 \fBdeprecated by definition\fP

   575 and may be removed in a future version of CMake.

   576 .UNINDENT

   577 .UNINDENT

   578 .SS CMP0011

   579 .sp

   580 Included scripts do automatic cmake_policy PUSH and POP.

   581 .sp

   582 In CMake 2.6.2 and below, CMake Policy settings in scripts loaded by

   583 the include() and find_package() commands would affect the includer.

   584 Explicit invocations of cmake_policy(PUSH) and cmake_policy(POP) were

   585 required to isolate policy changes and protect the includer.  While

   586 some scripts intend to affect the policies of their includer, most do

   587 not.  In CMake 2.6.3 and above, include() and find_package() by

   588 default PUSH and POP an entry on the policy stack around an included

   589 script, but provide a NO_POLICY_SCOPE option to disable it.  This

   590 policy determines whether or not to imply NO_POLICY_SCOPE for

   591 compatibility.  The OLD behavior for this policy is to imply

   592 NO_POLICY_SCOPE for include() and find_package() commands.  The NEW

   593 behavior for this policy is to allow the commands to do their default

   594 cmake_policy PUSH and POP.

   595 .sp

   596 This policy was introduced in CMake version 2.6.3.  CMake version

   597 3.3.2 warns when the policy is not set and uses OLD behavior.  Use

   598 the cmake_policy command to set it to OLD or NEW explicitly.

   599 .sp

   600 \fBNOTE:\fP

   601 .INDENT 0.0

   602 .INDENT 3.5

   603 The \fBOLD\fP behavior of a policy is

   604 \fBdeprecated by definition\fP

   605 and may be removed in a future version of CMake.

   606 .UNINDENT

   607 .UNINDENT

   608 .SS CMP0012

   609 .sp

   610 if() recognizes numbers and boolean constants.

   611 .sp

   612 In CMake versions 2.6.4 and lower the if() command implicitly

   613 dereferenced arguments corresponding to variables, even those named

   614 like numbers or boolean constants, except for 0 and 1.  Numbers and

   615 boolean constants such as true, false, yes, no, on, off, y, n,

   616 notfound, ignore (all case insensitive) were recognized in some cases

   617 but not all.  For example, the code "if(TRUE)" might have evaluated as

   618 false.  Numbers such as 2 were recognized only in boolean expressions

   619 like "if(NOT 2)" (leading to false) but not as a single\-argument like

   620 "if(2)" (also leading to false).  Later versions of CMake prefer to

   621 treat numbers and boolean constants literally, so they should not be

   622 used as variable names.

   623 .sp

   624 The OLD behavior for this policy is to implicitly dereference

   625 variables named like numbers and boolean constants.  The NEW behavior

   626 for this policy is to recognize numbers and boolean constants without

   627 dereferencing variables with such names.

   628 .sp

   629 This policy was introduced in CMake version 2.8.0.  CMake version

   630 3.3.2 warns when the policy is not set and uses OLD behavior.  Use

   631 the cmake_policy command to set it to OLD or NEW explicitly.

   632 .sp

   633 \fBNOTE:\fP

   634 .INDENT 0.0

   635 .INDENT 3.5

   636 The \fBOLD\fP behavior of a policy is

   637 \fBdeprecated by definition\fP

   638 and may be removed in a future version of CMake.

   639 .UNINDENT

   640 .UNINDENT

   641 .SS CMP0013

   642 .sp

   643 Duplicate binary directories are not allowed.

   644 .sp

   645 CMake 2.6.3 and below silently permitted add_subdirectory() calls to

   646 create the same binary directory multiple times.  During build system

   647 generation files would be written and then overwritten in the build

   648 tree and could lead to strange behavior.  CMake 2.6.4 and above

   649 explicitly detect duplicate binary directories.  CMake 2.6.4 always

   650 considers this case an error.  In CMake 2.8.0 and above this policy

   651 determines whether or not the case is an error.  The OLD behavior for

   652 this policy is to allow duplicate binary directories.  The NEW

   653 behavior for this policy is to disallow duplicate binary directories

   654 with an error.

   655 .sp

   656 This policy was introduced in CMake version 2.8.0.  CMake version

   657 3.3.2 warns when the policy is not set and uses OLD behavior.  Use

   658 the cmake_policy command to set it to OLD or NEW explicitly.

   659 .sp

   660 \fBNOTE:\fP

   661 .INDENT 0.0

   662 .INDENT 3.5

   663 The \fBOLD\fP behavior of a policy is

   664 \fBdeprecated by definition\fP

   665 and may be removed in a future version of CMake.

   666 .UNINDENT

   667 .UNINDENT

   668 .SS CMP0014

   669 .sp

   670 Input directories must have CMakeLists.txt.

   671 .sp

   672 CMake versions before 2.8 silently ignored missing CMakeLists.txt

   673 files in directories referenced by add_subdirectory() or subdirs(),

   674 treating them as if present but empty.  In CMake 2.8.0 and above this

   675 policy determines whether or not the case is an error.  The OLD

   676 behavior for this policy is to silently ignore the problem.  The NEW

   677 behavior for this policy is to report an error.

   678 .sp

   679 This policy was introduced in CMake version 2.8.0.  CMake version

   680 3.3.2 warns when the policy is not set and uses OLD behavior.  Use

   681 the cmake_policy command to set it to OLD or NEW explicitly.

   682 .sp

   683 \fBNOTE:\fP

   684 .INDENT 0.0

   685 .INDENT 3.5

   686 The \fBOLD\fP behavior of a policy is

   687 \fBdeprecated by definition\fP

   688 and may be removed in a future version of CMake.

   689 .UNINDENT

   690 .UNINDENT

   691 .SS CMP0015

   692 .sp

   693 link_directories() treats paths relative to the source dir.

   694 .sp

   695 In CMake 2.8.0 and lower the link_directories() command passed

   696 relative paths unchanged to the linker.  In CMake 2.8.1 and above the

   697 link_directories() command prefers to interpret relative paths with

   698 respect to CMAKE_CURRENT_SOURCE_DIR, which is consistent with

   699 include_directories() and other commands.  The OLD behavior for this

   700 policy is to use relative paths verbatim in the linker command.  The

   701 NEW behavior for this policy is to convert relative paths to absolute

   702 paths by appending the relative path to CMAKE_CURRENT_SOURCE_DIR.

   703 .sp

   704 This policy was introduced in CMake version 2.8.1.  CMake version

   705 3.3.2 warns when the policy is not set and uses OLD behavior.  Use

   706 the cmake_policy command to set it to OLD or NEW explicitly.

   707 .sp

   708 \fBNOTE:\fP

   709 .INDENT 0.0

   710 .INDENT 3.5

   711 The \fBOLD\fP behavior of a policy is

   712 \fBdeprecated by definition\fP

   713 and may be removed in a future version of CMake.

   714 .UNINDENT

   715 .UNINDENT

   716 .SS CMP0016

   717 .sp

   718 target_link_libraries() reports error if its only argument is not a target.

   719 .sp

   720 In CMake 2.8.2 and lower the target_link_libraries() command silently

   721 ignored if it was called with only one argument, and this argument

   722 wasn\(aqt a valid target.  In CMake 2.8.3 and above it reports an error

   723 in this case.

   724 .sp

   725 This policy was introduced in CMake version 2.8.3.  CMake version

   726 3.3.2 warns when the policy is not set and uses OLD behavior.  Use

   727 the cmake_policy command to set it to OLD or NEW explicitly.

   728 .sp

   729 \fBNOTE:\fP

   730 .INDENT 0.0

   731 .INDENT 3.5

   732 The \fBOLD\fP behavior of a policy is

   733 \fBdeprecated by definition\fP

   734 and may be removed in a future version of CMake.

   735 .UNINDENT

   736 .UNINDENT

   737 .SS CMP0017

   738 .sp

   739 Prefer files from the CMake module directory when including from there.

   740 .sp

   741 Starting with CMake 2.8.4, if a cmake\-module shipped with CMake (i.e.

   742 located in the CMake module directory) calls include() or

   743 find_package(), the files located in the CMake module directory are

   744 preferred over the files in CMAKE_MODULE_PATH.  This makes sure that

   745 the modules belonging to CMake always get those files included which

   746 they expect, and against which they were developed and tested.  In all

   747 other cases, the files found in CMAKE_MODULE_PATH still take

   748 precedence over the ones in the CMake module directory.  The OLD

   749 behavior is to always prefer files from CMAKE_MODULE_PATH over files

   750 from the CMake modules directory.

   751 .sp

   752 This policy was introduced in CMake version 2.8.4.  CMake version

   753 3.3.2 warns when the policy is not set and uses OLD behavior.  Use

   754 the cmake_policy command to set it to OLD or NEW explicitly.

   755 .sp

   756 \fBNOTE:\fP

   757 .INDENT 0.0

   758 .INDENT 3.5

   759 The \fBOLD\fP behavior of a policy is

   760 \fBdeprecated by definition\fP

   761 and may be removed in a future version of CMake.

   762 .UNINDENT

   763 .UNINDENT

   764 .SS CMP0018

   765 .sp

   766 Ignore CMAKE_SHARED_LIBRARY_<Lang>_FLAGS variable.

   767 .sp

   768 CMake 2.8.8 and lower compiled sources in SHARED and MODULE libraries

   769 using the value of the undocumented CMAKE_SHARED_LIBRARY_<Lang>_FLAGS

   770 platform variable.  The variable contained platform\-specific flags

   771 needed to compile objects for shared libraries.  Typically it included

   772 a flag such as \-fPIC for position independent code but also included

   773 other flags needed on certain platforms.  CMake 2.8.9 and higher

   774 prefer instead to use the POSITION_INDEPENDENT_CODE target property to

   775 determine what targets should be position independent, and new

   776 undocumented platform variables to select flags while ignoring

   777 CMAKE_SHARED_LIBRARY_<Lang>_FLAGS completely.

   778 .sp

   779 The default for either approach produces identical compilation flags,

   780 but if a project modifies CMAKE_SHARED_LIBRARY_<Lang>_FLAGS from its

   781 original value this policy determines which approach to use.

   782 .sp

   783 The OLD behavior for this policy is to ignore the

   784 POSITION_INDEPENDENT_CODE property for all targets and use the

   785 modified value of CMAKE_SHARED_LIBRARY_<Lang>_FLAGS for SHARED and

   786 MODULE libraries.

   787 .sp

   788 The NEW behavior for this policy is to ignore

   789 CMAKE_SHARED_LIBRARY_<Lang>_FLAGS whether it is modified or not and

   790 honor the POSITION_INDEPENDENT_CODE target property.

   791 .sp

   792 This policy was introduced in CMake version 2.8.9.  CMake version

   793 3.3.2 warns when the policy is not set and uses OLD behavior.  Use

   794 the cmake_policy command to set it to OLD or NEW explicitly.

   795 .sp

   796 \fBNOTE:\fP

   797 .INDENT 0.0

   798 .INDENT 3.5

   799 The \fBOLD\fP behavior of a policy is

   800 \fBdeprecated by definition\fP

   801 and may be removed in a future version of CMake.

   802 .UNINDENT

   803 .UNINDENT

   804 .SS CMP0019

   805 .sp

   806 Do not re\-expand variables in include and link information.

   807 .sp

   808 CMake 2.8.10 and lower re\-evaluated values given to the

   809 include_directories, link_directories, and link_libraries commands to

   810 expand any leftover variable references at the end of the

   811 configuration step.  This was for strict compatibility with VERY early

   812 CMake versions because all variable references are now normally

   813 evaluated during CMake language processing.  CMake 2.8.11 and higher

   814 prefer to skip the extra evaluation.

   815 .sp

   816 The OLD behavior for this policy is to re\-evaluate the values for

   817 strict compatibility.  The NEW behavior for this policy is to leave

   818 the values untouched.

   819 .sp

   820 This policy was introduced in CMake version 2.8.11.  CMake version

   821 3.3.2 warns when the policy is not set and uses OLD behavior.  Use

   822 the cmake_policy command to set it to OLD or NEW explicitly.

   823 .sp

   824 \fBNOTE:\fP

   825 .INDENT 0.0

   826 .INDENT 3.5

   827 The \fBOLD\fP behavior of a policy is

   828 \fBdeprecated by definition\fP

   829 and may be removed in a future version of CMake.

   830 .UNINDENT

   831 .UNINDENT

   832 .SS CMP0020

   833 .sp

   834 Automatically link Qt executables to qtmain target on Windows.

   835 .sp

   836 CMake 2.8.10 and lower required users of Qt to always specify a link

   837 dependency to the qtmain.lib static library manually on Windows.

   838 CMake 2.8.11 gained the ability to evaluate generator expressions

   839 while determining the link dependencies from IMPORTED targets.  This

   840 allows CMake itself to automatically link executables which link to Qt

   841 to the qtmain.lib library when using IMPORTED Qt targets.  For

   842 applications already linking to qtmain.lib, this should have little

   843 impact.  For applications which supply their own alternative WinMain

   844 implementation and for applications which use the QAxServer library,

   845 this automatic linking will need to be disabled as per the

   846 documentation.

   847 .sp

   848 The OLD behavior for this policy is not to link executables to

   849 qtmain.lib automatically when they link to the QtCore IMPORTED target.

   850 The NEW behavior for this policy is to link executables to qtmain.lib

   851 automatically when they link to QtCore IMPORTED target.

   852 .sp

   853 This policy was introduced in CMake version 2.8.11.  CMake version

   854 3.3.2 warns when the policy is not set and uses OLD behavior.  Use

   855 the cmake_policy command to set it to OLD or NEW explicitly.

   856 .sp

   857 \fBNOTE:\fP

   858 .INDENT 0.0

   859 .INDENT 3.5

   860 The \fBOLD\fP behavior of a policy is

   861 \fBdeprecated by definition\fP

   862 and may be removed in a future version of CMake.

   863 .UNINDENT

   864 .UNINDENT

   865 .SS CMP0021

   866 .sp

   867 Fatal error on relative paths in INCLUDE_DIRECTORIES target property.

   868 .sp

   869 CMake 2.8.10.2 and lower allowed the INCLUDE_DIRECTORIES target

   870 property to contain relative paths.  The base path for such relative

   871 entries is not well defined.  CMake 2.8.12 issues a FATAL_ERROR if the

   872 INCLUDE_DIRECTORIES property contains a relative path.

   873 .sp

   874 The OLD behavior for this policy is not to warn about relative paths

   875 in the INCLUDE_DIRECTORIES target property.  The NEW behavior for this

   876 policy is to issue a FATAL_ERROR if INCLUDE_DIRECTORIES contains a

   877 relative path.

   878 .sp

   879 This policy was introduced in CMake version 2.8.12.  CMake version

   880 3.3.2 warns when the policy is not set and uses OLD behavior.  Use

   881 the cmake_policy command to set it to OLD or NEW explicitly.

   882 .sp

   883 \fBNOTE:\fP

   884 .INDENT 0.0

   885 .INDENT 3.5

   886 The \fBOLD\fP behavior of a policy is

   887 \fBdeprecated by definition\fP

   888 and may be removed in a future version of CMake.

   889 .UNINDENT

   890 .UNINDENT

   891 .SS CMP0022

   892 .sp

   893 INTERFACE_LINK_LIBRARIES defines the link interface.

   894 .sp

   895 CMake 2.8.11 constructed the \(aqlink interface\(aq of a target from

   896 properties matching \fB(IMPORTED_)?LINK_INTERFACE_LIBRARIES(_<CONFIG>)?\fP\&.

   897 The modern way to specify config\-sensitive content is to use generator

   898 expressions and the \fBIMPORTED_\fP prefix makes uniform processing of the

   899 link interface with generator expressions impossible.  The

   900 INTERFACE_LINK_LIBRARIES target property was introduced as a

   901 replacement in CMake 2.8.12.  This new property is named consistently

   902 with the INTERFACE_COMPILE_DEFINITIONS, INTERFACE_INCLUDE_DIRECTORIES

   903 and INTERFACE_COMPILE_OPTIONS properties.  For in\-build targets, CMake

   904 will use the INTERFACE_LINK_LIBRARIES property as the source of the

   905 link interface only if policy CMP0022 is NEW.  When exporting a target

   906 which has this policy set to NEW, only the INTERFACE_LINK_LIBRARIES

   907 property will be processed and generated for the IMPORTED target by

   908 default.  A new option to the install(EXPORT) and export commands

   909 allows export of the old\-style properties for compatibility with

   910 downstream users of CMake versions older than 2.8.12.  The

   911 target_link_libraries command will no longer populate the properties

   912 matching LINK_INTERFACE_LIBRARIES(_<CONFIG>)? if this policy is NEW.

   913 .sp

   914 Warning\-free future\-compatible code which works with CMake 2.8.7 onwards

   915 can be written by using the \fBLINK_PRIVATE\fP and \fBLINK_PUBLIC\fP keywords

   916 of \fBtarget_link_libraries()\fP\&.

   917 .sp

   918 The OLD behavior for this policy is to ignore the

   919 INTERFACE_LINK_LIBRARIES property for in\-build targets.  The NEW

   920 behavior for this policy is to use the INTERFACE_LINK_LIBRARIES

   921 property for in\-build targets, and ignore the old properties matching

   922 \fB(IMPORTED_)?LINK_INTERFACE_LIBRARIES(_<CONFIG>)?\fP\&.

   923 .sp

   924 This policy was introduced in CMake version 2.8.12.  CMake version

   925 3.3.2 warns when the policy is not set and uses OLD behavior.  Use

   926 the cmake_policy command to set it to OLD or NEW explicitly.

   927 .sp

   928 \fBNOTE:\fP

   929 .INDENT 0.0

   930 .INDENT 3.5

   931 The \fBOLD\fP behavior of a policy is

   932 \fBdeprecated by definition\fP

   933 and may be removed in a future version of CMake.

   934 .UNINDENT

   935 .UNINDENT

   936 .SS CMP0023

   937 .sp

   938 Plain and keyword target_link_libraries signatures cannot be mixed.

   939 .sp

   940 CMake 2.8.12 introduced the target_link_libraries signature using the

   941 PUBLIC, PRIVATE, and INTERFACE keywords to generalize the LINK_PUBLIC

   942 and LINK_PRIVATE keywords introduced in CMake 2.8.7.  Use of

   943 signatures with any of these keywords sets the link interface of a

   944 target explicitly, even if empty.  This produces confusing behavior

   945 when used in combination with the historical behavior of the plain

   946 target_link_libraries signature.  For example, consider the code:

   947 .INDENT 0.0

   948 .INDENT 3.5

   949 .sp

   950 .nf

   951 .ft C

   952 target_link_libraries(mylib A)

   953 target_link_libraries(mylib PRIVATE B)

   954 .ft P

   955 .fi

   956 .UNINDENT

   957 .UNINDENT

   958 .sp

   959 After the first line the link interface has not been set explicitly so

   960 CMake would use the link implementation, A, as the link interface.

   961 However, the second line sets the link interface to empty.  In order

   962 to avoid this subtle behavior CMake now prefers to disallow mixing the

   963 plain and keyword signatures of target_link_libraries for a single

   964 target.

   965 .sp

   966 The OLD behavior for this policy is to allow keyword and plain

   967 target_link_libraries signatures to be mixed.  The NEW behavior for

   968 this policy is to not to allow mixing of the keyword and plain

   969 signatures.

   970 .sp

   971 This policy was introduced in CMake version 2.8.12.  CMake version

   972 3.3.2 warns when the policy is not set and uses OLD behavior.  Use

   973 the cmake_policy command to set it to OLD or NEW explicitly.

   974 .sp

   975 \fBNOTE:\fP

   976 .INDENT 0.0

   977 .INDENT 3.5

   978 The \fBOLD\fP behavior of a policy is

   979 \fBdeprecated by definition\fP

   980 and may be removed in a future version of CMake.

   981 .UNINDENT

   982 .UNINDENT

   983 .SS CMP0024

   984 .sp

   985 Disallow include export result.

   986 .sp

   987 CMake 2.8.12 and lower allowed use of the include() command with the

   988 result of the export() command.  This relies on the assumption that

   989 the export() command has an immediate effect at configure\-time during

   990 a cmake run.  Certain properties of targets are not fully determined

   991 until later at generate\-time, such as the link language and complete

   992 list of link libraries.  Future refactoring will change the effect of

   993 the export() command to be executed at generate\-time.  Use ALIAS

   994 targets instead in cases where the goal is to refer to targets by

   995 another name.

   996 .sp

   997 The OLD behavior for this policy is to allow including the result of

   998 an export() command.  The NEW behavior for this policy is not to

   999 allow including the result of an export() command.

  1000 .sp

  1001 This policy was introduced in CMake version 3.0.  CMake version

  1002 3.3.2 warns when the policy is not set and uses OLD behavior.  Use

  1003 the cmake_policy command to set it to OLD or NEW explicitly.

  1004 .sp

  1005 \fBNOTE:\fP

  1006 .INDENT 0.0

  1007 .INDENT 3.5

  1008 The \fBOLD\fP behavior of a policy is

  1009 \fBdeprecated by definition\fP

  1010 and may be removed in a future version of CMake.

  1011 .UNINDENT

  1012 .UNINDENT

  1013 .SS CMP0025

  1014 .sp

  1015 Compiler id for Apple Clang is now \fBAppleClang\fP\&.

  1016 .sp

  1017 CMake 3.0 and above recognize that Apple Clang is a different compiler

  1018 than upstream Clang and that they have different version numbers.

  1019 CMake now prefers to present this to projects by setting the

  1020 \fBCMAKE_<LANG>_COMPILER_ID\fP variable to \fBAppleClang\fP instead

  1021 of \fBClang\fP\&.  However, existing projects may assume the compiler id for

  1022 Apple Clang is just \fBClang\fP as it was in CMake versions prior to 3.0.

  1023 Therefore this policy determines for Apple Clang which compiler id to

  1024 report in the \fBCMAKE_<LANG>_COMPILER_ID\fP variable after

  1025 language \fB<LANG>\fP is enabled by the \fBproject()\fP or

  1026 \fBenable_language()\fP command.  The policy must be set prior

  1027 to the invocation of either command.

  1028 .sp

  1029 The OLD behavior for this policy is to use compiler id \fBClang\fP\&.  The

  1030 NEW behavior for this policy is to use compiler id \fBAppleClang\fP\&.

  1031 .sp

  1032 This policy was introduced in CMake version 3.0.  Use the

  1033 \fBcmake_policy()\fP command to set this policy to OLD or NEW explicitly.

  1034 Unlike most policies, CMake version 3.3.2 does \fInot\fP warn

  1035 by default when this policy is not set and simply uses OLD behavior.

  1036 See documentation of the

  1037 \fBCMAKE_POLICY_WARNING_CMP0025\fP

  1038 variable to control the warning.

  1039 .sp

  1040 \fBNOTE:\fP

  1041 .INDENT 0.0

  1042 .INDENT 3.5

  1043 The \fBOLD\fP behavior of a policy is

  1044 \fBdeprecated by definition\fP

  1045 and may be removed in a future version of CMake.

  1046 .UNINDENT

  1047 .UNINDENT

  1048 .SS CMP0026

  1049 .sp

  1050 Disallow use of the LOCATION property for build targets.

  1051 .sp

  1052 CMake 2.8.12 and lower allowed reading the LOCATION target

  1053 property (and configuration\-specific variants) to

  1054 determine the eventual location of build targets.  This relies on the

  1055 assumption that all necessary information is available at

  1056 configure\-time to determine the final location and filename of the

  1057 target.  However, this property is not fully determined until later at

  1058 generate\-time.  At generate time, the $<TARGET_FILE> generator

  1059 expression can be used to determine the eventual LOCATION of a target

  1060 output.

  1061 .sp

  1062 Code which reads the LOCATION target property can be ported to use the

  1063 $<TARGET_FILE> generator expression together with the file(GENERATE)

  1064 subcommand to generate a file containing the target location.

  1065 .sp

  1066 The OLD behavior for this policy is to allow reading the LOCATION

  1067 properties from build\-targets.  The NEW behavior for this policy is to

  1068 not to allow reading the LOCATION properties from build\-targets.

  1069 .sp

  1070 This policy was introduced in CMake version 3.0.  CMake version

  1071 3.3.2 warns when the policy is not set and uses OLD behavior.  Use

  1072 the cmake_policy command to set it to OLD or NEW explicitly.

  1073 .sp

  1074 \fBNOTE:\fP

  1075 .INDENT 0.0

  1076 .INDENT 3.5

  1077 The \fBOLD\fP behavior of a policy is

  1078 \fBdeprecated by definition\fP

  1079 and may be removed in a future version of CMake.

  1080 .UNINDENT

  1081 .UNINDENT

  1082 .SS CMP0027

  1083 .sp

  1084 Conditionally linked imported targets with missing include directories.

  1085 .sp

  1086 CMake 2.8.11 introduced introduced the concept of

  1087 INTERFACE_INCLUDE_DIRECTORIES, and a check at cmake time that the

  1088 entries in the INTERFACE_INCLUDE_DIRECTORIES of an IMPORTED target

  1089 actually exist.  CMake 2.8.11 also introduced generator expression

  1090 support in the target_link_libraries command.  However, if an imported

  1091 target is linked as a result of a generator expression evaluation, the

  1092 entries in the INTERFACE_INCLUDE_DIRECTORIES of that target were not

  1093 checked for existence as they should be.

  1094 .sp

  1095 The OLD behavior of this policy is to report a warning if an entry in

  1096 the INTERFACE_INCLUDE_DIRECTORIES of a generator\-expression

  1097 conditionally linked IMPORTED target does not exist.

  1098 .sp

  1099 The NEW behavior of this policy is to report an error if an entry in

  1100 the INTERFACE_INCLUDE_DIRECTORIES of a generator\-expression

  1101 conditionally linked IMPORTED target does not exist.

  1102 .sp

  1103 This policy was introduced in CMake version 3.0.  CMake version

  1104 3.3.2 warns when the policy is not set and uses OLD behavior.  Use

  1105 the cmake_policy command to set it to OLD or NEW explicitly.

  1106 .sp

  1107 \fBNOTE:\fP

  1108 .INDENT 0.0

  1109 .INDENT 3.5

  1110 The \fBOLD\fP behavior of a policy is

  1111 \fBdeprecated by definition\fP

  1112 and may be removed in a future version of CMake.

  1113 .UNINDENT

  1114 .UNINDENT

  1115 .SS CMP0028

  1116 .sp

  1117 Double colon in target name means ALIAS or IMPORTED target.

  1118 .sp

  1119 CMake 2.8.12 and lower allowed the use of targets and files with double

  1120 colons in target_link_libraries, with some buildsystem generators.

  1121 .sp

  1122 The use of double\-colons is a common pattern used to namespace IMPORTED

  1123 targets and ALIAS targets.  When computing the link dependencies of a target,

  1124 the name of each dependency could either be a target, or a file on disk.

  1125 Previously, if a target was not found with a matching name, the name was

  1126 considered to refer to a file on disk.  This can lead to confusing error

  1127 messages if there is a typo in what should be a target name.

  1128 .sp

  1129 The OLD behavior for this policy is to search for targets, then files on disk,

  1130 even if the search term contains double\-colons.  The NEW behavior for this

  1131 policy is to issue a FATAL_ERROR if a link dependency contains

  1132 double\-colons but is not an IMPORTED target or an ALIAS target.

  1133 .sp

  1134 This policy was introduced in CMake version 3.0.  CMake version

  1135 3.3.2 warns when the policy is not set and uses OLD behavior.  Use