the names listed after NAMES argument. Additional search locations can be specified after the PATHS argument. If you require special a version of a jar file you can specify it with the VERSIONS argument. The argument after DOC will be used for the documentation string in the cache. install_jar(TARGET_NAME DESTINATION) This command installs the TARGET_NAME files to the given DESTINA‐ TION. It should be called in the same scope as add_jar() or it will fail. install_jni_symlink(TARGET_NAME DESTINATION) This command installs the TARGET_NAME JNI symlinks to the given DESTINATION. It should be called in the same scope as add_jar() or it will fail. create_javadoc(<VAR> PACKAGES pkg1 [pkg2 ...] [SOURCEPATH <sourcepath>] [CLASSPATH <classpath>] [INSTALLPATH <install path>] [DOCTITLE "the documentation title"] [WINDOWTITLE "the title of the document"] [AUTHOR TRUE|FALSE] [USE TRUE|FALSE] [VERSION TRUE|FALSE] ) Create java documentation based on files or packages. For more details please read the javadoc manpage. There are two main signatures for create_javadoc. The first signa‐ ture works with package names on a path with source files: Example: create_javadoc(my_example_doc PACKAGES com.exmaple.foo com.example.bar SOURCEPATH "${CMAKE_CURRENT_SOURCE_DIR}" CLASSPATH ${CMAKE_JAVA_INCLUDE_PATH} WINDOWTITLE "My example" DOCTITLE "
My example
" AUTHOR TRUE USE TRUE VERSION TRUE ) The second signature for create_javadoc works on a given list of files. create_javadoc(<VAR> FILES file1 [file2 ...] [CLASSPATH <classpath>] [INSTALLPATH <install path>] [DOCTITLE "the documentation title"] [WINDOWTITLE "the title of the document"] [AUTHOR TRUE|FALSE] [USE TRUE|FALSE] [VERSION TRUE|FALSE] ) Example: create_javadoc(my_example_doc FILES ${example_SRCS} CLASSPATH ${CMAKE_JAVA_INCLUDE_PATH} WINDOWTITLE "My example" DOCTITLE "
My example
" AUTHOR TRUE USE TRUE VERSION TRUE ) Both signatures share most of the options. These options are the same as what you can find in the javadoc manpage. Please look at the manpage for CLASSPATH, DOCTITLE, WINDOWTITLE, AUTHOR, USE and VERSION. The documentation will be by default installed to ${CMAKE_INSTALL_PREFIX}/share/javadoc/<VAR> if you don't set the INSTALLPATH. UseJavaClassFilelist This script create a list of compiled Java class files to be added to a jar file. This avoids including cmake files which get created in the binary directory. UseJavaSymlinks Helper script for UseJava.cmake UsePkgConfig Obsolete pkg-config module for CMake, use FindPkgConfig instead. This module defines the following macro: PKGCONFIG(package includedir libdir linkflags cflags) Calling PKGCONFIG will fill the desired information into the 4 given arguments, e.g. PKGCONFIG(libart-2.0 LIBART_INCLUDE_DIR LIBART_LINK_DIR LIBART_LINK_FLAGS LIBART_CFLAGS) if pkg-config was NOT found or the specified software package doesn't exist, the variable will be empty when the function returns, otherwise they will contain the respective information UseQt4 Use Module for QT4 Sets up C and C++ to use Qt 4. It is assumed that FindQt.cmake has already been loaded. See FindQt.cmake for information on how to load Qt 4 into your CMake project. UseSWIG SWIG module for CMake Defines the following macros: SWIG_ADD_MODULE(name language [ files ]) - Define swig module with given name and specified language SWIG_LINK_LIBRARIES(name [ libraries ]) - Link libraries to swig module All other macros are for internal use only. To get the actual name of the swig module, use: ${SWIG_MODULE_${name}_REAL_NAME}. Set Source files properties such as CPLUSPLUS and SWIG_FLAGS to spec‐ ify special behavior of SWIG. Also global CMAKE_SWIG_FLAGS can be used to add special flags to all swig calls. Another special vari‐ able is CMAKE_SWIG_OUTDIR, it allows one to specify where to write all the swig generated module (swig -outdir option) The name-specific variable SWIG_MODULE_<name>_EXTRA_DEPS may be used to specify extra dependencies for the generated modules. If the source file generated by swig need some special flag you can use SET_SOURCE_FILES_PROPERTIES( ${swig_generated_file_fullname} PROPERTIES COMPILE_FLAGS "-bla") Use_wxWindows --------------------------------------------------- This convenience include finds if wxWindows is installed and set the appropriate libs, incdirs, flags etc. author Jan Woetzel <jw -at- mip.informatik.uni-kiel.de> (07/2003) USAGE: just include Use_wxWindows.cmake in your projects CMakeLists.txt INCLUDE( ${CMAKE_MODULE_PATH}/Use_wxWindows.cmake) if you are sure you need GL then SET(WXWINDOWS_USE_GL 1) *before* you include this file. UsewxWidgets Convenience include for using wxWidgets library. Determines if wxWidgets was FOUND and sets the appropriate libs, incdirs, flags, etc. INCLUDE_DIRECTORIES and LINK_DIRECTORIES are called. USAGE # Note that for MinGW users the order of libs is important! FIND_PACKAGE(wxWidgets REQUIRED net gl core base) INCLUDE(${wxWidgets_USE_FILE}) # and for each of your dependent executable/library targets: TARGET_LINK_LIBRARIES(<YourTarget> ${wxWidgets_LIBRARIES}) DEPRECATED LINK_LIBRARIES is not called in favor of adding dependencies per target. AUTHOR Jan Woetzel <jw -at- mip.informatik.uni-kiel.de> WriteBasicConfigVersionFile WRITE_BASIC_CONFIG_VERSION_FILE( filename VERSION major.minor.patch COMPATIBILITY (AnyNewerVersion|SameMajorVersion) ) Deprecated, see WRITE_BASIC_PACKAGE_VERSION_FILE(), it is identi‐ cal. POLICIES CMP0000 A minimum required CMake version must be specified. CMake requires that projects specify the version of CMake to which they have been written. This policy has been put in place so users trying to build the project may be told when they need to update their CMake. Specifying a version also helps the project build with CMake versions newer than that specified. Use the cmake_minimum_required command at the top of your main CMake‐ Lists.txt file: cmake_minimum_required(VERSION <major>.<minor>) where "<major>.<minor>" is the version of CMake you want to sup‐ port (such as "2.6"). The command will ensure that at least the given version of CMake is running and help newer versions be com‐ patible with the project. See documentation of cmake_mini‐ mum_required for details. Note that the command invocation must appear in the CMakeLists.txt file itself; a call in an included file is not sufficient. How‐ ever, the cmake_policy command may be called to set policy CMP0000 to OLD or NEW behavior explicitly. The OLD behavior is to silently ignore the missing invocation. The NEW behavior is to issue an error instead of a warning. An included file may set CMP0000 explicitly to affect how this policy is enforced for the main CMakeLists.txt file. This policy was introduced in CMake version 2.6.0. CMP0001 CMAKE_BACKWARDS_COMPATIBILITY should no longer be used. The OLD behavior is to check CMAKE_BACKWARDS_COMPATIBILITY and present it to the user. The NEW behavior is to ignore CMAKE_BACK‐ WARDS_COMPATIBILITY completely. In CMake 2.4 and below the variable CMAKE_BACKWARDS_COMPATIBILITY was used to request compatibility with earlier versions of CMake. In CMake 2.6 and above all compatibility issues are handled by policies and the cmake_policy command. However, CMake must still check CMAKE_BACKWARDS_COMPATIBILITY for projects written for CMake 2.4 and below. This policy was introduced in CMake version 2.6.0. CMake version 2.8.9 warns when the policy is not set and uses OLD behavior. Use the cmake_policy command to set it to OLD or NEW explicitly. CMP0002 Logical target names must be globally unique. Targets names created with add_executable, add_library, or add_custom_target are logical build target names. Logical target names must be globally unique because: - Unique names may be referenced unambiguously both in CMake code and on make tool command lines. - Logical names are used by Xcode and VS IDE generators to produce meaningful project names for the targets. The logical name of executable and library targets does not have to correspond to the physical file names built. Consider using the OUTPUT_NAME target property to create two targets with the same physical name while keeping logical names distinct. Custom targets must simply have globally unique names (unless one uses the global property ALLOW_DUPLICATE_CUSTOM_TARGETS with a Make‐ files generator). This policy was introduced in CMake version 2.6.0. CMake version 2.8.9 warns when the policy is not set and uses OLD behavior. Use the cmake_policy command to set it to OLD or NEW explicitly. CMP0003 Libraries linked via full path no longer produce linker search paths. This policy affects how libraries whose full paths are NOT known are found at link time, but was created due to a change in how CMake deals with libraries whose full paths are known. Consider the code target_link_libraries(myexe /path/to/libA.so) CMake 2.4 and below implemented linking to libraries whose full paths are known by splitting them on the link line into separate components consisting of the linker search path and the library name. The example code might have produced something like ... -L/path/to -lA ... in order to link to library A. An analysis was performed to order multiple link directories such that the linker would find library A in the desired location, but there are cases in which this does not work. CMake versions 2.6 and above use the more reliable approach of passing the full path to libraries directly to the linker in most cases. The example code now produces something like ... /path/to/libA.so .... Unfortunately this change can break code like target_link_libraries(myexe /path/to/libA.so B) where "B" is meant to find "/path/to/libB.so". This code is wrong because the user is asking the linker to find library B but has not provided a linker search path (which may be added with the link_directories command). However, with the old linking imple‐ mentation the code would work accidentally because the linker search path added for library A allowed library B to be found. In order to support projects depending on linker search paths added by linking to libraries with known full paths, the OLD behavior for this policy will add the linker search paths even though they are not needed for their own libraries. When this policy is set to OLD, CMake will produce a link line such as ... -L/path/to /path/to/libA.so -lB ... which will allow library B to be found as it was previously. When this policy is set to NEW, CMake will produce a link line such as ... /path/to/libA.so -lB ... which more accurately matches what the project specified. The setting for this policy used when generating the link line is that in effect when the target is created by an add_executable or add_library command. For the example described above, the code cmake_policy(SET CMP0003 OLD) # or cmake_policy(VERSION 2.4) add_executable(myexe myexe.c) target_link_libraries(myexe /path/to/libA.so B) will work and suppress the warning for this policy. It may also be updated to work with the corrected linking approach: cmake_policy(SET CMP0003 NEW) # or cmake_policy(VERSION 2.6) link_directories(/path/to) # needed to find library B add_executable(myexe myexe.c) target_link_libraries(myexe /path/to/libA.so B) Even better, library B may be specified with a full path: add_executable(myexe myexe.c) target_link_libraries(myexe /path/to/libA.so /path/to/libB.so) When all items on the link line have known paths CMake does not check this policy so it has no effect. Note that the warning for this policy will be issued for at most one target. This avoids flooding users with messages for every target when setting the policy once will probably fix all targets. This policy was introduced in CMake version 2.6.0. CMake version 2.8.9 warns when the policy is not set and uses OLD behavior. Use the cmake_policy command to set it to OLD or NEW explicitly. CMP0004 Libraries linked may not have leading or trailing whitespace. CMake versions 2.4 and below silently removed leading and trailing whitespace from libraries linked with code like target_link_libraries(myexe " A ") This could lead to subtle errors in user projects. The OLD behavior for this policy is to silently remove leading and trailing whitespace. The NEW behavior for this policy is to diag‐ nose the existence of such whitespace as an error. The setting for this policy used when checking the library names is that in effect when the target is created by an add_executable or add_library command. This policy was introduced in CMake version 2.6.0. CMake version 2.8.9 warns when the policy is not set and uses OLD behavior. Use the cmake_policy command to set it to OLD or NEW explicitly. CMP0005 Preprocessor definition values are now escaped automatically. This policy determines whether or not CMake should generate escaped preprocessor definition values added via add_definitions. CMake versions 2.4 and below assumed that only trivial values would be given for macros in add_definitions calls. It did not attempt to escape non-trivial values such as string literals in generated build rules. CMake versions 2.6 and above support escaping of most values, but cannot assume the user has not added escapes already in an attempt to work around limitations in ear‐ lier versions. The OLD behavior for this policy is to place definition values given to add_definitions directly in the generated build rules without attempting to escape anything. The NEW behavior for this policy is to generate correct escapes for all native build tools automatically. See documentation of the COMPILE_DEFINITIONS tar‐ get property for limitations of the escaping implementation. This policy was introduced in CMake version 2.6.0. CMake version 2.8.9 warns when the policy is not set and uses OLD behavior. Use the cmake_policy command to set it to OLD or NEW explicitly. CMP0006 Installing MACOSX_BUNDLE targets requires a BUNDLE DESTINATION. This policy determines whether the install(TARGETS) command must be given a BUNDLE DESTINATION when asked to install a target with the MACOSX_BUNDLE property set. CMake 2.4 and below did not dis‐ tinguish application bundles from normal executables when installing targets. CMake 2.6 provides a BUNDLE option to the install(TARGETS) command that specifies rules specific to applica‐ tion bundles on the Mac. Projects should use this option when installing a target with the MACOSX_BUNDLE property set. The OLD behavior for this policy is to fall back to the RUNTIME DESTINATION if a BUNDLE DESTINATION is not given. The NEW behav‐ ior for this policy is to produce an error if a bundle target is installed without a BUNDLE DESTINATION. This policy was introduced in CMake version 2.6.0. CMake version 2.8.9 warns when the policy is not set and uses OLD behavior. Use the cmake_policy command to set it to OLD or NEW explicitly. CMP0007 list command no longer ignores empty elements. This policy determines whether the list command will ignore empty elements in the list. CMake 2.4 and below list commands ignored all empty elements in the list. For example, a;b;;c would have length 3 and not 4. The OLD behavior for this policy is to ignore empty list elements. The NEW behavior for this policy is to cor‐ rectly count empty elements in a list. This policy was introduced in CMake version 2.6.0. CMake version 2.8.9 warns when the policy is not set and uses OLD behavior. Use the cmake_policy command to set it to OLD or NEW explicitly. CMP0008 Libraries linked by full-path must have a valid library file name. In CMake 2.4 and below it is possible to write code like target_link_libraries(myexe /full/path/to/somelib) where "somelib" is supposed to be a valid library file name such as "libsomelib.a" or "somelib.lib". For Makefile generators this produces an error at build time because the dependency on the full path cannot be found. For VS IDE and Xcode generators this used to work by accident because CMake would always split off the library directory and ask the linker to search for the library by name (-lsomelib or somelib.lib). Despite the failure with Make‐ files, some projects have code like this and build only with VS and/or Xcode. This version of CMake prefers to pass the full path directly to the native build tool, which will fail in this case because it does not name a valid library file. This policy determines what to do with full paths that do not appear to name a valid library file. The OLD behavior for this policy is to split the library name from the path and ask the linker to search for it. The NEW behavior for this policy is to trust the given path and pass it directly to the native build tool unchanged. This policy was introduced in CMake version 2.6.1. CMake version 2.8.9 warns when the policy is not set and uses OLD behavior. Use the cmake_policy command to set it to OLD or NEW explicitly. CMP0009 FILE GLOB_RECURSE calls should not follow symlinks by default. In CMake 2.6.1 and below, FILE GLOB_RECURSE calls would follow through symlinks, sometimes coming up with unexpectedly large result sets because of symlinks to top level directories that con‐ tain hundreds of thousands of files. This policy determines whether or not to follow symlinks encoun‐ tered during a FILE GLOB_RECURSE call. The OLD behavior for this policy is to follow the symlinks. The NEW behavior for this policy is not to follow the symlinks by default, but only if FOLLOW_SYM‐ LINKS is given as an additional argument to the FILE command. This policy was introduced in CMake version 2.6.2. CMake version 2.8.9 warns when the policy is not set and uses OLD behavior. Use the cmake_policy command to set it to OLD or NEW explicitly. CMP0010 Bad variable reference syntax is an error. In CMake 2.6.2 and below, incorrect variable reference syntax such as a missing close-brace ("${FOO") was reported but did not stop processing of CMake code. This policy determines whether a bad variable reference is an error. The OLD behavior for this policy is to warn about the error, leave the string untouched, and con‐ tinue. The NEW behavior for this policy is to report an error. This policy was introduced in CMake version 2.6.3. CMake version 2.8.9 warns when the policy is not set and uses OLD behavior. Use the cmake_policy command to set it to OLD or NEW explicitly. CMP0011 Included scripts do automatic cmake_policy PUSH and POP. In CMake 2.6.2 and below, CMake Policy settings in scripts loaded by the include() and find_package() commands would affect the includer. Explicit invocations of cmake_policy(PUSH) and cmake_policy(POP) were required to isolate policy changes and pro‐ tect the includer. While some scripts intend to affect the poli‐ cies of their includer, most do not. In CMake 2.6.3 and above, include() and find_package() by default PUSH and POP an entry on the policy stack around an included script, but provide a NO_POL‐ ICY_SCOPE option to disable it. This policy determines whether or not to imply NO_POLICY_SCOPE for compatibility. The OLD behavior for this policy is to imply NO_POLICY_SCOPE for include() and find_package() commands. The NEW behavior for this policy is to allow the commands to do their default cmake_policy PUSH and POP. This policy was introduced in CMake version 2.6.3. CMake version 2.8.9 warns when the policy is not set and uses OLD behavior. Use the cmake_policy command to set it to OLD or NEW explicitly. CMP0012 if() recognizes numbers and boolean constants. In CMake versions 2.6.4 and lower the if() command implicitly dereferenced arguments corresponding to variables, even those named like numbers or boolean constants, except for 0 and 1. Num‐ bers and boolean constants such as true, false, yes, no, on, off, y, n, notfound, ignore (all case insensitive) were recognized in some cases but not all. For example, the code "if(TRUE)" might have evaluated as false. Numbers such as 2 were recognized only in boolean expressions like "if(NOT 2)" (leading to false) but not as a single-argument like "if(2)" (also leading to false). Later versions of CMake prefer to treat numbers and boolean constants literally, so they should not be used as variable names. The OLD behavior for this policy is to implicitly dereference variables named like numbers and boolean constants. The NEW behav‐ ior for this policy is to recognize numbers and boolean constants without dereferencing variables with such names. This policy was introduced in CMake version 2.8.0. CMake version 2.8.9 warns when the policy is not set and uses OLD behavior. Use the cmake_policy command to set it to OLD or NEW explicitly. CMP0013 Duplicate binary directories are not allowed. CMake 2.6.3 and below silently permitted add_subdirectory() calls to create the same binary directory multiple times. During build system generation files would be written and then overwritten in the build tree and could lead to strange behavior. CMake 2.6.4 and above explicitly detect duplicate binary directories. CMake 2.6.4 always considers this case an error. In CMake 2.8.0 and above this policy determines whether or not the case is an error. The OLD behavior for this policy is to allow duplicate binary directories. The NEW behavior for this policy is to disallow duplicate binary directories with an error. This policy was introduced in CMake version 2.8.0. CMake version 2.8.9 warns when the policy is not set and uses OLD behavior. Use the cmake_policy command to set it to OLD or NEW explicitly. CMP0014 Input directories must have CMakeLists.txt. CMake versions before 2.8 silently ignored missing CMakeLists.txt files in directories referenced by add_subdirectory() or sub‐ dirs(), treating them as if present but empty. In CMake 2.8.0 and above this policy determines whether or not the case is an error. The OLD behavior for this policy is to silently ignore the prob‐ lem. The NEW behavior for this policy is to report an error. This policy was introduced in CMake version 2.8.0. CMake version 2.8.9 warns when the policy is not set and uses OLD behavior. Use the cmake_policy command to set it to OLD or NEW explicitly. CMP0015 link_directories() treats paths relative to the source dir. In CMake 2.8.0 and lower the link_directories() command passed relative paths unchanged to the linker. In CMake 2.8.1 and above the link_directories() command prefers to interpret relative paths with respect to CMAKE_CURRENT_SOURCE_DIR, which is consistent with include_directories() and other commands. The OLD behavior for this policy is to use relative paths verbatim in the linker com‐ mand. The NEW behavior for this policy is to convert relative paths to absolute paths by appending the relative path to CMAKE_CURRENT_SOURCE_DIR. This policy was introduced in CMake version 2.8.1. CMake version 2.8.9 warns when the policy is not set and uses OLD behavior. Use the cmake_policy command to set it to OLD or NEW explicitly. CMP0016 target_link_libraries() reports error if only argument is not a target. In CMake 2.8.2 and lower the target_link_libraries() command silently ignored if it was called with only one argument, and this argument wasn't a valid target. In CMake 2.8.3 and above it reports an error in this case. This policy was introduced in CMake version 2.8.3. CMake version 2.8.9 warns when the policy is not set and uses OLD behavior. Use the cmake_policy command to set it to OLD or NEW explicitly. CMP0017 Prefer files from the CMake module directory when including from there. Starting with CMake 2.8.4, if a cmake-module shipped with CMake (i.e. located in the CMake module directory) calls include() or find_package(), the files located in the the CMake module direc‐ tory are preferred over the files in CMAKE_MODULE_PATH. This makes sure that the modules belonging to CMake always get those files included which they expect, and against which they were developed and tested. In call other cases, the files found in CMAKE_MODULE_PATH still take precedence over the ones in the CMake module directory. The OLD behaviour is to always prefer files from CMAKE_MODULE_PATH over files from the CMake modules direc‐ tory. This policy was introduced in CMake version 2.8.4. CMake version 2.8.9 warns when the policy is not set and uses OLD behavior. Use the cmake_policy command to set it to OLD or NEW explicitly. CMP0018 Ignore CMAKE_SHARED_LIBRARY_<Lang>_FLAGS variable. CMake 2.8.8 and lower compiled sources in SHARED and MODULE libraries using the value of the undocumented CMAKE_SHARED_LIBRARY_<Lang>_FLAGS platform variable. The variable contained platform-specific flags needed to compile objects for shared libraries. Typically it included a flag such as -fPIC for position independent code but also included other flags needed on certain platforms. CMake 2.8.9 and higher prefer instead to use the POSITION_INDEPENDENT_CODE target property to determine what targets should be position independent, and new undocumented plat‐ form variables to select flags while ignoring CMAKE_SHARED_LIBRARY_<Lang>_FLAGS completely. The default for either approach produces identical compilation flags, but if a project modifies CMAKE_SHARED_LIBRARY_<Lang>_FLAGS from its original value this policy determines which approach to use. The OLD behavior for this policy is to ignore the POSITION_INDE‐ PENDENT_CODE property for all targets and use the modified value of CMAKE_SHARED_LIBRARY_<Lang>_FLAGS for SHARED and MODULE libraries. The NEW behavior for this policy is to ignore CMAKE_SHARED_LIBRARY_<Lang>_FLAGS whether it is modified or not and honor the POSITION_INDEPENDENT_CODE target property. This policy was introduced in CMake version 2.8.9. CMake version 2.8.9 warns when the policy is not set and uses OLD behavior. Use the cmake_policy command to set it to OLD or NEW explicitly. VARIABLES VARIABLES THAT CHANGE BEHAVIOR BUILD_SHARED_LIBS Global flag to cause add_library to create shared libraries if on. If present and true, this will cause all libraries to be built shared unless the library was explicitly added as a static library. This variable is often added to projects as an OPTION so that each user of a project can decide if they want to build the project using shared or static libraries. CMAKE_ABSOLUTE_DESTINATION_FILES List of files which have been installed using an ABSOLUTE DESTI‐ NATION path. This variable is defined by CMake-generated cmake_install.cmake scripts. It can be used (read-only) by program or script that source those install scripts. This is used by some CPack genera‐ tors (e.g. RPM). CMAKE_AUTOMOC_RELAXED_MODE Switch between strict and relaxed automoc mode. By default, automoc behaves exactly as described in the documenta‐ tion of the AUTOMOC target property. When set to TRUE, it accepts more input and tries to find the correct input file for moc even if it differs from the documented behaviour. In this mode it e.g. also checks whether a header file is intended to be processed by moc when a "foo.moc" file has been included. Relaxed mode has to be enabled for KDE4 compatibility. CMAKE_BACKWARDS_COMPATIBILITY Version of cmake required to build project From the point of view of backwards compatibility, this specifies what version of CMake should be supported. By default this value is the version number of CMake that you are running. You can set this to an older version of CMake to support deprecated commands of CMake in projects that were written to use older versions of CMake. This can be set by the user or set at the beginning of a CMakeLists file. CMAKE_BUILD_TYPE Specifies the build type for make based generators. This specifies what build type will be built in this tree. Possi‐ ble values are empty, Debug, Release, RelWithDebInfo and MinSiz‐ eRel. This variable is only supported for make based generators. If this variable is supported, then CMake will also provide ini‐ tial values for the variables with the name CMAKE_C_FLAGS_[DEBUG|RELEASE|RELWITHDEBINFO|MINSIZEREL]. For exam‐ ple, if CMAKE_BUILD_TYPE is Debug, then CMAKE_C_FLAGS_DEBUG will be added to the CMAKE_C_FLAGS. CMAKE_COLOR_MAKEFILE Enables color output when using the Makefile generator. When enabled, the generated Makefiles will produce colored output. Default is ON. CMAKE_CONFIGURATION_TYPES Specifies the available build types. This specifies what build types will be available such as Debug, Release, RelWithDebInfo etc. This has reasonable defaults on most platforms. But can be extended to provide other build types. See also CMAKE_BUILD_TYPE. CMAKE_DISABLE_FIND_PACKAGE_<PackageName> Variable for disabling find_package() calls. Every non-REQUIRED find_package() call in a project can be dis‐ abled by setting the variable CMAKE_DISABLE_FIND_PACKAGE_<Package‐ Name> to TRUE. This can be used to build a project without an optional package, although that package is installed. This switch should be used during the initial CMake run. Otherwise if the package has already been found in a previous CMake run, the variables which have been stored in the cache will still be there. In the case it is recommended to remove the cache variables for this package from the cache using the cache editor or cmake -U CMAKE_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION Ask cmake_install.cmake script to error out as soon as a file with absolute INSTALL DESTINATION is encountered. The fatal error is emitted before the installation of the offend‐ ing file takes place. This variable is used by CMake-generated cmake_install.cmake scripts. If ones set this variable to ON while running the script, it may get fatal error messages from the script. CMAKE_FIND_LIBRARY_PREFIXES Prefixes to prepend when looking for libraries. This specifies what prefixes to add to library names when the find_library command looks for libraries. On UNIX systems this is typically lib, meaning that when trying to find the foo library it will look for libfoo. CMAKE_FIND_LIBRARY_SUFFIXES Suffixes to append when looking for libraries. This specifies what suffixes to add to library names when the find_library command looks for libraries. On Windows systems this is typically .lib and .dll, meaning that when trying to find the foo library it will look for foo.dll etc. CMAKE_FIND_PACKAGE_WARN_NO_MODULE Tell find_package to warn if called without an explicit mode. If find_package is called without an explicit mode option (MODULE, CONFIG or NO_MODULE) and no Find<pkg>.cmake module is in CMAKE_MODULE_PATH then CMake implicitly assumes that the caller intends to search for a package configuration file. If no package configuration file is found then the wording of the failure mes‐ sage must account for both the case that the package is really missing and the case that the project has a bug and failed to pro‐ vide the intended Find module. If instead the caller specifies an explicit mode option then the failure message can be more spe‐ cific. Set CMAKE_FIND_PACKAGE_WARN_NO_MODULE to TRUE to tell find_package to warn when it implicitly assumes Config mode. This helps devel‐ opers enforce use of an explicit mode in all calls to find_package within a project. CMAKE_IGNORE_PATH Path to be ignored by FIND_XXX() commands. Specifies directories to be ignored by searches in FIND_XXX() com‐ mands This is useful in cross-compiled environments where some system directories contain incompatible but possibly linkable libraries. For example, on cross-compiled cluster environments, this allows a user to ignore directories containing libraries meant for the front-end machine that modules like FindX11 (and others) would normally search. By default this is empty; it is intended to be set by the project. Note that CMAKE_IGNORE_PATH takes a list of directory names, NOT a list of prefixes. If you want to ignore paths under prefixes (bin, include, lib, etc.), you'll need to specify them explicitly. See also CMAKE_PRE‐ FIX_PATH, CMAKE_LIBRARY_PATH, CMAKE_INCLUDE_PATH, CMAKE_PRO‐ GRAM_PATH. CMAKE_INCLUDE_PATH Path used for searching by FIND_FILE() and FIND_PATH(). Specifies a path which will be used both by FIND_FILE() and FIND_PATH(). Both commands will check each of the contained direc‐ tories for the existence of the file which is currently searched. By default it is empty, it is intended to be set by the project. See also CMAKE_SYSTEM_INCLUDE_PATH, CMAKE_PREFIX_PATH. CMAKE_INSTALL_DEFAULT_COMPONENT_NAME Default component used in install() commands. If an install() command is used without the COMPONENT argument, these files will be grouped into a default component. The name of this default install component will be taken from this variable. It defaults to "Unspecified". CMAKE_INSTALL_PREFIX Install directory used by install. If "make install" is invoked or INSTALL is built, this directory is pre-pended onto all install directories. This variable defaults to /usr/local on UNIX and c:/Program Files on Windows. CMAKE_LIBRARY_PATH Path used for searching by FIND_LIBRARY(). Specifies a path which will be used by FIND_LIBRARY(). FIND_LIBRARY() will check each of the contained directories for the existence of the library which is currently searched. By default it is empty, it is intended to be set by the project. See also CMAKE_SYSTEM_LIBRARY_PATH, CMAKE_PREFIX_PATH. CMAKE_MFC_FLAG Tell cmake to use MFC for an executable or dll. This can be set in a CMakeLists.txt file and will enable MFC in the application. It should be set to 1 for static the static MFC library, and 2 for the shared MFC library. This is used in visual studio 6 and 7 project files. The CMakeSetup dialog used MFC and the CMakeLists.txt looks like this: add_definitions(-D_AFXDLL) set(CMAKE_MFC_FLAG 2) add_executable(CMakeSetup WIN32 ${SRCS}) CMAKE_MODULE_PATH List of directories to search for CMake modules. Commands like include() and find_package() search for files in directories listed by this variable before checking the default modules that come with CMake. CMAKE_NOT_USING_CONFIG_FLAGS Skip _BUILD_TYPE flags if true. This is an internal flag used by the generators in CMake to tell CMake to skip the _BUILD_TYPE flags. CMAKE_POLICY_DEFAULT_CMP<NNNN> Default for CMake Policy CMP<NNNN> when it is otherwise left unset. Commands cmake_minimum_required(VERSION) and cmake_policy(VERSION) by default leave policies introduced after the given version unset. Set CMAKE_POLICY_DEFAULT_CMP<NNNN> to OLD or NEW to spec‐ ify the default for policy CMP<NNNN>, where <NNNN> is the policy number. This variable should not be set by a project in CMake code; use cmake_policy(SET) instead. Users running CMake may set this vari‐ able in the cache (e.g. -DCMAKE_POL‐ ICY_DEFAULT_CMP<NNNN>=<OLD|NEW>) to set a policy not otherwise set by the project. Set to OLD to quiet a policy warning while using old behavior or to NEW to try building the project with new behav‐ ior. CMAKE_PREFIX_PATH Path used for searching by FIND_XXX(), with appropriate suffixes added. Specifies a path which will be used by the FIND_XXX() commands. It contains the "base" directories, the FIND_XXX() commands append appropriate subdirectories to the base directories. So FIND_PRO‐ GRAM() adds /bin to each of the directories in the path, FIND_LIBRARY() appends /lib to each of the directories, and FIND_PATH() and FIND_FILE() append /include . By default it is empty, it is intended to be set by the project. See also CMAKE_SYSTEM_PREFIX_PATH, CMAKE_INCLUDE_PATH, CMAKE_LIBRARY_PATH, CMAKE_PROGRAM_PATH. CMAKE_PROGRAM_PATH Path used for searching by FIND_PROGRAM(). Specifies a path which will be used by FIND_PROGRAM(). FIND_PRO‐ GRAM() will check each of the contained directories for the exis‐ tence of the program which is currently searched. By default it is empty, it is intended to be set by the project. See also CMAKE_SYSTEM_PROGRAM_PATH, CMAKE_PREFIX_PATH. CMAKE_SKIP_INSTALL_ALL_DEPENDENCY Don't make the install target depend on the all target. By default, the "install" target depends on the "all" target. This has the effect, that when "make install" is invoked or INSTALL is built, first the "all" target is built, then the installation starts. If CMAKE_SKIP_INSTALL_ALL_DEPENDENCY is set to TRUE, this dependency is not created, so the installation process will start immediately, independent from whether the project has been com‐ pletely built or not. CMAKE_SYSTEM_IGNORE_PATH Path to be ignored by FIND_XXX() commands. Specifies directories to be ignored by searches in FIND_XXX() com‐ mands This is useful in cross-compiled environments where some system directories contain incompatible but possibly linkable libraries. For example, on cross-compiled cluster environments, this allows a user to ignore directories containing libraries meant for the front-end machine that modules like FindX11 (and others) would normally search. By default this contains a list of directories containing incompatible binaries for the host system. See also CMAKE_SYSTEM_PREFIX_PATH, CMAKE_SYSTEM_LIBRARY_PATH, CMAKE_SYSTEM_INCLUDE_PATH, and CMAKE_SYSTEM_PROGRAM_PATH. CMAKE_SYSTEM_INCLUDE_PATH Path used for searching by FIND_FILE() and FIND_PATH(). Specifies a path which will be used both by FIND_FILE() and FIND_PATH(). Both commands will check each of the contained direc‐ tories for the existence of the file which is currently searched. By default it contains the standard directories for the current system. It is NOT intended to be modified by the project, use CMAKE_INCLUDE_PATH for this. See also CMAKE_SYSTEM_PREFIX_PATH. CMAKE_SYSTEM_LIBRARY_PATH Path used for searching by FIND_LIBRARY(). Specifies a path which will be used by FIND_LIBRARY(). FIND_LIBRARY() will check each of the contained directories for the existence of the library which is currently searched. By default it contains the standard directories for the current sys‐ tem. It is NOT intended to be modified by the project, use CMAKE_LIBRARY_PATH for this. See also CMAKE_SYSTEM_PREFIX_PATH. CMAKE_SYSTEM_PREFIX_PATH Path used for searching by FIND_XXX(), with appropriate suffixes added. Specifies a path which will be used by the FIND_XXX() commands. It contains the "base" directories, the FIND_XXX() commands append appropriate subdirectories to the base directories. So FIND_PRO‐ GRAM() adds /bin to each of the directories in the path, FIND_LIBRARY() appends /lib to each of the directories, and FIND_PATH() and FIND_FILE() append /include . By default this con‐ tains the standard directories for the current system. It is NOT intended to be modified by the project, use CMAKE_PREFIX_PATH for this. See also CMAKE_SYSTEM_INCLUDE_PATH, CMAKE_SYS‐ TEM_LIBRARY_PATH, CMAKE_SYSTEM_PROGRAM_PATH, and CMAKE_SYS‐ TEM_IGNORE_PATH. CMAKE_SYSTEM_PROGRAM_PATH Path used for searching by FIND_PROGRAM(). Specifies a path which will be used by FIND_PROGRAM(). FIND_PRO‐ GRAM() will check each of the contained directories for the exis‐ tence of the program which is currently searched. By default it contains the standard directories for the current system. It is NOT intended to be modified by the project, use CMAKE_PROGRAM_PATH for this. See also CMAKE_SYSTEM_PREFIX_PATH. CMAKE_USER_MAKE_RULES_OVERRIDE Specify a CMake file that overrides platform information. CMake loads the specified file while enabling support for each language from either the project() or enable_language() commands. It is loaded after CMake's builtin compiler and platform informa‐ tion modules have been loaded but before the information is used. The file may set platform information variables to override CMake's defaults. This feature is intended for use only in overriding information variables that must be set before CMake builds its first test project to check that the compiler for a language works. It should not be used to load a file in cases that a normal include() will work. Use it only as a last resort for behavior that cannot be achieved any other way. For example, one may set CMAKE_C_FLAGS_INIT to change the default value used to initialize CMAKE_C_FLAGS before it is cached. The override file should NOT be used to set anything that could be set after languages are enabled, such as variables like CMAKE_RUNTIME_OUTPUT_DIRECTORY that affect the placement of binaries. Information set in the file will be used for try_compile and try_run builds too. CMAKE_WARN_ON_ABSOLUTE_INSTALL_DESTINATION Ask cmake_install.cmake script to warn each time a file with abso‐ lute INSTALL DESTINATION is encountered. This variable is used by CMake-generated cmake_install.cmake scripts. If ones set this variable to ON while running the script, it may get warning messages from the script. VARIABLES THAT DESCRIBE THE SYSTEM APPLE True if running on Mac OSX. Set to true on Mac OSX. BORLAND True if the borland compiler is being used. This is set to true if the Borland compiler is being used. CMAKE_CL_64 Using the 64 bit compiler from Microsoft Set to true when using the 64 bit cl compiler from Microsoft. CMAKE_COMPILER_2005 Using the Visual Studio 2005 compiler from Microsoft Set to true when using the Visual Studio 2005 compiler from Micro‐ soft. CMAKE_HOST_APPLE True for Apple OSXoperating systems. Set to true when the host system is Apple OSX. CMAKE_HOST_SYSTEM Name of system cmake is being run on. The same as CMAKE_SYSTEM but for the host system instead of the target system when cross compiling. CMAKE_HOST_SYSTEM_NAME Name of the OS CMake is running on. The same as CMAKE_SYSTEM_NAME but for the host system instead of the target system when cross compiling. CMAKE_HOST_SYSTEM_PROCESSOR The name of the CPU CMake is running on. The same as CMAKE_SYSTEM_PROCESSOR but for the host system instead of the target system when cross compiling. CMAKE_HOST_SYSTEM_VERSION OS version CMake is running on. The same as CMAKE_SYSTEM_VERSION but for the host system instead of the target system when cross compiling. CMAKE_HOST_UNIX True for UNIX and UNIX like operating systems. Set to true when the host system is UNIX or UNIX like (i.e. APPLE and CYGWIN). CMAKE_HOST_WIN32 True on windows systems, including win64. Set to true when the host system is Windows and on cygwin. CMAKE_LIBRARY_ARCHITECTURE Target architecture library directory name, if detected. This is the value of CMAKE_<lang>_LIBRARY_ARCHITECTURE as detected for one of the enabled languages. CMAKE_LIBRARY_ARCHITECTURE_REGEX Regex matching possible target architecture library directory names. This is used to detect CMAKE_<lang>_LIBRARY_ARCHITECTURE from the implicit linker search path by matching the <arch> name. CMAKE_OBJECT_PATH_MAX Maximum object file full-path length allowed by native build tools. CMake computes for every source file an object file name that is unique to the source file and deterministic with respect to the full path to the source file. This allows multiple source files in a target to share the same name if they lie in different direc‐ tories without rebuilding when one is added or removed. However, it can produce long full paths in a few cases, so CMake shortens the path using a hashing scheme when the full path to an object file exceeds a limit. CMake has a built-in limit for each plat‐ form that is sufficient for common tools, but some native tools may have a lower limit. This variable may be set to specify the limit explicitly. The value must be an integer no less than 128. CMAKE_SYSTEM Name of system cmake is compiling for. This variable is the composite of CMAKE_SYSTEM_NAME and CMAKE_SYS‐ TEM_VERSION, like this ${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_VER‐ SION}. If CMAKE_SYSTEM_VERSION is not set, then CMAKE_SYSTEM is the same as CMAKE_SYSTEM_NAME. CMAKE_SYSTEM_NAME Name of the OS CMake is building for. This is the name of the operating system on which CMake is target‐ ing. On systems that have the uname command, this variable is set to the output of uname -s. Linux, Windows, and Darwin for Mac OSX are the values found on the big three operating systems. CMAKE_SYSTEM_PROCESSOR The name of the CPU CMake is building for. On systems that support uname, this variable is set to the output of uname -p, on windows it is set to the value of the environment variable PROCESSOR_ARCHITECTURE CMAKE_SYSTEM_VERSION OS version CMake is building for. A numeric version string for the system, on systems that support uname, this variable is set to the output of uname -r. On other systems this is set to major-minor version numbers. CYGWIN True for cygwin. Set to true when using CYGWIN. MSVC True when using Microsoft Visual C Set to true when the compiler is some version of Microsoft Visual C. MSVC80 True when using Microsoft Visual C 8.0 Set to true when the compiler is version 8.0 of Microsoft Visual C. MSVC_IDE True when using the Microsoft Visual C IDE Set to true when the target platform is the Microsoft Visual C IDE, as opposed to the command line compiler. MSVC_VERSION The version of Microsoft Visual C/C++ being used if any. Known version numbers are: 1200 = VS 6.0 1300 = VS 7.0 1310 = VS 7.1 1400 = VS 8.0 1500 = VS 9.0 1600 = VS 10.0 UNIX True for UNIX and UNIX like operating systems. Set to true when the target system is UNIX or UNIX like (i.e. APPLE and CYGWIN). WIN32 True on windows systems, including win64. Set to true when the target system is Windows. XCODE_VERSION Version of Xcode (Xcode generator only). Under the Xcode generator, this is the version of Xcode as speci‐ fied in "Xcode.app/Contents/version.plist" (such as "3.1.2"). VARIABLES FOR LANGUAGES CMAKE_<LANG>_ARCHIVE_APPEND Rule variable to append to a static archive. This is a rule variable that tells CMake how to append to a static archive. It is used in place of CMAKE_<LANG>_CRE‐ ATE_STATIC_LIBRARY on some platforms in order to support large object counts. See also CMAKE_<LANG>_ARCHIVE_CREATE and CMAKE_<LANG>_ARCHIVE_FINISH. CMAKE_<LANG>_ARCHIVE_CREATE Rule variable to create a new static archive. This is a rule variable that tells CMake how to create a static archive. It is used in place of CMAKE_<LANG>_CRE‐ ATE_STATIC_LIBRARY on some platforms in order to support large object counts. See also CMAKE_<LANG>_ARCHIVE_APPEND and CMAKE_<LANG>_ARCHIVE_FINISH. CMAKE_<LANG>_ARCHIVE_FINISH Rule variable to finish an existing static archive. This is a rule variable that tells CMake how to finish a static archive. It is used in place of CMAKE_<LANG>_CRE‐ ATE_STATIC_LIBRARY on some platforms in order to support large object counts. See also CMAKE_<LANG>_ARCHIVE_CREATE and CMAKE_<LANG>_ARCHIVE_APPEND. CMAKE_<LANG>_COMPILER The full path to the compiler for LANG. This is the command that will be used as the <LANG> compiler. Once set, you can not change this variable. CMAKE_<LANG>_COMPILER_ABI An internal variable subject to change. This is used in determining the compiler ABI and is subject to change. CMAKE_<LANG>_COMPILER_ID An internal variable subject to change. This is used in determining the compiler and is subject to change. CMAKE_<LANG>_COMPILER_LOADED Defined to true if the language is enabled. When language <LANG> is enabled by project() or enable_language() this variable is defined to 1. CMAKE_<LANG>_COMPILER_VERSION An internal variable subject to change. Compiler version in major[.minor[.patch[.tweak]]] format. This variable is reserved for internal use by CMake and is not guaran‐ teed to be set. CMAKE_<LANG>_COMPILE_OBJECT Rule variable to compile a single object file. This is a rule variable that tells CMake how to compile a single object file for for the language <LANG>. CMAKE_<LANG>_CREATE_SHARED_LIBRARY Rule variable to create a shared library. This is a rule variable that tells CMake how to create a shared library for the language <LANG>. CMAKE_<LANG>_CREATE_SHARED_MODULE Rule variable to create a shared module. This is a rule variable that tells CMake how to create a shared library for the language <LANG>. CMAKE_<LANG>_CREATE_STATIC_LIBRARY Rule variable to create a static library. This is a rule variable that tells CMake how to create a static library for the language <LANG>. CMAKE_<LANG>_FLAGS_DEBUG Flags for Debug build type or configuration. <LANG> flags used when CMAKE_BUILD_TYPE is Debug. CMAKE_<LANG>_FLAGS_MINSIZEREL Flags for MinSizeRel build type or configuration. <LANG> flags used when CMAKE_BUILD_TYPE is MinSizeRel.Short for minimum size release. CMAKE_<LANG>_FLAGS_RELEASE Flags for Release build type or configuration. <LANG> flags used when CMAKE_BUILD_TYPE is Release CMAKE_<LANG>_FLAGS_RELWITHDEBINFO Flags for RelWithDebInfo type or configuration. <LANG> flags used when CMAKE_BUILD_TYPE is RelWithDebInfo. Short for Release With Debug Information. CMAKE_<LANG>_IGNORE_EXTENSIONS File extensions that should be ignored by the build. This is a list of file extensions that may be part of a project for a given language but are not compiled. CMAKE_<LANG>_IMPLICIT_INCLUDE_DIRECTORIES Directories implicitly searched by the compiler for header files. CMake does not explicitly specify these directories on compiler command lines for language <LANG>. This prevents system include directories from being treated as user include directories on some compilers. CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES Implicit linker search path detected for language <LANG>. Compilers typically pass directories containing language runtime libraries and default library search paths when they invoke a linker. These paths are implicit linker search directories for the compiler's language. CMake automatically detects these direc‐ tories for each language and reports the results in this variable. CMAKE_<LANG>_IMPLICIT_LINK_LIBRARIES Implicit link libraries and flags detected for language <LANG>. Compilers typically pass language runtime library names and other flags when they invoke a linker. These flags are implicit link options for the compiler's language. CMake automatically detects these libraries and flags for each language and reports the results in this variable. CMAKE_<LANG>_LIBRARY_ARCHITECTURE Target architecture library directory name detected for <lang>. If the <lang> compiler passes to the linker an architecture-spe‐ cific system library search directory such as <prefix>/lib/<arch> this variable contains the <arch> name if/as detected by CMake. CMAKE_<LANG>_LINKER_PREFERENCE Preference value for linker language selection. The "linker language" for executable, shared library, and module targets is the language whose compiler will invoke the linker. The LINKER_LANGUAGE target property sets the language explicitly. Otherwise, the linker language is that whose linker preference value is highest among languages compiled and linked into the tar‐ get. See also the CMAKE_<LANG>_LINKER_PREFERENCE_PROPAGATES vari‐ able. CMAKE_<LANG>_LINKER_PREFERENCE_PROPAGATES True if CMAKE_<LANG>_LINKER_PREFERENCE propagates across targets. This is used when CMake selects a linker language for a target. Languages compiled directly into the target are always considered. A language compiled into static libraries linked by the target is considered if this variable is true. CMAKE_<LANG>_LINK_EXECUTABLE Rule variable to link and executable. Rule variable to link and executable for the given language. CMAKE_<LANG>_OUTPUT_EXTENSION Extension for the output of a compile for a single file. This is the extension for an object file for the given <LANG>. For example .obj for C on Windows. CMAKE_<LANG>_PLATFORM_ID An internal variable subject to change. This is used in determining the platform and is subject to change. CMAKE_<LANG>_SIZEOF_DATA_PTR Size of pointer-to-data types for language <LANG>. This holds the size (in bytes) of pointer-to-data types in the target platform ABI. It is defined for languages C and CXX (C++). CMAKE_<LANG>_SOURCE_FILE_EXTENSIONS Extensions of source files for the given language. This is the list of extensions for a given languages source files. CMAKE_COMPILER_IS_GNU<LANG> True if the compiler is GNU. If the selected <LANG> compiler is the GNU compiler then this is TRUE, if not it is FALSE. CMAKE_Fortran_MODDIR_DEFAULT Fortran default module output directory. Most Fortran compilers write .mod files to the current working directory. For those that do not, this is set to "." and used when the Fortran_MODULE_DIRECTORY target property is not set. CMAKE_Fortran_MODDIR_FLAG Fortran flag for module output directory. This stores the flag needed to pass the value of the Fortran_MOD‐ ULE_DIRECTORY target property to the compiler. CMAKE_Fortran_MODOUT_FLAG Fortran flag to enable module output. Most Fortran compilers write .mod files out by default. For oth‐ ers, this stores the flag needed to enable module output. CMAKE_INTERNAL_PLATFORM_ABI An internal variable subject to change. This is used in determining the compiler ABI and is subject to change. CMAKE_USER_MAKE_RULES_OVERRIDE_<LANG> Specify a CMake file that overrides platform information for <LANG>. This is a language-specific version of CMAKE_USER_MAKE_RULES_OVER‐ RIDE loaded only when enabling language <LANG>. VARIABLES THAT CONTROL THE BUILD CMAKE_<CONFIG>_POSTFIX Default filename postfix for libraries under configuration <CON‐ FIG>. When a non-executable target is created its <CONFIG>_POSTFIX tar‐ get property is initialized with the value of this variable if it is set. CMAKE_ARCHIVE_OUTPUT_DIRECTORY Where to put all the ARCHIVE targets when built. This variable is used to initialize the ARCHIVE_OUTPUT_DIRECTORY property on all the targets. See that target property for addi‐ tional information. CMAKE_AUTOMOC Whether to handle moc automatically for Qt targets. This variable is used to initialize the AUTOMOC property on all the targets. See that target property for additional information. CMAKE_AUTOMOC_MOC_OPTIONS Additional options for moc when using automoc (see CMAKE_AUTOMOC). This variable is used to initialize the AUTOMOC_MOC_OPTIONS prop‐ erty on all the targets. See that target property for additional information. CMAKE_BUILD_WITH_INSTALL_RPATH Use the install path for the RPATH Normally CMake uses the build tree for the RPATH when building executables etc on systems that use RPATH. When the software is installed the executables etc are relinked by CMake to have the install RPATH. If this variable is set to true then the software is always built with the install path for the RPATH and does not need to be relinked when installed. CMAKE_DEBUG_POSTFIX See variable CMAKE_<CONFIG>_POSTFIX. This variable is a special case of the more-general CMAKE_<CON‐ FIG>_POSTFIX variable for the DEBUG configuration. CMAKE_EXE_LINKER_FLAGS Linker flags used to create executables. Flags used by the linker when creating an executable. CMAKE_EXE_LINKER_FLAGS_[CMAKE_BUILD_TYPE] Flag used when linking an executable. Same as CMAKE_C_FLAGS_* but used by the linker when creating exe‐ cutables. CMAKE_Fortran_FORMAT Set to FIXED or FREE to indicate the Fortran source layout. This variable is used to initialize the Fortran_FORMAT property on all the targets. See that target property for additional informa‐ tion. CMAKE_Fortran_MODULE_DIRECTORY Fortran module output directory. This variable is used to initialize the Fortran_MODULE_DIRECTORY property on all the targets. See that target property for addi‐ tional information. CMAKE_GNUtoMS Convert GNU import libraries (.dll.a) to MS format (.lib). This variable is used to initialize the GNUtoMS property on tar‐ gets when they are created. See that target property for addi‐ tional information. CMAKE_INCLUDE_CURRENT_DIR Automatically add the current source- and build directories to the include path. If this variable is enabled, CMake automatically adds in each directory ${CMAKE_CURRENT_SOURCE_DIR} and ${CMAKE_CUR‐ RENT_BINARY_DIR} to the include path for this directory. These additional include directories do not propagate down to subdirec‐ tories. This is useful mainly for out-of-source builds, where files generated into the build tree are included by files located in the source tree. By default CMAKE_INCLUDE_CURRENT_DIR is OFF. CMAKE_INSTALL_NAME_DIR Mac OSX directory name for installed targets. CMAKE_INSTALL_NAME_DIR is used to initialize the INSTALL_NAME_DIR property on all targets. See that target property for more infor‐ mation. CMAKE_INSTALL_RPATH The rpath to use for installed targets. A semicolon-separated list specifying the rpath to use in installed targets (for platforms that support it). This is used to initialize the target property INSTALL_RPATH for all targets. CMAKE_INSTALL_RPATH_USE_LINK_PATH Add paths to linker search and installed rpath. CMAKE_INSTALL_RPATH_USE_LINK_PATH is a boolean that if set to true will append directories in the linker search path and outside the project to the INSTALL_RPATH. This is used to initialize the tar‐ get property INSTALL_RPATH_USE_LINK_PATH for all targets. CMAKE_LIBRARY_OUTPUT_DIRECTORY Where to put all the LIBRARY targets when built. This variable is used to initialize the LIBRARY_OUTPUT_DIRECTORY property on all the targets. See that target property for addi‐ tional information. CMAKE_LIBRARY_PATH_FLAG The flag used to add a library search path to a compiler. The flag used to specify a library directory to the compiler. On most compilers this is "-L". CMAKE_LINK_DEF_FILE_FLAG Linker flag used to specify a .def file for dll creation. The flag used to add a .def file when creating a dll on Windows, this is only defined on Windows. CMAKE_LINK_INTERFACE_LIBRARIES Default value for LINK_INTERFACE_LIBRARIES of targets. This variable is used to initialize the LINK_INTERFACE_LIBRARIES property on all the targets. See that target property for addi‐ tional information. CMAKE_LINK_LIBRARY_FILE_FLAG Flag used to link a library specified by a path to its file. The flag used before a library file path is given to the linker. This is needed only on very few platforms. CMAKE_LINK_LIBRARY_FLAG Flag used to link a library into an executable. The flag used to specify a library to link to an executable. On most compilers this is "-l". CMAKE_MACOSX_BUNDLE Default value for MACOSX_BUNDLE of targets. This variable is used to initialize the MACOSX_BUNDLE property on all the targets. See that target property for additional informa‐ tion. CMAKE_NO_BUILTIN_CHRPATH Do not use the builtin ELF editor to fix RPATHs on installation. When an ELF binary needs to have a different RPATH after installa‐ tion than it does in the build tree, CMake uses a builtin editor to change the RPATH in the installed copy. If this variable is set to true then CMake will relink the binary before installation instead of using its builtin editor. CMAKE_POSITION_INDEPENDENT_FLAGS Default value for POSITION_INDEPENDENT_CODE of targets. This variable is used to initialize the POSITION_INDEPENDENT_CODE property on all the targets. See that target property for addi‐ tional information. CMAKE_RUNTIME_OUTPUT_DIRECTORY Where to put all the RUNTIME targets when built. This variable is used to initialize the RUNTIME_OUTPUT_DIRECTORY property on all the targets. See that target property for addi‐ tional information. CMAKE_SKIP_BUILD_RPATH Do not include RPATHs in the build tree. Normally CMake uses the build tree for the RPATH when building executables etc on systems that use RPATH. When the software is installed the executables etc are relinked by CMake to have the install RPATH. If this variable is set to true then the software is always built with no RPATH. CMAKE_SKIP_INSTALL_RPATH Do not include RPATHs in the install tree. Normally CMake uses the build tree for the RPATH when building executables etc on systems that use RPATH. When the software is installed the executables etc are relinked by CMake to have the install RPATH. If this variable is set to true then the software is always installed without RPATH, even if RPATH is enabled when building. This can be useful for example to allow running tests from the build directory with RPATH enabled before the installa‐ tion step. To omit RPATH in both the build and install steps, use CMAKE_SKIP_RPATH instead. CMAKE_TRY_COMPILE_CONFIGURATION Build configuration used for try_compile and try_run projects. Projects built by try_compile and try_run are built synchronously during the CMake configuration step. Therefore a specific build configuration must be chosen even if the generated build system supports multiple configurations. CMAKE_USE_RELATIVE_PATHS Use relative paths (May not work!). If this is set to TRUE, then the CMake will use relative paths between the source and binary tree. This option does not work for more complicated projects, and relative paths are used when possi‐ ble. In general, it is not possible to move CMake generated make‐ files to a different location regardless of the value of this variable. CMAKE_WIN32_EXECUTABLE Default value for WIN32_EXECUTABLE of targets. This variable is used to initialize the WIN32_EXECUTABLE property on all the targets. See that target property for additional infor‐ mation. EXECUTABLE_OUTPUT_PATH Old executable location variable. The target property RUNTIME_OUTPUT_DIRECTORY supercedes this vari‐ able for a target if it is set. Executable targets are otherwise placed in this directory. LIBRARY_OUTPUT_PATH Old library location variable. The target properties ARCHIVE_OUTPUT_DIRECTORY, LIBRARY_OUT‐ PUT_DIRECTORY, and RUNTIME_OUTPUT_DIRECTORY supercede this vari‐ able for a target if they are set. Library targets are otherwise placed in this directory. VARIABLES THAT PROVIDE INFORMATION variables defined by cmake, that give information about the project, and cmake CMAKE_AR Name of archiving tool for static libraries. This specifies name of the program that creates archive or static libraries. CMAKE_ARGC Number of command line arguments passed to CMake in script mode. When run in -P script mode, CMake sets this variable to the number of command line arguments. See also CMAKE_ARGV0, 1, 2 ... CMAKE_ARGV0 Command line argument passed to CMake in script mode. When run in -P script mode, CMake sets this variable to the first command line argument. It then also sets CMAKE_ARGV1, CMAKE_ARGV2, ... and so on, up to the number of command line arguments given. See also CMAKE_ARGC. CMAKE_BINARY_DIR The path to the top level of the build tree. This is the full path to the top level of the current CMake build tree. For an in-source build, this would be the same as CMAKE_SOURCE_DIR. CMAKE_BUILD_TOOL Tool used for the actual build process. This variable is set to the program that will be needed to build the output of CMake. If the generator selected was Visual Studio 6, the CMAKE_BUILD_TOOL will be set to msdev, for Unix makefiles it will be set to make or gmake, and for Visual Studio 7 it set to devenv. For Nmake Makefiles the value is nmake. This can be use‐ ful for adding special flags and commands based on the final build environment. CMAKE_CACHEFILE_DIR The directory with the CMakeCache.txt file. This is the full path to the directory that has the CMakeCache.txt file in it. This is the same as CMAKE_BINARY_DIR. CMAKE_CACHE_MAJOR_VERSION Major version of CMake used to create the CMakeCache.txt file This is stores the major version of CMake used to write a CMake cache file. It is only different when a different version of CMake is run on a previously created cache file. CMAKE_CACHE_MINOR_VERSION Minor version of CMake used to create the CMakeCache.txt file This is stores the minor version of CMake used to write a CMake cache file. It is only different when a different version of CMake is run on a previously created cache file. CMAKE_CACHE_PATCH_VERSION Patch version of CMake used to create the CMakeCache.txt file This is stores the patch version of CMake used to write a CMake cache file. It is only different when a different version of CMake is run on a previously created cache file. CMAKE_CFG_INTDIR Build-time reference to per-configuration output subdirectory. For native build systems supporting multiple configurations in the build tree (such as Visual Studio and Xcode), the value is a ref‐ erence to a build-time variable specifying the name of the per-configuration output subdirectory. On Makefile generators this evaluates to "." because there is only one configuration in a build tree. Example values: $(IntDir) = Visual Studio 6 $(OutDir) = Visual Studio 7, 8, 9 $(Configuration) = Visual Studio 10 $(CONFIGURATION) = Xcode . = Make-based tools Since these values are evaluated by the native build system, this variable is suitable only for use in command lines that will be evaluated at build time. Example of intended usage: add_executable(mytool mytool.c) add_custom_command( OUTPUT out.txt COMMAND ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/mytool ${CMAKE_CURRENT_SOURCE_DIR}/in.txt out.txt DEPENDS mytool in.txt ) add_custom_target(drive ALL DEPENDS out.txt) Note that CMAKE_CFG_INTDIR is no longer necessary for this purpose but has been left for compatibility with existing projects. Instead add_custom_command() recognizes executable target names in its COMMAND option, so "${CMAKE_CUR‐ RENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/mytool" can be replaced by just "mytool". This variable is read-only. Setting it is undefined behavior. In multi-configuration build systems the value of this variable is passed as the value of preprocessor symbol "CMAKE_INTDIR" to the compilation of all source files. CMAKE_COMMAND The full path to the cmake executable. This is the full path to the CMake executable cmake which is use‐ ful from custom commands that want to use the cmake -E option for portable system commands. (e.g. /usr/local/bin/cmake CMAKE_CROSSCOMPILING Is CMake currently cross compiling. This variable will be set to true by CMake if CMake is cross com‐ piling. Specifically if the build platform is different from the target platform. CMAKE_CTEST_COMMAND Full path to ctest command installed with cmake. This is the full path to the CTest executable ctest which is use‐ ful from custom commands that want to use the cmake -E option for portable system commands. CMAKE_CURRENT_BINARY_DIR The path to the binary directory currently being processed. This the full path to the build directory that is currently being processed by cmake. Each directory added by add_subdirectory will create a binary directory in the build tree, and as it is being processed this variable will be set. For in-source builds this is the current source directory being processed. CMAKE_CURRENT_LIST_DIR Full directory of the listfile currently being processed. As CMake processes the listfiles in your project this variable will always be set to the directory where the listfile which is currently being processed (CMAKE_CURRENT_LIST_FILE) is located. The value has dynamic scope. When CMake starts processing com‐ mands in a source file it sets this variable to the directory where this file is located. When CMake finishes processing com‐ mands from the file it restores the previous value. Therefore the value of the variable inside a macro or function is the directory of the file invoking the bottom-most entry on the call stack, not the directory of the file containing the macro or function defini‐ tion. See also CMAKE_CURRENT_LIST_FILE. CMAKE_CURRENT_LIST_FILE Full path to the listfile currently being processed. As CMake processes the listfiles in your project this variable will always be set to the one currently being processed. The value has dynamic scope. When CMake starts processing commands in a source file it sets this variable to the location of the file. When CMake finishes processing commands from the file it restores the previous value. Therefore the value of the variable inside a macro or function is the file invoking the bottom-most entry on the call stack, not the file containing the macro or function def‐ inition. See also CMAKE_PARENT_LIST_FILE. CMAKE_CURRENT_LIST_LINE The line number of the current file being processed. This is the line number of the file currently being processed by cmake. CMAKE_CURRENT_SOURCE_DIR The path to the source directory currently being processed. This the full path to the source directory that is currently being processed by cmake. CMAKE_DL_LIBS Name of library containing dlopen and dlcose. The name of the library that has dlopen and dlclose in it, usually -ldl on most UNIX machines. CMAKE_EDIT_COMMAND Full path to cmake-gui or ccmake. This is the full path to the CMake executable that can graphically edit the cache. For example, cmake-gui, ccmake, or cmake -i. CMAKE_EXECUTABLE_SUFFIX The suffix for executables on this platform. The suffix to use for the end of an executable if any, .exe on Windows. CMAKE_EXECUTABLE_SUFFIX_<LANG> overrides this for language <LANG>. CMAKE_EXTRA_GENERATOR The extra generator used to build the project. When using the Eclipse, CodeBlocks or KDevelop generators, CMake generates Makefiles (CMAKE_GENERATOR) and additionally project files for the respective IDE. This IDE project file generator is stored in CMAKE_EXTRA_GENERATOR (e.g. "Eclipse CDT4"). CMAKE_EXTRA_SHARED_LIBRARY_SUFFIXES Additional suffixes for shared libraries. Extensions for shared libraries other than that specified by CMAKE_SHARED_LIBRARY_SUFFIX, if any. CMake uses this to recognize external shared library files during analysis of libraries linked by a target. CMAKE_GENERATOR The generator used to build the project. The name of the generator that is being used to generate the build files. (e.g. "Unix Makefiles", "Visual Studio 6", etc.) CMAKE_HOME_DIRECTORY Path to top of source tree. This is the path to the top level of the source tree. CMAKE_IMPORT_LIBRARY_PREFIX The prefix for import libraries that you link to. The prefix to use for the name of an import library if used on this platform. CMAKE_IMPORT_LIBRARY_PREFIX_<LANG> overrides this for language <LANG>. CMAKE_IMPORT_LIBRARY_SUFFIX The suffix for import libraries that you link to. The suffix to use for the end of an import library if used on this platform. CMAKE_IMPORT_LIBRARY_SUFFIX_<LANG> overrides this for language <LANG>. CMAKE_LINK_LIBRARY_SUFFIX The suffix for libraries that you link to. The suffix to use for the end of a library, .lib on Windows. CMAKE_MAJOR_VERSION The Major version of cmake (i.e. the 2 in 2.X.X) This specifies the major version of the CMake executable being run. CMAKE_MAKE_PROGRAM See CMAKE_BUILD_TOOL. This variable is around for backwards compatibility, see CMAKE_BUILD_TOOL. CMAKE_MINOR_VERSION The Minor version of cmake (i.e. the 4 in X.4.X). This specifies the minor version of the CMake executable being run. CMAKE_PARENT_LIST_FILE Full path to the parent listfile of the one currently being pro‐ cessed. As CMake processes the listfiles in your project this variable will always be set to the listfile that included or somehow invoked the one currently being processed. See also CMAKE_CUR‐ RENT_LIST_FILE. CMAKE_PATCH_VERSION The patch version of cmake (i.e. the 3 in X.X.3). This specifies the patch version of the CMake executable being run. CMAKE_PROJECT_NAME The name of the current project. This specifies name of the current project from the closest inher‐ ited PROJECT command. CMAKE_RANLIB Name of randomizing tool for static libraries. This specifies name of the program that randomizes libraries on UNIX, not used on Windows, but may be present. CMAKE_ROOT Install directory for running cmake. This is the install root for the running CMake and the Modules directory can be found here. This is commonly used in this format: ${CMAKE_ROOT}/Modules CMAKE_SCRIPT_MODE_FILE Full path to the -P script file currently being processed. When run in -P script mode, CMake sets this variable to the full path of the script file. When run to configure a CMakeLists.txt file, this variable is not set. CMAKE_SHARED_LIBRARY_PREFIX The prefix for shared libraries that you link to. The prefix to use for the name of a shared library, lib on UNIX. CMAKE_SHARED_LIBRARY_PREFIX_<LANG> overrides this for language <LANG>. CMAKE_SHARED_LIBRARY_SUFFIX The suffix for shared libraries that you link to. The suffix to use for the end of a shared library, .dll on Win‐ dows. CMAKE_SHARED_LIBRARY_SUFFIX_<LANG> overrides this for language <LANG>. CMAKE_SHARED_MODULE_PREFIX The prefix for loadable modules that you link to. The prefix to use for the name of a loadable module on this plat‐ form. CMAKE_SHARED_MODULE_PREFIX_<LANG> overrides this for language <LANG>. CMAKE_SHARED_MODULE_SUFFIX The suffix for shared libraries that you link to. The suffix to use for the end of a loadable module on this plat‐ form CMAKE_SHARED_MODULE_SUFFIX_<LANG> overrides this for language <LANG>. CMAKE_SIZEOF_VOID_P Size of a void pointer. This is set to the size of a pointer on the machine, and is deter‐ mined by a try compile. If a 64 bit size is found, then the library search path is modified to look for 64 bit libraries first. CMAKE_SKIP_RPATH If true, do not add run time path information. If this is set to TRUE, then the rpath information is not added to compiled executables. The default is to add rpath information if the platform supports it. This allows for easy running from the build tree. To omit RPATH in the install step, but not the build step, use CMAKE_SKIP_INSTALL_RPATH instead. CMAKE_SOURCE_DIR The path to the top level of the source tree. This is the full path to the top level of the current CMake source tree. For an in-source build, this would be the same as CMAKE_BINARY_DIR. CMAKE_STANDARD_LIBRARIES Libraries linked into every executable and shared library. This is the list of libraries that are linked into all executables and libraries. CMAKE_STATIC_LIBRARY_PREFIX The prefix for static libraries that you link to. The prefix to use for the name of a static library, lib on UNIX. CMAKE_STATIC_LIBRARY_PREFIX_<LANG> overrides this for language <LANG>. CMAKE_STATIC_LIBRARY_SUFFIX The suffix for static libraries that you link to. The suffix to use for the end of a static library, .lib on Win‐ dows. CMAKE_STATIC_LIBRARY_SUFFIX_<LANG> overrides this for language <LANG>. CMAKE_TWEAK_VERSION The tweak version of cmake (i.e. the 1 in X.X.X.1). This specifies the tweak version of the CMake executable being run. Releases use tweak < 20000000 and development versions use the date format CCYYMMDD for the tweak level. CMAKE_USING_VC_FREE_TOOLS True if free visual studio tools being used. This is set to true if the compiler is Visual Studio free tools. CMAKE_VERBOSE_MAKEFILE Create verbose makefiles if on. This variable defaults to false. You can set this variable to true to make CMake produce verbose makefiles that show each command line as it is used. CMAKE_VERSION The full version of cmake in major.minor.patch[.tweak[-id]] for‐ mat. This specifies the full version of the CMake executable being run. This variable is defined by versions 2.6.3 and higher. See vari‐ ables CMAKE_MAJOR_VERSION, CMAKE_MINOR_VERSION, CMAKE_PATCH_VER‐ SION, and CMAKE_TWEAK_VERSION for individual version components. The [-id] component appears in non-release versions and may be arbitrary text. PROJECT_BINARY_DIR Full path to build directory for project. This is the binary directory of the most recent PROJECT command. PROJECT_NAME Name of the project given to the project command. This is the name given to the most recent PROJECT command. PROJECT_SOURCE_DIR Top level source directory for the current project. This is the source directory of the most recent PROJECT command. [Project name]_BINARY_DIR Top level binary directory for the named project. A variable is created with the name used in the PROJECT command, and is the binary directory for the project. This can be useful when SUBDIR is used to connect several projects. [Project name]_SOURCE_DIR Top level source directory for the named project. A variable is created with the name used in the PROJECT command, and is the source directory for the project. This can be useful when add_subdirectory is used to connect several projects. COPYRIGHT Copyright 2000-2009 Kitware, Inc., Insight Software Consortium. All rights reserved. Redistribution and use in source and binary forms, with or without modi‐ fication, are permitted provided that the following conditions are met: Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. Neither the names of Kitware, Inc., the Insight Software Consortium, nor the names of their contributors may be used to endorse or promote prod‐ ucts derived from this software without specific prior written permis‐ sion.   SEE ALSO ccmake(1), cpack(1), ctest(1), cmakecommands(1), cmakecompat(1), cmake‐ modules(1), cmakeprops(1), cmakevars(1) The following resources are available to get help using CMake: Home Page http://www.cmake.org The primary starting point for learning about CMake. Frequently Asked Questions http://www.cmake.org/Wiki/CMake_FAQ A Wiki is provided containing answers to frequently asked ques‐ tions. Online Documentation http://www.cmake.org/HTML/Documentation.html Links to available documentation may be found on this web page. Mailing List http://www.cmake.org/HTML/MailingLists.html For help and discussion about using cmake, a mailing list is pro‐ vided at<EMAIL_ADDRESS>The list is member-post-only but one may sign up on the CMake web page. Please first read the full documen‐ tation at http://www.cmake.org before posting questions to the list. Summary of helpful links: Home: http://www.cmake.org Docs: http://www.cmake.org/HTML/Documentation.html Mail: http://www.cmake.org/HTML/MailingLists.html FAQ: http://www.cmake.org/Wiki/CMake_FAQ AUTHOR This manual page was generated by the "--help-man" option. cmake 2.8.9 August 18, 2012 cmake(1)


setGlobalOptions.Rd
Produce a function which can get or set global options
setGlobalOptions(...)
| ... | specification of options, see 'details' section |
|---|
The function has a short name set_opt
.
The most simple way is to construct an option function (e.g. opt()
) as:
opt = set_opt( "a" = 1, "b" = "text" )
Then users can get or set the options by
opt() opt("a") opt$a opt[["a"]] opt(c("a", "b")) opt("a", "b") opt("a" = 2) opt$a = 2 opt[["a"]] = 2 opt("a" = 2, "b" = "new_text")
Options can be reset to their default values by:
opt(RESET = TRUE)
The value for each option can be set as a list which contains more configurations of the option:
opt = set_opt( "a" = list(.value = 1, .length = 1, .class = "numeric", .validate = function(x) x > 0) )
The different fields in the list can be used to filter or validate the option values.
.value
The default value.
.length
The valid length of the option value. It can be a vector, the check will be passed if one of the length fits.
.class
The valid class of the option value. It can be a vector, the check will be passed if one of the classes fits.
.validate
Validation function. The input parameter is the option value and should return a single logical value.
.failed_msg
Once validation failed, the error message that is printed.
.filter
Filtering function. The input parameter is the option value and it should return a filtered option value.
.read.only
Logical. The option value can not be modified if it is set to TRUE
.
.visible
Logical. Whether the option is visible to users.
.private
Logical. The option value can only be modified in the same namespace where the option function is created.
.synonymous
a single option name which should have been already defined ahead of current option. The option specified will be shared by current option.
.description
a short text for describing the option. The description is only used when printing the object.
For more detailed explanation, please go to the vignette.
#> Option Value #> ------:------- #> a 1 #> b text# for more examples, please go to the vignette


MultiSat Report
Creates a text file that contains data for multiple satellites. In "Satellites" list each satellite name separated by semicolons, i.e. Satellite1;Satellite2;Satellite3. Do not include semicolon if only listing one satellite.
Satellites:
Time Step (sec):


108 The Reference manual option downloads a copy of the latest revision of this manual in PDF format. The Snap! website option opens a browser window pointing to snap.berkeley.edu, the web site for Snap ! . The Download source option opens a browser window displaying the Github repository of the source ﬁles for Snap ! . At the bottom of the page are links to download the latest ofﬁcial release. Or you can navigate around the site to ﬁnd the current development version. You can read the code to learn how Snap ! is implemented, host a copy on your own computer (this is one way to keep working while on an airplane), or make a modiﬁed version with customized features. (However, access to cloud accounts is limited to the ofﬁcial version hosted at Berkeley.) The File Menu The ﬁle icon shows a menu mostly about saving and loading projects. You may not see all these options, if you don’t have multiple sprites, scenes, custom blocks, and custom categories. The Notes option opens a window in which you can type notes about the project: How to use it, what it does, whose project you modiﬁed to create it, if any, what other sources of ideas you used, or any other information about the project. This text is saved with the project, and is useful if you share it with other users. The New option starts a new, empty project. Any project you were working on before disappears, so you are asked to conﬁrm that this is really what you want. (It disappears only from the current working Snap ! window; you should save the current project, if you want to keep it, before using New.) Note the ^N at the end of the line. This indicates that you can type control-N as a shortcut for this menu item. Alas, this is not the case in every browser. Some Mac browsers require command-N (⌘N) instead, while others open a new browser window instead of a new project. You’ll have to experiment. In general, the keyboard shortcuts in Snap ! are the standard ones you expect in other software. The Open… option shows a project open dialog box in which you can choose a project to open: In this dialog, the three large buttons at the left select a source of projects: Cloud means your Snap ! account’s cloud storage. Examples means a collection of sample projects we provide. Computer is for projects saved on your own computer; when you click it, this dialog is replaced with your computer’s system dialog for opening ﬁles. The text box to the right of those buttons is an alphabetical listing of projects from that source; selecting a project by clicking shows its thumbnail (a picture of the stage when it was saved) and its project notes at the right.


The Growth of Big Data
Big Data is one of the key forces driving the growth and popularity of NoSQL for business. The almost limitless array of data collection technologies ranging from simple online actions to point of sale systems to GPS tools to smartphones and tablets to sophisticated sensors – and many more – act as force multipliers for data growth.
In fact, one of the first reasons to use NoSQL is because you have a Big Data project to tackle. A Big Data project is normally typified by:
High data velocity – lots of data coming in very quickly, possibly from different locations. Data variety – storage of data that is structured, semi-structured and unstructured. Data volume – data that involves many terabytes or petabytes in size. Data complexity – data that is stored and managed in different locations or data centers.
Datamodel Performance Scalability Flexibility Complexity Functionality Key-value store High High High None Variable (None) Column Store High High Moderate Low Minimal Document Store High Variable (High) High Low Variable (Low) Graph Database Variable Variable High High Graph Theory
massively scalable open source NoSQL database. Cassandra is perfect for managing large amounts of structured, semi-structured, and unstructured data across multiple data centers and the cloud. Cassandra delivers continuous availability, linear scalability, and operational simplicity across many commodity servers with no single point of failure, along with a powerful dynamic data model designed for maximum flexibility and fast response times
built-for-scale architecture means that it is capable of handling petabytes of information and thousands of concurrent users/operations per second.
An apache Software Foundation project, Cassandra is column oriented database and is an open source distributed database management system designed to handle large amounts of data across many commodity servers, providing high availability with no single point of failure.
Cassandra does not support joins or subqueries. Rather, Cassandra emphasizes denormalization through features like collections
CQL - Cassandara Query Language
Each node in a cluster can accept read and write requests, regardless of where the data is actually located in the cluster.
When a node goes down, read/write requests can be served from other nodes in the network.
The key components of Cassandra are as follows − Node − It is the place where data is stored. Data center − It is a collection of related nodes. Cluster − A cluster is a component that contains one or more data centers. Commit log − The commit log is a crash-recovery mechanism in Cassandra. Every write operation is written to the commit log. Mem-table − A mem-table is a memory-resident data structure. After commit log, the data will be written to the mem-table. Sometimes, for a single-column family, there will be multiple mem-tables. SSTable − It is a disk file to which the data is flushed from the mem-table when its contents reach a threshold value. Bloom filter − These are nothing but quick, nondeterministic, algorithms for testing whether an element is a member of a set. It is a special kind of cache. Bloom filters are accessed after every query.
Commands:
nodetool cfstats : displays statistics for each table and keyspace. nodetool cfhistograms : provides statistics about a table, including read/write latency, row size, column count, and number of SSTables. nodetool netstats : provides statistics about network operations and connections. nodetool tpstats : provides statistics about the number of active, pending, and completed tasks for each stage of Cassandra operations by thread pool. nodetool status :
cqlsh
cqlsh command list:
HELP - Displays help topics for all cqlsh commands. CAPTURE - Captures the output of a command and adds it to a file. CONSISTENCY - Shows the current consistency level, or sets a new consistency level. COPY - Copies data to and from Cassandra. DESCRIBE - Describes the current cluster of Cassandra and its objects. EXPAND - Expands the output of a query vertically. EXIT - Using this command, you can terminate cqlsh. PAGING - Enables or disables query paging. SHOW - Displays the details of current cqlsh session such as Cassandra version, host, or data type assumptions. SOURCE - Executes a file that contains CQL statements. TRACING - Enables or disables request tracing.
Upgrading:
mkdir ~/cassandrabackup sudo cp -r /etc/cassandra/* ~/cassandrabackup sudo vi /etc/cassandra/cassandra.yaml and edit numtokens to 1 and uncomment the initialtoken and set it to 1 nodetool upgradesstables nodetool drain sudo service cassandra stop sudo cp -r /etc/cassandra/* ~/cassandrabackupnew sudo apt-get install cassandra=2.1.12 Open the old and new cassandra.yaml files and diff them. Merge the diffs by hand, including the partitioner setting, from the old file into the new one. Do not use the default partitioner setting in the new cassandra.yaml because it has changed in this release to the Murmur3Partitioner. The Murmur3Partitioner can only be used for new clusters. After data has been added to the cluster, you cannot change the partitioner without reworking tables, which is not practical. Use your old partitioner setting in the new cassandra.yaml file. Save the file as cassandra.yaml.
Configuration file '/etc/cassandra/cassandra.yaml' ==> Modified (by you or by a script) since installation. ==> Package distributor has shipped an updated version. What would you like to do about it ? Your options are: Y or I : install the package maintainer's version N or O : keep your currently-installed version D : show the differences between the versions Z : start a shell to examine the situation The default action is to keep your current version. *** cassandra.yaml (Y/I/N/O/D/Z) [default=N] ?
************Inserting values into tables************************** CREATE KEYSPACE tutorialspoint WITH replication = { 'class': 'NetworkTopologyStrategy', 'cdr_record': '2' };
INSERT INTO tutorialspoint.emp (empid,empcity,empname,empphone,emp_sal) VALUES(3,'Kolkata','Stag1',8791134412,60);
UPDATE TABLE emp( empid int PRIMARY KEY, empname text, empcity text, empsal varint, emp_phone varint);
INSERT INTO TABLE emp(empid int,empname,empcity,empsal,emp_phone) VALUES(1,'dk','Bangalore',24,9964014500);
/usr/local/freeswitch/bin/fs_cli -x "originate freetdm/8/a/009716337516 &park()"
Nodetool Command Set:
nodetool status nodetool info nodetool -host <IP_ADDRESS> ring


AlpineLite
Name:
Name (by $get):
Email:
Local Name:
Local Name Alt:
Is Dirty:
Is Typing:
Is Valid:
Consent?
First
Second
Third
Lasr
Cancel
Save Changes
State is true
State is false
Name:
Other Name:
Called Name:
Email:
Added:
Index:
|
Value:
|
Count:
Index:
|
Value:
|
Count:
Title:
Year:
Seasons:
Root Name:


SweetFreeStuff.com
///////////////////////////////////////////
Free Milk Chocolate Reeses Peanut Butter Cups
Posted: 05 Sep 2014 11:14 AM PDT
http://feedproxy.google.com/&edburner&utm_medium=email
Save 100% when you buy ONE (1) 1.5 oz. Milk Chocolate Reeses Peanut Butter
Cups. Expires 9/7. Free Milk Chocolate Reese’s Peanut Butter Cups
The post Free Milk Chocolate Reese’s Peanut Butter Cups appeared first on
SweetFreeStuff.com.
///////////////////////////////////////////
Free Jimmy Dean Frozen Entree at Kroger & Affiliate Stores
Posted: 05 Sep 2014 10:14 AM PDT
http://feedproxy.google.com/&edburner&utm_medium=email
Load the coupon to your shoppers card today only (9/5,) and use by 9/19.
Free Jimmy Dean Frozen Entree at Kroger Affiliate Stores
The post Free Jimmy Dean Frozen Entree at Kroger Affiliate Stores appeared
first on SweetFreeStuff.com.
///////////////////////////////////////////
Free Anchor Bracelet
Posted: 05 Sep 2014 04:24 AM PDT
http://feedproxy.google.com/&edburner&utm_medium=email
For new customers only. Free Anchor Bracelet
The post Free Anchor Bracelet appeared first on SweetFreeStuff.com.
///////////////////////////////////////////
Free Mambo Sprouts Coupon Booklet
Posted: 05 Sep 2014 03:44 AM PDT
http://feedproxy.google.com/&edburner&utm_medium=email
Sign up for a free Mambo Sprouts Coupon booklet. Ships at the end of
November 2014. Free Mambo Sprouts Coupon Booklet
The post Free Mambo Sprouts Coupon Booklet appeared first on
SweetFreeStuff.com.
///////////////////////////////////////////
Free BG Nation Shirt
Posted: 05 Sep 2014 03:29 AM PDT
http://feedproxy.google.com/&edburner&utm_medium=email
Sign up here first and then complete the signup form here for a free BG
Nation Shirt.
The post Free BG Nation Shirt appeared first on SweetFreeStuff.com.
///////////////////////////////////////////
Free Hugo Boss Fragrance Samples
Posted: 05 Sep 2014 02:43 AM PDT
http://feedproxy.google.com/&edburner&utm_medium=email
Free Hugo Boss Womens Fragrance Sample Free Hugo Boss Mens Fragrance Sample
Free Hugo Boss Mens Fragrance Sample
The post Free Hugo Boss Fragrance Samples appeared first on
SweetFreeStuff.com.
///////////////////////////////////////////
Free Canyon Capers PC Game Download
Posted: 05 Sep 2014 02:40 AM PDT
http://feedproxy.google.com/&edburner&utm_medium=email
Free Canyon Capers PC Game Download
The post Free Canyon Capers PC Game Download appeared first on
SweetFreeStuff.com.
///////////////////////////////////////////
Free Starbucks Single Beverages In-Store
Posted: 05 Sep 2014 12:37 AM PDT
http://feedproxy.google.com/&edburner&utm_medium=email
Many stores have Starbucks Iced Coffee Singles, Espresso Singles or
Refreshers Singles for under $2.00. Visit this website and click the
Special Savings tab on top of the page to get a coupon good for $4.00 off
any 2 Starbucks coffee products which will make them free! Free Starbucks
Single Beverages In-Store
The post Free Starbucks Single Beverages In-Store appeared first on
SweetFreeStuff.com.
///////////////////////////////////////////
Free GoPicnic Breakfast Product at Target
Posted: 04 Sep 2014 11:36 AM PDT
http://feedproxy.google.com/&edburner&utm_medium=email
Enter your e-mail on the right side of the page to get a free coupon. Free
GoPicnic Breakfast Product at Target
The post Free GoPicnic Breakfast Product at Target appeared first on
SweetFreeStuff.com.
///////////////////////////////////////////
FREE Organic Tortilla Chips at Sprouts Stores
Posted: 04 Sep 2014 02:49 AM PDT
http://feedproxy.google.com/&edburner&utm_medium=email
FREE Organic Tortilla Chips at Sprouts Stores - expires 9/18
The post FREE Organic Tortilla Chips at Sprouts Stores appeared first on
SweetFreeStuff.com.
///////////////////////////////////////////
Free Original Glazed Doughnut at Krispy Kreme September 19th
Posted: 04 Sep 2014 01:56 AM PDT
http://feedproxy.google.com/&edburner&utm_medium=email
They are giving out free doughnuts in honor of Talk Like a Pirate Day. All
you have to do is enter a participating Krispy Kreme on Thursday, September
19th and talk like a pirate for one free original glazed doughnut. If you
dress up in full pirate attire they will give you a free dozen []
The post Free Original Glazed Doughnut at Krispy Kreme September 19th
appeared first on SweetFreeStuff.com.
///////////////////////////////////////////
Free Simple Truth Organic Broth at Ralphs
Posted: 04 Sep 2014 01:43 AM PDT
http://feedproxy.google.com/&edburner&utm_medium=email
Free Simple Truth Organic Broth at Ralph’s
The post Free Simple Truth Organic Broth at Ralph’s appeared first on
SweetFreeStuff.com.
///////////////////////////////////////////
Free Sample of Eucerin Smoothing Repair Lotion
Posted: 04 Sep 2014 12:00 AM PDT
http://feedproxy.google.com/&edburner&utm_medium=email
Click on Pledge Now for a Free Sample of Eucerin Lotion.
The post Free Sample of Eucerin Smoothing Repair Lotion appeared first on
SweetFreeStuff.com.
///////////////////////////////////////////
Free Nivea, Eucerin or Aquaphor Sample
Posted: 03 Sep 2014 11:53 PM PDT
http://feedproxy.google.com/&edburner&utm_medium=email
Free Nivea, Eucerin or Aquaphor Sample Watch the video to access the
samples.
The post Free Nivea, Eucerin or Aquaphor Sample appeared first on
SweetFreeStuff.com.
///////////////////////////////////////////
Free Subscription to Mens Health Magazine
Posted: 03 Sep 2014 11:21 PM PDT
http://feedproxy.google.com/&edburner&utm_medium=email
Free Subscription to Mens Health Magazine
The post Free Subscription to Mens Health Magazine appeared first on
SweetFreeStuff.com.
///////////////////////////////////////////
Free Subscription to Shape Magazine
Posted: 03 Sep 2014 11:05 PM PDT
http://feedproxy.google.com/&edburner&utm_medium=email
Free Subscription to Shape Magzaine
The post Free Subscription to Shape Magazine appeared first on
SweetFreeStuff.com.
///////////////////////////////////////////
Free Subscription to Diabetic Living
Posted: 03 Sep 2014 10:16 PM PDT
http://feedproxy.google.com/&edburner&utm_medium=email
Free Subscription to Diabetic Living
The post Free Subscription to Diabetic Living appeared first on
SweetFreeStuff.com.


Table of all the assessments / quizzes.
| Name | Description |
|---|---|
| assessment_id | Each quiz is assigned a unique id that is a combination of a base id and version. |
| assessment_base_id | Every quiz has a globally unique base id that is associated with a course. |
| assessment_version | Whenever a quiz is updated the base id is kept the same but the version and assessment id are updated. |
| assessment_type_id | Type of assessment so that it can be joined with the corresponding type specific tables. |
| assessment_update_ts | Update timestamp for a change to the assessment. |
| assessment_passing_fraction | No column description available |
CREATE TABLE assessments ( assessment_id VARCHAR(50) ,assessment_base_id VARCHAR(50) ,assessment_version INT4 ,assessment_type_id INT4 ,assessment_update_ts TIMESTAMP ,assessment_passing_fraction FLOAT4 ,PRIMARY KEY (assessment_id) ,FOREIGN KEY (assessment_type_id) REFERENCES assessment_types(assessment_type_id) );