file ---- File manipulation command. ------------------------------------------------------------------------------ :: file(WRITE ...) file(APPEND ...) Write ```` into a file called ````. If the file does not exist, it will be created. If the file already exists, ``WRITE`` mode will overwrite it and ``APPEND`` mode will append to the end. (If the file is a build input, use the :command:`configure_file` command to update the file only when its content changes.) ------------------------------------------------------------------------------ :: file(READ [OFFSET ] [LIMIT ] [HEX]) Read content from a file called ```` and store it in a ````. Optionally start from the given ```` and read at most ```` bytes. The ``HEX`` option causes data to be converted to a hexadecimal representation (useful for binary data). ------------------------------------------------------------------------------ :: file(STRINGS [...]) Parse a list of ASCII strings from ```` and store it in ````. Binary data in the file are ignored. Carriage return (``\r``, CR) characters are ignored. The options are: ``LENGTH_MAXIMUM `` Consider only strings of at most a given length. ``LENGTH_MINIMUM `` Consider only strings of at least a given length. ``LIMIT_COUNT `` Limit the number of distinct strings to be extracted. ``LIMIT_INPUT `` Limit the number of input bytes to read from the file. ``LIMIT_OUTPUT `` Limit the number of total bytes to store in the ````. ``NEWLINE_CONSUME`` Treat newline characters (``\n``, LF) as part of string content instead of terminating at them. ``NO_HEX_CONVERSION`` Intel Hex and Motorola S-record files are automatically converted to binary while reading unless this option is given. ``REGEX `` Consider only strings that match the given regular expression. ``ENCODING `` Consider strings of a given encoding. Currently supported encodings are: UTF-8, UTF-16LE, UTF-16BE, UTF-32LE, UTF-32BE. If the ENCODING option is not provided and the file has a Byte Order Mark, the ENCODING option will be defaulted to respect the Byte Order Mark. For example, the code .. code-block:: cmake file(STRINGS myfile.txt myfile) stores a list in the variable ``myfile`` in which each item is a line from the input file. ------------------------------------------------------------------------------ :: file( ) Compute a cryptographic hash of the content of ```` and store it in a ````. ------------------------------------------------------------------------------ :: file(GLOB [LIST_DIRECTORIES true|false] [RELATIVE ] [...]) file(GLOB_RECURSE [FOLLOW_SYMLINKS] [LIST_DIRECTORIES true|false] [RELATIVE ] [...]) Generate a list of files that match the ```` and store it into the ````. Globbing expressions are similar to regular expressions, but much simpler. If ``RELATIVE`` flag is specified, the results will be returned as relative paths to the given path. By default ``GLOB`` lists directories - directories are omited in result if ``LIST_DIRECTORIES`` is set to false. .. note:: We do not recommend using GLOB to collect a list of source files from your source tree. If no CMakeLists.txt file changes when a source is added or removed then the generated build system cannot know when to ask CMake to regenerate. Examples of globbing expressions include:: *.cxx - match all files with extension cxx *.vt? - match all files with extension vta,...,vtz f[3-5].txt - match files f3.txt, f4.txt, f5.txt The ``GLOB_RECURSE`` mode will traverse all the subdirectories of the matched directory and match the files. Subdirectories that are symlinks are only traversed if ``FOLLOW_SYMLINKS`` is given or policy :policy:`CMP0009` is not set to ``NEW``. By default ``GLOB_RECURSE`` omits directories from result list - setting ``LIST_DIRECTORIES`` to true adds directories to result list. If ``FOLLOW_SYMLINKS`` is given or policy :policy:`CMP0009` is not set to ``OLD`` then ``LIST_DIRECTORIES`` treats symlinks as directories. Examples of recursive globbing include:: /dir/*.py - match all python files in /dir and subdirectories ------------------------------------------------------------------------------ :: file(RENAME ) Move a file or directory within a filesystem from ```` to ````, replacing the destination atomically. ------------------------------------------------------------------------------ :: file(REMOVE [...]) file(REMOVE_RECURSE [...]) Remove the given files. The ``REMOVE_RECURSE`` mode will remove the given files and directories, also non-empty directories ------------------------------------------------------------------------------ :: file(MAKE_DIRECTORY [...]) Create the given directories and their parents as needed. ------------------------------------------------------------------------------ :: file(RELATIVE_PATH ) Compute the relative path from a ```` to a ```` and store it in the ````. ------------------------------------------------------------------------------ :: file(TO_CMAKE_PATH "" ) file(TO_NATIVE_PATH "" ) The ``TO_CMAKE_PATH`` mode converts a native ```` into a cmake-style path with forward-slashes (``/``). The input can be a single path or a system search path like ``$ENV{PATH}``. A search path will be converted to a cmake-style list separated by ``;`` characters. The ``TO_NATIVE_PATH`` mode converts a cmake-style ```` into a native path with platform-specific slashes (``\`` on Windows and ``/`` elsewhere). Always use double quotes around the ```` to be sure it is treated as a single argument to this command. ------------------------------------------------------------------------------ :: file(DOWNLOAD [...]) file(UPLOAD [...]) The ``DOWNLOAD`` mode downloads the given ```` to a local ````. The ``UPLOAD`` mode uploads a local ```` to a given ````. Options to both ``DOWNLOAD`` and ``UPLOAD`` are: ``INACTIVITY_TIMEOUT `` Terminate the operation after a period of inactivity. ``LOG `` Store a human-readable log of the operation in a variable. ``SHOW_PROGRESS`` Print progress information as status messages until the operation is complete. ``STATUS `` Store the resulting status of the operation in a variable. The status is a ``;`` separated list of length 2. The first element is the numeric return value for the operation, and the second element is a string value for the error. A ``0`` numeric error means no error in the operation. ``TIMEOUT `` Terminate the operation after a given total time has elapsed. Additional options to ``DOWNLOAD`` are: ``EXPECTED_HASH ALGO=`` Verify that the downloaded content hash matches the expected value, where ``ALGO`` is one of ``MD5``, ``SHA1``, ``SHA224``, ``SHA256``, ``SHA384``, or ``SHA512``. If it does not match, the operation fails with an error. ``EXPECTED_MD5 `` Historical short-hand for ``EXPECTED_HASH MD5=``. ``TLS_VERIFY `` Specify whether to verify the server certificate for ``https://`` URLs. The default is to *not* verify. ``TLS_CAINFO `` Specify a custom Certificate Authority file for ``https://`` URLs. For ``https://`` URLs CMake must be built with OpenSSL support. ``TLS/SSL`` certificates are not checked by default. Set ``TLS_VERIFY`` to ``ON`` to check certificates and/or use ``EXPECTED_HASH`` to verify downloaded content. If neither ``TLS`` option is given CMake will check variables ``CMAKE_TLS_VERIFY`` and ``CMAKE_TLS_CAINFO``, respectively. ------------------------------------------------------------------------------ :: file(TIMESTAMP [] [UTC]) Compute a string representation of the modification time of ```` and store it in ````. Should the command be unable to obtain a timestamp variable will be set to the empty string (""). See the :command:`string(TIMESTAMP)` command for documentation of the ```` and ``UTC`` options. ------------------------------------------------------------------------------ :: file(GENERATE OUTPUT output-file [CONDITION expression]) Generate an output file for each build configuration supported by the current :manual:`CMake Generator `. Evaluate :manual:`generator expressions ` from the input content to produce the output content. The options are: ``CONDITION `` Generate the output file for a particular configuration only if the condition is true. The condition must be either ``0`` or ``1`` after evaluating generator expressions. ``CONTENT `` Use the content given explicitly as input. ``INPUT `` Use the content from a given file as input. ``OUTPUT `` Specify the output file name to generate. Use generator expressions such as ``$`` to specify a configuration-specific output file name. Multiple configurations may generate the same output file only if the generated content is identical. Otherwise, the ```` must evaluate to an unique name for each configuration. Exactly one ``CONTENT`` or ``INPUT`` option must be given. A specific ``OUTPUT`` file may be named by at most one invocation of ``file(GENERATE)``. Generated files are modified on subsequent cmake runs only if their content is changed. ------------------------------------------------------------------------------ :: file( ... DESTINATION [FILE_PERMISSIONS ...] [DIRECTORY_PERMISSIONS ...] [NO_SOURCE_PERMISSIONS] [USE_SOURCE_PERMISSIONS] [FILES_MATCHING] [[PATTERN | REGEX ] [EXCLUDE] [PERMISSIONS ...]] [...]) The ``COPY`` signature copies files, directories, and symlinks to a destination folder. Relative input paths are evaluated with respect to the current source directory, and a relative destination is evaluated with respect to the current build directory. Copying preserves input file timestamps, and optimizes out a file if it exists at the destination with the same timestamp. Copying preserves input permissions unless explicit permissions or ``NO_SOURCE_PERMISSIONS`` are given (default is ``USE_SOURCE_PERMISSIONS``). See the :command:`install(DIRECTORY)` command for documentation of permissions, ``FILES_MATCHING``, ``PATTERN``, ``REGEX``, and ``EXCLUDE`` options. Copying directories preserves the structure of their content even if options are used to select a subset of files. The ``INSTALL`` signature differs slightly from ``COPY``: it prints status messages (subject to the :variable:`CMAKE_INSTALL_MESSAGE` variable), and ``NO_SOURCE_PERMISSIONS`` is default. Installation scripts generated by the :command:`install` command use this signature (with some undocumented options for internal use). ------------------------------------------------------------------------------ :: file(LOCK [DIRECTORY] [RELEASE] [GUARD ] [RESULT_VARIABLE ] [TIMEOUT ]) Lock a file specified by ```` if no ``DIRECTORY`` option present and file ``/cmake.lock`` otherwise. File will be locked for scope defined by ``GUARD`` option (default value is ``PROCESS``). ``RELEASE`` option can be used to unlock file explicitly. If option ``TIMEOUT`` is not specified CMake will wait until lock succeed or until fatal error occurs. If ``TIMEOUT`` is set to ``0`` lock will be tried once and result will be reported immediately. If ``TIMEOUT`` is not ``0`` CMake will try to lock file for the period specified by ```` value. Any errors will be interpreted as fatal if there is no ``RESULT_VARIABLE`` option. Otherwise result will be stored in ```` and will be ``0`` on success or error message on failure. Note that lock is advisory - there is no guarantee that other processes will respect this lock, i.e. lock synchronize two or more CMake instances sharing some modifiable resources. Similar logic applied to ``DIRECTORY`` option - locking parent directory doesn't prevent other ``LOCK`` commands to lock any child directory or file. Trying to lock file twice is not allowed. Any intermediate directories and file itself will be created if they not exist. ``GUARD`` and ``TIMEOUT`` options ignored on ``RELEASE`` operation.