cmake-3.10.2/.clang-format000644 000766 000024 00000000311 13230131712 016026 0ustar00kitwarestaff000000 000000 --- # This configuration requires clang-format 3.8 or higher. BasedOnStyle: Mozilla AlignOperands: false AlwaysBreakAfterReturnType: None AlwaysBreakAfterDefinitionReturnType: None ColumnLimit: 79 ... cmake-3.10.2/.clang-tidy000644 000766 000024 00000001711 13230131712 015514 0ustar00kitwarestaff000000 000000 --- Checks: "-*,\ google-readability-casting,\ misc-*,\ -misc-incorrect-roundings,\ -misc-macro-parentheses,\ -misc-misplaced-widening-cast,\ -misc-static-assert,\ modernize-*,\ -modernize-deprecated-headers,\ -modernize-pass-by-value,\ -modernize-raw-string-literal,\ -modernize-return-braced-init-list,\ -modernize-use-auto,\ -modernize-use-default-member-init,\ -modernize-use-emplace,\ -modernize-use-equals-default,\ -modernize-use-equals-delete,\ -modernize-use-noexcept,\ -modernize-use-transparent-functors,\ -modernize-use-using,\ performance-*,\ -performance-inefficient-string-concatenation,\ readability-*,\ -readability-function-size,\ -readability-identifier-naming,\ -readability-implicit-bool-cast,\ -readability-inconsistent-declaration-parameter-name,\ -readability-named-parameter,\ -readability-redundant-declaration,\ -readability-redundant-member-init,\ -readability-simplify-boolean-expr,\ " HeaderFilterRegex: 'Source/cm[^/]*\.(h|hxx|cxx)$' ... cmake-3.10.2/Auxiliary/000755 000766 000024 00000000000 13230133206 015427 5ustar00kitwarestaff000000 000000 cmake-3.10.2/Auxiliary/bash-completion/000755 000766 000024 00000000000 13230133206 020513 5ustar00kitwarestaff000000 000000 cmake-3.10.2/Auxiliary/bash-completion/cmake000644 000766 000024 00000012347 13230131712 021525 0ustar00kitwarestaff000000 000000 # bash completion for cmake(1) -*- shell-script -*- _cmake() { local cur prev words cword split=false if type -t _init_completion >/dev/null; then _init_completion -n = || return else # manual initialization for older bash completion versions COMPREPLY=() cur="${COMP_WORDS[COMP_CWORD]}" prev="${COMP_WORDS[COMP_CWORD-1]}" fi # Workaround for options like -DCMAKE_BUILD_TYPE=Release local prefix= if [[ $cur == -D* ]]; then prev=-D prefix=-D cur="${cur#-D}" elif [[ $cur == -U* ]]; then prev=-U prefix=-U cur="${cur#-U}" fi case "$prev" in -D) if [[ $cur == *=* ]]; then # complete values for variables local var type value var="${cur%%[:=]*}" value="${cur#*=}" if [[ $cur == CMAKE_BUILD_TYPE* ]]; then # most widely used case COMPREPLY=( $( compgen -W 'Debug Release RelWithDebInfo MinSizeRel' -- "$value" ) ) return fi if [[ $cur == *:* ]]; then type="${cur#*:}" type="${type%%=*}" else # get type from cache if it's not set explicitly type=$( cmake -LA -N 2>/dev/null | grep "$var:" \ 2>/dev/null ) type="${type#*:}" type="${type%%=*}" fi case "$type" in FILEPATH) cur="$value" _filedir return ;; PATH) cur="$value" _filedir -d return ;; BOOL) COMPREPLY=( $( compgen -W 'ON OFF TRUE FALSE' -- \ "$value" ) ) return ;; STRING|INTERNAL) # no completion available return ;; esac elif [[ $cur == *:* ]]; then # complete types local type="${cur#*:}" COMPREPLY=( $( compgen -W 'FILEPATH PATH STRING BOOL INTERNAL'\ -S = -- "$type" ) ) compopt -o nospace else # complete variable names COMPREPLY=( $( compgen -W '$( cmake -LA -N | tail -n +2 | cut -f1 -d: )' -P "$prefix" -- "$cur" ) ) compopt -o nospace fi return ;; -U) COMPREPLY=( $( compgen -W '$( cmake -LA -N | tail -n +2 | cut -f1 -d: )' -P "$prefix" -- "$cur" ) ) return ;; esac _split_longopt && split=true case "$prev" in -C|-P|--graphviz|--system-information) _filedir return ;; --build) _filedir -d return ;; -E) COMPREPLY=( $( compgen -W "$( cmake -E help |& sed -n \ '/^ [^ ]/{s|^ \([^ ]\{1,\}\) .*$|\1|;p}' 2>/dev/null )" \ -- "$cur" ) ) return ;; -G) local IFS=$'\n' local quoted printf -v quoted %q "$cur" COMPREPLY=( $( compgen -W '$( cmake --help 2>/dev/null | sed -n \ -e "1,/^Generators/d" \ -e "/^ *[^ =]/{s|^ *\([^=]*[^ =]\).*$|\1|;s| |\\\\ |g;p}" \ 2>/dev/null )' -- "$quoted" ) ) return ;; --help-command) COMPREPLY=( $( compgen -W '$( cmake --help-command-list 2>/dev/null| grep -v "^cmake version " )' -- "$cur" ) ) return ;; --help-manual) COMPREPLY=( $( compgen -W '$( cmake --help-manual-list 2>/dev/null| grep -v "^cmake version " | sed -e "s/([0-9])$//" )' -- "$cur" ) ) return ;; --help-module) COMPREPLY=( $( compgen -W '$( cmake --help-module-list 2>/dev/null| grep -v "^cmake version " )' -- "$cur" ) ) return ;; --help-policy) COMPREPLY=( $( compgen -W '$( cmake --help-policy-list 2>/dev/null | grep -v "^cmake version " )' -- "$cur" ) ) return ;; --help-property) COMPREPLY=( $( compgen -W '$( cmake --help-property-list \ 2>/dev/null | grep -v "^cmake version " )' -- "$cur" ) ) return ;; --help-variable) COMPREPLY=( $( compgen -W '$( cmake --help-variable-list \ 2>/dev/null | grep -v "^cmake version " )' -- "$cur" ) ) return ;; esac $split && return if [[ "$cur" == -* ]]; then COMPREPLY=( $(compgen -W '$( _parse_help "$1" --help )' -- ${cur}) ) [[ $COMPREPLY == *= ]] && compopt -o nospace [[ $COMPREPLY ]] && return fi _filedir } && complete -F _cmake cmake # ex: ts=4 sw=4 et filetype=sh cmake-3.10.2/Auxiliary/bash-completion/CMakeLists.txt000644 000766 000024 00000000636 13230131712 023260 0ustar00kitwarestaff000000 000000 # Always install completion file in local dir # in order to be sure to always be able to install # in a local user directory rooted in a single directory. # packager should either patch that out or # add symlinks to the files in appropriate places # /etc/bash_completion.d/ # DATADIR/completions (may be /usr/share//completions install(FILES cmake cpack ctest DESTINATION ${CMAKE_DATA_DIR}/completions) cmake-3.10.2/Auxiliary/bash-completion/cpack000644 000766 000024 00000005466 13230131712 021532 0ustar00kitwarestaff000000 000000 # bash completion for cpack(1) -*- shell-script -*- _cpack() { local cur prev words cword if type -t _init_completion >/dev/null; then _init_completion -n = || return else # manual initialization for older bash completion versions COMPREPLY=() cur="${COMP_WORDS[COMP_CWORD]}" prev="${COMP_WORDS[COMP_CWORD-1]}" fi case "$prev" in -G) COMPREPLY=( $( compgen -W '$( cpack --help 2>/dev/null | sed -e "1,/^Generators/d" -e "s|^ *\([^ ]*\) .*$|\1|" \ 2>/dev/null )' -- "$cur" ) ) return ;; -C) COMPREPLY=( $( compgen -W 'Debug Release RelWithDebInfo MinSizeRel' -- "$cur" ) ) return ;; -D) [[ $cur == *=* ]] && return # no completion for values COMPREPLY=( $( compgen -W '$( cpack --help-variable-list \ 2>/dev/null | grep -v "^cpack version " )' -S = -- "$cur" ) ) compopt -o nospace return ;; -P|-R|--vendor) # argument required but no completions available return ;; -B) _filedir -d return ;; --config) _filedir return ;; --help-command) COMPREPLY=( $( compgen -W '$( cpack --help-command-list 2>/dev/null| grep -v "^cpack version " )' -- "$cur" ) ) return ;; --help-manual) COMPREPLY=( $( compgen -W '$( cpack --help-manual-list 2>/dev/null| grep -v "^cpack version " | sed -e "s/([0-9])$//" )' -- "$cur" ) ) return ;; --help-module) COMPREPLY=( $( compgen -W '$( cpack --help-module-list 2>/dev/null| grep -v "^cpack version " )' -- "$cur" ) ) return ;; --help-policy) COMPREPLY=( $( compgen -W '$( cpack --help-policy-list 2>/dev/null | grep -v "^cpack version " )' -- "$cur" ) ) return ;; --help-property) COMPREPLY=( $( compgen -W '$( cpack --help-property-list \ 2>/dev/null | grep -v "^cpack version " )' -- "$cur" ) ) return ;; --help-variable) COMPREPLY=( $( compgen -W '$( cpack --help-variable-list \ 2>/dev/null | grep -v "^cpack version " )' -- "$cur" ) ) return ;; esac if [[ "$cur" == -* ]]; then COMPREPLY=( $(compgen -W '$( _parse_help "$1" --help )' -- ${cur}) ) [[ $COMPREPLY == *= ]] && compopt -o nospace [[ $COMPREPLY ]] && return fi _filedir } && complete -F _cpack cpack # ex: ts=4 sw=4 et filetype=sh cmake-3.10.2/Auxiliary/bash-completion/ctest000644 000766 000024 00000010071 13230131712 021557 0ustar00kitwarestaff000000 000000 # bash completion for ctest(1) -*- shell-script -*- _ctest() { local cur prev words cword if type -t _init_completion >/dev/null; then _init_completion -n = || return else # manual initialization for older bash completion versions COMPREPLY=() cur="${COMP_WORDS[COMP_CWORD]}" prev="${COMP_WORDS[COMP_CWORD-1]}" fi case "$prev" in -C|--build-config) COMPREPLY=( $( compgen -W 'Debug Release RelWithDebInfo MinSizeRel' -- "$cur" ) ) return ;; -j|--parallel) COMPREPLY=( $( compgen -W "{1..$(( $(_ncpus)*2 ))}" -- "$cur" ) ) return ;; -O|--output-log|-A|--add-notes|--extra-submit) _filedir return ;; -L|--label-regex|-LE|--label-exclude) COMPREPLY=( $( compgen -W '$( ctest --print-labels 2>/dev/null | grep "^ " 2>/dev/null | cut -d" " -f 3 )' -- "$cur" ) ) return ;; --track|-I|--tests-information|--max-width|--timeout|--stop-time) # argument required but no completions available return ;; -R|--tests-regex|-E|--exclude-regex) COMPREPLY=( $( compgen -W '$( ctest -N 2>/dev/null | grep "^ Test" 2>/dev/null | cut -d: -f 2 )' -- "$cur" ) ) return ;; -D|--dashboard) if [[ $cur == @(Experimental|Nightly|Continuous)* ]]; then local model action action=${cur#@(Experimental|Nightly|Continuous)} model=${cur%"$action"} COMPREPLY=( $( compgen -W 'Start Update Configure Build Test Coverage Submit MemCheck' -P "$model" -- "$action" ) ) else COMPREPLY=( $( compgen -W 'Experimental Nightly Continuous' \ -- "$cur" ) ) compopt -o nospace fi return ;; -M|--test-model) COMPREPLY=( $( compgen -W 'Experimental Nightly Continuous' -- \ "$cur" ) ) return ;; -T|--test-action) COMPREPLY=( $( compgen -W 'Start Update Configure Build Test Coverage Submit MemCheck' -- "$cur" ) ) return ;; -S|--script|-SP|--script-new-process) _filedir '@(cmake|ctest)' return ;; --interactive-debug-mode) COMPREPLY=( $( compgen -W '0 1' -- "$cur" ) ) return ;; --help-command) COMPREPLY=( $( compgen -W '$( ctest --help-command-list 2>/dev/null| grep -v "^ctest version " )' -- "$cur" ) ) return ;; --help-manual) COMPREPLY=( $( compgen -W '$( ctest --help-manual-list 2>/dev/null| grep -v "^ctest version " | sed -e "s/([0-9])$//" )' -- "$cur" ) ) return ;; --help-module) COMPREPLY=( $( compgen -W '$( ctest --help-module-list 2>/dev/null| grep -v "^ctest version " )' -- "$cur" ) ) return ;; --help-policy) COMPREPLY=( $( compgen -W '$( ctest --help-policy-list 2>/dev/null | grep -v "^ctest version " )' -- "$cur" ) ) return ;; --help-property) COMPREPLY=( $( compgen -W '$( ctest --help-property-list \ 2>/dev/null | grep -v "^ctest version " )' -- "$cur" ) ) return ;; --help-variable) COMPREPLY=( $( compgen -W '$( ctest --help-variable-list \ 2>/dev/null | grep -v "^ctest version " )' -- "$cur" ) ) return ;; esac if [[ "$cur" == -* ]]; then COMPREPLY=( $(compgen -W '$( _parse_help "$1" --help )' -- ${cur}) ) [[ $COMPREPLY == *= ]] && compopt -o nospace [[ $COMPREPLY ]] && return fi _filedir } && complete -F _ctest ctest # ex: ts=4 sw=4 et filetype=sh cmake-3.10.2/Auxiliary/cmake-mode.el000644 000766 000024 00000034436 13230131712 017765 0ustar00kitwarestaff000000 000000 ;;; cmake-mode.el --- major-mode for editing CMake sources ; Distributed under the OSI-approved BSD 3-Clause License. See accompanying ; file Copyright.txt or https://cmake.org/licensing for details. ;------------------------------------------------------------------------------ ;;; Commentary: ;; Provides syntax highlighting and indentation for CMakeLists.txt and ;; *.cmake source files. ;; ;; Add this code to your .emacs file to use the mode: ;; ;; (setq load-path (cons (expand-file-name "/dir/with/cmake-mode") load-path)) ;; (require 'cmake-mode) ;------------------------------------------------------------------------------ ;;; Code: ;; ;; cmake executable variable used to run cmake --help-command ;; on commands in cmake-mode ;; ;; cmake-command-help Written by James Bigler ;; (defcustom cmake-mode-cmake-executable "cmake" "*The name of the cmake executable. This can be either absolute or looked up in $PATH. You can also set the path with these commands: (setenv \"PATH\" (concat (getenv \"PATH\") \";C:\\\\Program Files\\\\CMake 2.8\\\\bin\")) (setenv \"PATH\" (concat (getenv \"PATH\") \":/usr/local/cmake/bin\"))" :type 'file :group 'cmake) ;; Keywords (defconst cmake-keywords-block-open '("IF" "MACRO" "FOREACH" "ELSE" "ELSEIF" "WHILE" "FUNCTION")) (defconst cmake-keywords-block-close '("ENDIF" "ENDFOREACH" "ENDMACRO" "ELSE" "ELSEIF" "ENDWHILE" "ENDFUNCTION")) (defconst cmake-keywords (let ((kwds (append cmake-keywords-block-open cmake-keywords-block-close nil))) (delete-dups kwds))) ;; Regular expressions used by line indentation function. ;; (defconst cmake-regex-blank "^[ \t]*$") (defconst cmake-regex-comment "#.*") (defconst cmake-regex-paren-left "(") (defconst cmake-regex-paren-right ")") (defconst cmake-regex-argument-quoted (rx ?\" (* (or (not (any ?\" ?\\)) (and ?\\ anything))) ?\")) (defconst cmake-regex-argument-unquoted (rx (or (not (any space "()#\"\\\n")) (and ?\\ nonl)) (* (or (not (any space "()#\\\n")) (and ?\\ nonl))))) (defconst cmake-regex-token (rx-to-string `(group (or (regexp ,cmake-regex-comment) ?( ?) (regexp ,cmake-regex-argument-unquoted) (regexp ,cmake-regex-argument-quoted))))) (defconst cmake-regex-indented (rx-to-string `(and bol (* (group (or (regexp ,cmake-regex-token) (any space ?\n))))))) (defconst cmake-regex-block-open (rx-to-string `(and symbol-start (or ,@(append cmake-keywords-block-open (mapcar 'downcase cmake-keywords-block-open))) symbol-end))) (defconst cmake-regex-block-close (rx-to-string `(and symbol-start (or ,@(append cmake-keywords-block-close (mapcar 'downcase cmake-keywords-block-close))) symbol-end))) (defconst cmake-regex-close (rx-to-string `(and bol (* space) (regexp ,cmake-regex-block-close) (* space) (regexp ,cmake-regex-paren-left)))) ;------------------------------------------------------------------------------ ;; Line indentation helper functions (defun cmake-line-starts-inside-string () "Determine whether the beginning of the current line is in a string." (save-excursion (beginning-of-line) (let ((parse-end (point))) (goto-char (point-min)) (nth 3 (parse-partial-sexp (point) parse-end)) ) ) ) (defun cmake-find-last-indented-line () "Move to the beginning of the last line that has meaningful indentation." (let ((point-start (point)) region) (forward-line -1) (setq region (buffer-substring-no-properties (point) point-start)) (while (and (not (bobp)) (or (looking-at cmake-regex-blank) (cmake-line-starts-inside-string) (not (and (string-match cmake-regex-indented region) (= (length region) (match-end 0)))))) (forward-line -1) (setq region (buffer-substring-no-properties (point) point-start)) ) ) ) ;------------------------------------------------------------------------------ ;; ;; Indentation increment. ;; (defcustom cmake-tab-width 2 "Number of columns to indent cmake blocks" :type 'integer :group 'cmake) ;; ;; Line indentation function. ;; (defun cmake-indent () "Indent current line as CMake code." (interactive) (unless (cmake-line-starts-inside-string) (if (bobp) (cmake-indent-line-to 0) (let (cur-indent) (save-excursion (beginning-of-line) (let ((point-start (point)) (case-fold-search t) ;; case-insensitive token) ; Search back for the last indented line. (cmake-find-last-indented-line) ; Start with the indentation on this line. (setq cur-indent (current-indentation)) ; Search forward counting tokens that adjust indentation. (while (re-search-forward cmake-regex-token point-start t) (setq token (match-string 0)) (when (or (string-match (concat "^" cmake-regex-paren-left "$") token) (and (string-match cmake-regex-block-open token) (looking-at (concat "[ \t]*" cmake-regex-paren-left)))) (setq cur-indent (+ cur-indent cmake-tab-width))) (when (string-match (concat "^" cmake-regex-paren-right "$") token) (setq cur-indent (- cur-indent cmake-tab-width))) ) (goto-char point-start) ;; If next token closes the block, decrease indentation (when (looking-at cmake-regex-close) (setq cur-indent (- cur-indent cmake-tab-width)) ) ) ) ; Indent this line by the amount selected. (cmake-indent-line-to (max cur-indent 0)) ) ) ) ) (defun cmake-point-in-indendation () (string-match "^[ \\t]*$" (buffer-substring (point-at-bol) (point)))) (defun cmake-indent-line-to (column) "Indent the current line to COLUMN. If point is within the existing indentation it is moved to the end of the indentation. Otherwise it retains the same position on the line" (if (cmake-point-in-indendation) (indent-line-to column) (save-excursion (indent-line-to column)))) ;------------------------------------------------------------------------------ ;; ;; Helper functions for buffer ;; (defun cmake-unscreamify-buffer () "Convert all CMake commands to lowercase in buffer." (interactive) (save-excursion (goto-char (point-min)) (while (re-search-forward "^\\([ \t]*\\)\\_<\\(\\(?:\\w\\|\\s_\\)+\\)\\_>\\([ \t]*(\\)" nil t) (replace-match (concat (match-string 1) (downcase (match-string 2)) (match-string 3)) t)) ) ) ;------------------------------------------------------------------------------ ;; ;; Keyword highlighting regex-to-face map. ;; (defconst cmake-font-lock-keywords `((,(rx-to-string `(and symbol-start (or ,@cmake-keywords ,@(mapcar #'downcase cmake-keywords)) symbol-end)) . font-lock-keyword-face) (,(rx symbol-start (group (+ (or word (syntax symbol)))) (* blank) ?\() 1 font-lock-function-name-face) (,(rx "${" (group (+(any alnum "-_+/."))) "}") 1 font-lock-variable-name-face t) ) "Highlighting expressions for CMake mode.") ;------------------------------------------------------------------------------ ;; Syntax table for this mode. (defvar cmake-mode-syntax-table nil "Syntax table for CMake mode.") (or cmake-mode-syntax-table (setq cmake-mode-syntax-table (let ((table (make-syntax-table))) (modify-syntax-entry ?\( "()" table) (modify-syntax-entry ?\) ")(" table) (modify-syntax-entry ?# "<" table) (modify-syntax-entry ?\n ">" table) (modify-syntax-entry ?$ "'" table) table))) ;; ;; User hook entry point. ;; (defvar cmake-mode-hook nil) ;------------------------------------------------------------------------------ ;; For compatibility with Emacs < 24 (defalias 'cmake--parent-mode (if (fboundp 'prog-mode) 'prog-mode 'fundamental-mode)) ;;------------------------------------------------------------------------------ ;; Mode definition. ;; ;;;###autoload (define-derived-mode cmake-mode cmake--parent-mode "CMake" "Major mode for editing CMake source files." ; Setup font-lock mode. (set (make-local-variable 'font-lock-defaults) '(cmake-font-lock-keywords)) ; Setup indentation function. (set (make-local-variable 'indent-line-function) 'cmake-indent) ; Setup comment syntax. (set (make-local-variable 'comment-start) "#")) ; Help mode starts here ;;;###autoload (defun cmake-command-run (type &optional topic buffer) "Runs the command cmake with the arguments specified. The optional argument topic will be appended to the argument list." (interactive "s") (let* ((bufname (if buffer buffer (concat "*CMake" type (if topic "-") topic "*"))) (buffer (if (get-buffer bufname) (get-buffer bufname) (generate-new-buffer bufname))) (command (concat cmake-mode-cmake-executable " " type " " topic)) ;; Turn of resizing of mini-windows for shell-command. (resize-mini-windows nil) ) (shell-command command buffer) (save-selected-window (select-window (display-buffer buffer 'not-this-window)) (cmake-mode) (read-only-mode 1)) ) ) ;;;###autoload (defun cmake-help-list-commands () "Prints out a list of the cmake commands." (interactive) (cmake-command-run "--help-command-list") ) (defvar cmake-commands '() "List of available topics for --help-command.") (defvar cmake-help-command-history nil "Command read history.") (defvar cmake-modules '() "List of available topics for --help-module.") (defvar cmake-help-module-history nil "Module read history.") (defvar cmake-variables '() "List of available topics for --help-variable.") (defvar cmake-help-variable-history nil "Variable read history.") (defvar cmake-properties '() "List of available topics for --help-property.") (defvar cmake-help-property-history nil "Property read history.") (defvar cmake-help-complete-history nil "Complete help read history.") (defvar cmake-string-to-list-symbol '(("command" cmake-commands cmake-help-command-history) ("module" cmake-modules cmake-help-module-history) ("variable" cmake-variables cmake-help-variable-history) ("property" cmake-properties cmake-help-property-history) )) (defun cmake-get-list (listname) "If the value of LISTVAR is nil, run cmake --help-LISTNAME-list and store the result as a list in LISTVAR." (let ((listvar (car (cdr (assoc listname cmake-string-to-list-symbol))))) (if (not (symbol-value listvar)) (let ((temp-buffer-name "*CMake Temporary*")) (save-window-excursion (cmake-command-run (concat "--help-" listname "-list") nil temp-buffer-name) (with-current-buffer temp-buffer-name ; FIXME: Ignore first line if it is "cmake version ..." from CMake < 3.0. (set listvar (split-string (buffer-substring-no-properties (point-min) (point-max)) "\n" t))))) (symbol-value listvar) )) ) (require 'thingatpt) (defun cmake-symbol-at-point () (let ((symbol (symbol-at-point))) (and (not (null symbol)) (symbol-name symbol)))) (defun cmake-help-type (type) (let* ((default-entry (cmake-symbol-at-point)) (history (car (cdr (cdr (assoc type cmake-string-to-list-symbol))))) (input (completing-read (format "CMake %s: " type) ; prompt (cmake-get-list type) ; completions nil ; predicate t ; require-match default-entry ; initial-input history ))) (if (string= input "") (error "No argument given") input)) ) ;;;###autoload (defun cmake-help-command () "Prints out the help message for the command the cursor is on." (interactive) (cmake-command-run "--help-command" (cmake-help-type "command") "*CMake Help*")) ;;;###autoload (defun cmake-help-module () "Prints out the help message for the module the cursor is on." (interactive) (cmake-command-run "--help-module" (cmake-help-type "module") "*CMake Help*")) ;;;###autoload (defun cmake-help-variable () "Prints out the help message for the variable the cursor is on." (interactive) (cmake-command-run "--help-variable" (cmake-help-type "variable") "*CMake Help*")) ;;;###autoload (defun cmake-help-property () "Prints out the help message for the property the cursor is on." (interactive) (cmake-command-run "--help-property" (cmake-help-type "property") "*CMake Help*")) ;;;###autoload (defun cmake-help () "Queries for any of the four available help topics and prints out the approriate page." (interactive) (let* ((default-entry (cmake-symbol-at-point)) (command-list (cmake-get-list "command")) (variable-list (cmake-get-list "variable")) (module-list (cmake-get-list "module")) (property-list (cmake-get-list "property")) (all-words (append command-list variable-list module-list property-list)) (input (completing-read "CMake command/module/variable/property: " ; prompt all-words ; completions nil ; predicate t ; require-match default-entry ; initial-input 'cmake-help-complete-history ))) (if (string= input "") (error "No argument given") (if (member input command-list) (cmake-command-run "--help-command" input "*CMake Help*") (if (member input variable-list) (cmake-command-run "--help-variable" input "*CMake Help*") (if (member input module-list) (cmake-command-run "--help-module" input "*CMake Help*") (if (member input property-list) (cmake-command-run "--help-property" input "*CMake Help*") (error "Not a know help topic.") ; this really should not happen )))))) ) ;;;###autoload (progn (add-to-list 'auto-mode-alist '("CMakeLists\\.txt\\'" . cmake-mode)) (add-to-list 'auto-mode-alist '("\\.cmake\\'" . cmake-mode))) ; This file provides cmake-mode. (provide 'cmake-mode) ;;; cmake-mode.el ends here cmake-3.10.2/Auxiliary/cmake.m4000644 000766 000024 00000002675 13230131712 016763 0ustar00kitwarestaff000000 000000 dnl Distributed under the OSI-approved BSD 3-Clause License. See accompanying dnl file Copyright.txt or https://cmake.org/licensing for details. AC_DEFUN([CMAKE_FIND_BINARY], [AC_ARG_VAR([CMAKE_BINARY], [path to the cmake binary])dnl if test "x$ac_cv_env_CMAKE_BINARY_set" != "xset"; then AC_PATH_TOOL([CMAKE_BINARY], [cmake])dnl fi ])dnl # $1: package name # $2: language (e.g. C/CXX/Fortran) # $3: The compiler ID, defaults to GNU. # Possible values are: GNU, Intel, Clang, SunPro, HP, XL, VisualAge, PGI, # PathScale, Cray, SCO, MIPSpro, MSVC # $4: optional extra arguments to cmake, e.g. "-DCMAKE_SIZEOF_VOID_P=8" # $5: optional path to cmake binary AC_DEFUN([CMAKE_FIND_PACKAGE], [ AC_REQUIRE([CMAKE_FIND_BINARY])dnl AC_ARG_VAR([$1][_][$2][FLAGS], [$2 compiler flags for $1. This overrides the cmake output])dnl AC_ARG_VAR([$1][_LIBS], [linker flags for $1. This overrides the cmake output])dnl failed=false AC_MSG_CHECKING([for $1]) if test -z "${$1[]_$2[]FLAGS}"; then $1[]_$2[]FLAGS=`$CMAKE_BINARY --find-package "-DNAME=$1" "-DCOMPILER_ID=m4_default([$3], [GNU])" "-DLANGUAGE=$2" -DMODE=COMPILE $4` || failed=true fi if test -z "${$1[]_LIBS}"; then $1[]_LIBS=`$CMAKE_BINARY --find-package "-DNAME=$1" "-DCOMPILER_ID=m4_default([$3], [GNU])" "-DLANGUAGE=$2" -DMODE=LINK $4` || failed=true fi if $failed; then unset $1[]_$2[]FLAGS unset $1[]_LIBS AC_MSG_RESULT([no]) $6 else AC_MSG_RESULT([yes]) $5 fi[]dnl ]) cmake-3.10.2/Auxiliary/CMakeLists.txt000644 000766 000024 00000000400 13230131712 020161 0ustar00kitwarestaff000000 000000 install(DIRECTORY vim/indent vim/syntax DESTINATION ${CMAKE_DATA_DIR}/editors/vim) install(FILES cmake-mode.el DESTINATION ${CMAKE_DATA_DIR}/editors/emacs) install(FILES cmake.m4 DESTINATION ${CMAKE_XDGDATA_DIR}/aclocal) add_subdirectory (bash-completion) cmake-3.10.2/Auxiliary/vim/000755 000766 000024 00000000000 13230133206 016222 5ustar00kitwarestaff000000 000000 cmake-3.10.2/Auxiliary/vim/cmake.vim.in000644 000766 000024 00000005776 13230131712 020443 0ustar00kitwarestaff000000 000000 " vim: set nowrap: " Vim syntax file " Program: CMake - Cross-Platform Makefile Generator " Version: @VERSION@ " Language: CMake " Author: Andy Cedilnik , " Nicholas Hutchinson , " Patrick Boettcher " Maintainer: Dimitri Merejkowsky " Former Maintainer: Karthik Krishnan " " Licence: The CMake license applies to this file. See " https://cmake.org/licensing " This implies that distribution with Vim is allowed if exists("b:current_syntax") finish endif let s:keepcpo= &cpo set cpo&vim syn region cmakeComment start="#" end="$" contains=cmakeTodo,cmakeLuaComment,@Spell syn region cmakeLuaComment start="\[\z(=*\)\[" end="\]\z1\]" contains=cmakeTodo,@Spell syn match cmakeEscaped /\(\\\\\|\\"\|\\n\|\\t\)/ contained syn region cmakeRegistry start="\[" end="]" contained oneline contains=cmakeTodo,cmakeEscaped syn region cmakeGeneratorExpression start="$<" end=">" contained oneline contains=cmakeVariableValue,cmakeProperty,cmakeGeneratorExpressions,cmakeTodo syn region cmakeString start='"' end='"' contained contains=cmakeTodo,cmakeVariableValue,cmakeEscaped syn region cmakeVariableValue start="${" end="}" contained oneline contains=cmakeVariable,cmakeTodo syn region cmakeEnvironment start="$ENV{" end="}" contained oneline contains=cmakeTodo syn region cmakeArguments start="(" end=")" contains=ALLBUT,cmakeCommand,cmakeCommandConditional,cmakeCommandRepeat,cmakeCommandDeprecated,cmakeArguments,cmakeTodo syn case match syn keyword cmakeProperty contained @PROPERTIES@ syn keyword cmakeVariable contained @VARIABLE_LIST@ syn keyword cmakeModule contained @MODULES@ @KEYWORDS@ syn keyword cmakeGeneratorExpressions contained @GENERATOR_EXPRESSIONS@ syn case ignore syn keyword cmakeCommand @COMMAND_LIST@ \ nextgroup=cmakeArguments syn keyword cmakeCommandConditional @CONDITIONALS@ \ nextgroup=cmakeArguments syn keyword cmakeCommandRepeat @LOOPS@ \ nextgroup=cmakeArguments syn keyword cmakeCommandDeprecated @DEPRECATED@ \ nextgroup=cmakeArguments syn case match syn keyword cmakeTodo \ TODO FIXME XXX \ contained hi def link cmakeCommand Function hi def link cmakeCommandConditional Conditional hi def link cmakeCommandDeprecated WarningMsg hi def link cmakeCommandRepeat Repeat hi def link cmakeComment Comment hi def link cmakeEnvironment Special hi def link cmakeEscaped Special hi def link cmakeGeneratorExpression WarningMsg hi def link cmakeGeneratorExpressions Constant hi def link cmakeLuaComment Comment hi def link cmakeModule Include hi def link cmakeProperty Constant hi def link cmakeRegistry Underlined hi def link cmakeString String hi def link cmakeTodo TODO hi def link cmakeVariableValue Type hi def link cmakeVariable Identifier @KEYWORDS_HIGHLIGHT@ let b:current_syntax = "cmake" let &cpo = s:keepcpo unlet s:keepcpo "EOF" cmake-3.10.2/Auxiliary/vim/extract-upper-case.pl000755 000766 000024 00000010561 13230131712 022301 0ustar00kitwarestaff000000 000000 #!/usr/bin/env perl use strict; use warnings; #my $cmake = "/home/pboettch/devel/upstream/cmake/build/bin/cmake"; my $cmake = "cmake"; my @variables; my @commands; my @properties; my @modules; my %keywords; # command => keyword-list # unwanted upper-cases my %unwanted = map { $_ => 1 } qw(VS CXX IDE NOTFOUND NO_ DFOO DBAR NEW); # cannot remove ALL - exists for add_custom_command # control-statements my %conditional = map { $_ => 1 } qw(if else elseif endif); my %loop = map { $_ => 1 } qw(foreach while endforeach endwhile); # decrecated my %deprecated = map { $_ => 1 } qw(build_name exec_program export_library_dependencies install_files install_programs install_targets link_libraries make_directory output_required_files remove subdir_depends subdirs use_mangled_mesa utility_source variable_requires write_file); # add some (popular) modules push @modules, "ExternalProject"; # variables open(CMAKE, "$cmake --help-variable-list|") or die "could not run cmake"; while () { next if /\ chomp; push @variables, $_; } close(CMAKE); # transform all variables in a hash - to be able to use exists later on my %variables = map { $_ => 1 } @variables; # commands open(CMAKE, "$cmake --help-command-list|"); while (my $cmd = ) { chomp $cmd; push @commands, $cmd; } close(CMAKE); # now generate a keyword-list per command foreach my $cmd (@commands) { my @word = extract_upper("$cmake --help-command $cmd|"); next if scalar @word == 0; $keywords{$cmd} = [ sort keys %{ { map { $_ => 1 } @word } } ]; } # and now for modules foreach my $mod (@modules) { my @word = extract_upper("$cmake --help-module $mod|"); next if scalar @word == 0; $keywords{$mod} = [ sort keys %{ { map { $_ => 1 } @word } } ]; } # and now for generator-expressions my @generator_expr = extract_upper("$cmake --help-manual cmake-generator-expressions |"); # properties open(CMAKE, "$cmake --help-property-list|"); while () { next if /\ chomp; push @properties, $_; } close(CMAKE); # transform all properties in a hash my %properties = map { $_ => 1 } @properties; # version open(CMAKE, "$cmake --version|"); my $version = 'unknown'; while () { chomp; $version = $_ if /cmake version/; } close(CMAKE); # generate cmake.vim open(IN, "syntax/cmake.vim") or die "could not write to syntax/cmake.vim"; my @keyword_hi; while() { if (m/\@([A-Z0-9_]+)\@/) { # match for @SOMETHING@ if ($1 eq "COMMAND_LIST") { # do not include "special" commands in this list my @tmp = grep { ! exists $conditional{$_} and ! exists $loop{$_} and ! exists $deprecated{$_} } @commands; print OUT " " x 12 , "\\ ", join(" ", @tmp), "\n"; } elsif ($1 eq "VARIABLE_LIST") { print OUT " " x 12 , "\\ ", join(" ", sort keys %variables), "\n"; } elsif ($1 eq "MODULES") { print OUT " " x 12 , "\\ ", join("\n", @modules), "\n"; } elsif ($1 eq "GENERATOR_EXPRESSIONS") { print OUT " " x 12 , "\\ ", join(" ", @generator_expr), "\n"; } elsif ($1 eq "CONDITIONALS") { print OUT " " x 12 , "\\ ", join(" ", sort keys %conditional), "\n"; } elsif ($1 eq "LOOPS") { print OUT " " x 12 , "\\ ", join(" ", sort keys %loop), "\n"; } elsif ($1 eq "DEPRECATED") { print OUT " " x 12 , "\\ ", join(" ", sort keys %deprecated), "\n"; } elsif ($1 eq "PROPERTIES") { print OUT " " x 12 , "\\ ", join(" ", sort keys %properties), "\n"; } elsif ($1 eq "KEYWORDS") { foreach my $k (sort keys %keywords) { print OUT "syn keyword cmakeKW$k contained\n"; print OUT " " x 12, "\\ ", join(" ", @{$keywords{$k}}), "\n"; print OUT "\n"; push @keyword_hi, "hi def link cmakeKW$k ModeMsg"; } } elsif ($1 eq "KEYWORDS_HIGHLIGHT") { print OUT join("\n", @keyword_hi), "\n"; } elsif ($1 eq "VERSION") { $_ =~ s/\@VERSION\@/$version/; print OUT $_; } else { print "ERROR do not know how to replace $1\n"; } } else { print OUT $_; } } close(IN); close(OUT); sub extract_upper { my $input = shift; my @word; open(KW, $input); while () { foreach my $w (m/\b([A-Z_]{2,})\b/g) { next if exists $variables{$w} or # skip if it is a variable exists $unwanted{$w} or # skip if not wanted grep(/$w/, @word); # skip if already in array push @word, $w; } } close(KW); return @word; } cmake-3.10.2/Auxiliary/vim/indent/000755 000766 000024 00000000000 13230133206 017503 5ustar00kitwarestaff000000 000000 cmake-3.10.2/Auxiliary/vim/indent/cmake.vim000644 000766 000024 00000004752 13230131712 021310 0ustar00kitwarestaff000000 000000 " Vim indent file " Language: CMake (ft=cmake) " Author: Andy Cedilnik " Maintainer: Karthik Krishnan " Last Change: $Date$ " Version: $Revision$ " " Licence: The CMake license applies to this file. See " https://cmake.org/licensing " This implies that distribution with Vim is allowed if exists("b:did_indent") finish endif let b:did_indent = 1 setlocal indentexpr=CMakeGetIndent(v:lnum) setlocal indentkeys+==ENDIF(,ENDFOREACH(,ENDMACRO(,ELSE(,ELSEIF(,ENDWHILE( " Only define the function once. if exists("*CMakeGetIndent") finish endif fun! CMakeGetIndent(lnum) let this_line = getline(a:lnum) " Find a non-blank line above the current line. let lnum = a:lnum let lnum = prevnonblank(lnum - 1) let previous_line = getline(lnum) " Hit the start of the file, use zero indent. if lnum == 0 return 0 endif let ind = indent(lnum) let or = '\|' " Regular expressions used by line indentation function. let cmake_regex_comment = '#.*' let cmake_regex_identifier = '[A-Za-z][A-Za-z0-9_]*' let cmake_regex_quoted = '"\([^"\\]\|\\.\)*"' let cmake_regex_arguments = '\(' . cmake_regex_quoted . \ or . '\$(' . cmake_regex_identifier . ')' . \ or . '[^()\\#"]' . or . '\\.' . '\)*' let cmake_indent_comment_line = '^\s*' . cmake_regex_comment let cmake_indent_blank_regex = '^\s*$' let cmake_indent_open_regex = '^\s*' . cmake_regex_identifier . \ '\s*(' . cmake_regex_arguments . \ '\(' . cmake_regex_comment . '\)\?$' let cmake_indent_close_regex = '^' . cmake_regex_arguments . \ ')\s*' . \ '\(' . cmake_regex_comment . '\)\?$' let cmake_indent_begin_regex = '^\s*\(IF\|MACRO\|FOREACH\|ELSE\|ELSEIF\|WHILE\|FUNCTION\)\s*(' let cmake_indent_end_regex = '^\s*\(ENDIF\|ENDFOREACH\|ENDMACRO\|ELSE\|ELSEIF\|ENDWHILE\|ENDFUNCTION\)\s*(' " Add if previous_line =~? cmake_indent_comment_line " Handle comments let ind = ind else if previous_line =~? cmake_indent_begin_regex let ind = ind + &sw endif if previous_line =~? cmake_indent_open_regex let ind = ind + &sw endif endif " Subtract if this_line =~? cmake_indent_end_regex let ind = ind - &sw endif if previous_line =~? cmake_indent_close_regex let ind = ind - &sw endif return ind endfun cmake-3.10.2/Auxiliary/vim/syntax/000755 000766 000024 00000000000 13230133206 017550 5ustar00kitwarestaff000000 000000 cmake-3.10.2/Auxiliary/vim/syntax/cmake.vim000644 000766 000024 00000122303 13230131712 021346 0ustar00kitwarestaff000000 000000 " vim: set nowrap: " Vim syntax file " Program: CMake - Cross-Platform Makefile Generator " Version: cmake version 3.9.20170830-ge0713 " Language: CMake " Author: Andy Cedilnik , " Nicholas Hutchinson , " Patrick Boettcher " Maintainer: Dimitri Merejkowsky " Former Maintainer: Karthik Krishnan " " Licence: The CMake license applies to this file. See " https://cmake.org/licensing " This implies that distribution with Vim is allowed if exists("b:current_syntax") finish endif let s:keepcpo= &cpo set cpo&vim syn region cmakeComment start="#" end="$" contains=cmakeTodo,cmakeLuaComment,@Spell syn region cmakeLuaComment start="\[\z(=*\)\[" end="\]\z1\]" contains=cmakeTodo,@Spell syn match cmakeEscaped /\(\\\\\|\\"\|\\n\|\\t\)/ contained syn region cmakeRegistry start="\[" end="]" contained oneline contains=cmakeTodo,cmakeEscaped syn region cmakeGeneratorExpression start="$<" end=">" contained oneline contains=cmakeVariableValue,cmakeProperty,cmakeGeneratorExpressions,cmakeTodo syn region cmakeString start='"' end='"' contained contains=cmakeTodo,cmakeVariableValue,cmakeEscaped syn region cmakeVariableValue start="${" end="}" contained oneline contains=cmakeVariable,cmakeTodo syn region cmakeEnvironment start="$ENV{" end="}" contained oneline contains=cmakeTodo syn region cmakeArguments start="(" end=")" contains=ALLBUT,cmakeCommand,cmakeCommandConditional,cmakeCommandRepeat,cmakeCommandDeprecated,cmakeArguments,cmakeTodo syn case match syn keyword cmakeProperty contained \ ABSTRACT ADDITIONAL_MAKE_CLEAN_FILES ADVANCED ALIASED_TARGET ALLOW_DUPLICATE_CUSTOM_TARGETS ANDROID_ANT_ADDITIONAL_OPTIONS ANDROID_API ANDROID_API_MIN ANDROID_ARCH ANDROID_ASSETS_DIRECTORIES ANDROID_GUI ANDROID_JAR_DEPENDENCIES ANDROID_JAR_DIRECTORIES ANDROID_JAVA_SOURCE_DIR ANDROID_NATIVE_LIB_DEPENDENCIES ANDROID_NATIVE_LIB_DIRECTORIES ANDROID_PROCESS_MAX ANDROID_PROGUARD ANDROID_PROGUARD_CONFIG_PATH ANDROID_SECURE_PROPS_PATH ANDROID_SKIP_ANT_STEP ANDROID_STL_TYPE ARCHIVE_OUTPUT_DIRECTORY ARCHIVE_OUTPUT_NAME ATTACHED_FILES ATTACHED_FILES_ON_FAIL AUTOGEN_BUILD_DIR AUTOGEN_SOURCE_GROUP AUTOGEN_TARGETS_FOLDER AUTOGEN_TARGET_DEPENDS AUTOMOC AUTOMOC_DEPEND_FILTERS AUTOMOC_MACRO_NAMES AUTOMOC_MOC_OPTIONS AUTOMOC_SOURCE_GROUP AUTOMOC_TARGETS_FOLDER AUTORCC AUTORCC_OPTIONS AUTORCC_SOURCE_GROUP AUTOUIC AUTOUIC_OPTIONS AUTOUIC_SEARCH_PATHS BINARY_DIR BUILDSYSTEM_TARGETS BUILD_RPATH BUILD_WITH_INSTALL_NAME_DIR BUILD_WITH_INSTALL_RPATH BUNDLE BUNDLE_EXTENSION CACHE_VARIABLES CLEAN_NO_CUSTOM CMAKE_CONFIGURE_DEPENDS CMAKE_CXX_KNOWN_FEATURES CMAKE_C_KNOWN_FEATURES COMPATIBLE_INTERFACE_BOOL COMPATIBLE_INTERFACE_NUMBER_MAX COMPATIBLE_INTERFACE_NUMBER_MIN COMPATIBLE_INTERFACE_STRING COMPILE_DEFINITIONS COMPILE_FEATURES COMPILE_FLAGS COMPILE_OPTIONS COMPILE_PDB_NAME COMPILE_PDB_OUTPUT_DIRECTORY COST CPACK_DESKTOP_SHORTCUTS CPACK_NEVER_OVERWRITE CPACK_PERMANENT CPACK_STARTUP_SHORTCUTS CPACK_START_MENU_SHORTCUTS CPACK_WIX_ACL CROSSCOMPILING_EMULATOR CUDA_EXTENSIONS CUDA_PTX_COMPILATION CUDA_RESOLVE_DEVICE_SYMBOLS CUDA_SEPARABLE_COMPILATION CUDA_STANDARD CUDA_STANDARD_REQUIRED CXX_EXTENSIONS CXX_STANDARD CXX_STANDARD_REQUIRED C_EXTENSIONS C_STANDARD C_STANDARD_REQUIRED DEBUG_CONFIGURATIONS DEBUG_POSTFIX DEFINE_SYMBOL DEFINITIONS DEPENDS DEPLOYMENT_REMOTE_DIRECTORY DISABLED DISABLED_FEATURES ECLIPSE_EXTRA_NATURES ENABLED_FEATURES ENABLED_LANGUAGES ENABLE_EXPORTS ENVIRONMENT EXCLUDE_FROM_ALL EXCLUDE_FROM_DEFAULT_BUILD EXPORT_NAME EXTERNAL_OBJECT EchoString FAIL_REGULAR_EXPRESSION FIND_LIBRARY_USE_LIB32_PATHS FIND_LIBRARY_USE_LIB64_PATHS FIND_LIBRARY_USE_LIBX32_PATHS FIND_LIBRARY_USE_OPENBSD_VERSIONING FIXTURES_CLEANUP FIXTURES_REQUIRED FIXTURES_SETUP FOLDER FRAMEWORK FRAMEWORK_VERSION Fortran_FORMAT Fortran_MODULE_DIRECTORY GENERATED GENERATOR_FILE_NAME GENERATOR_IS_MULTI_CONFIG GLOBAL_DEPENDS_DEBUG_MODE GLOBAL_DEPENDS_NO_CYCLES GNUtoMS HAS_CXX HEADER_FILE_ONLY HELPSTRING IMPLICIT_DEPENDS_INCLUDE_TRANSFORM IMPORTED IMPORTED_CONFIGURATIONS IMPORTED_IMPLIB IMPORTED_LIBNAME IMPORTED_LINK_DEPENDENT_LIBRARIES IMPORTED_LINK_INTERFACE_LANGUAGES IMPORTED_LINK_INTERFACE_LIBRARIES IMPORTED_LINK_INTERFACE_MULTIPLICITY IMPORTED_LOCATION IMPORTED_NO_SONAME IMPORTED_OBJECTS IMPORTED_SONAME IMPORT_PREFIX IMPORT_SUFFIX INCLUDE_DIRECTORIES INCLUDE_REGULAR_EXPRESSION INSTALL_NAME_DIR INSTALL_RPATH INSTALL_RPATH_USE_LINK_PATH INTERFACE_AUTOUIC_OPTIONS INTERFACE_COMPILE_DEFINITIONS INTERFACE_COMPILE_FEATURES INTERFACE_COMPILE_OPTIONS INTERFACE_INCLUDE_DIRECTORIES INTERFACE_LINK_LIBRARIES INTERFACE_POSITION_INDEPENDENT_CODE INTERFACE_SOURCES INTERFACE_SYSTEM_INCLUDE_DIRECTORIES INTERPROCEDURAL_OPTIMIZATION IN_TRY_COMPILE IOS_INSTALL_COMBINED JOB_POOLS JOB_POOL_COMPILE JOB_POOL_LINK KEEP_EXTENSION LABELS LANGUAGE LIBRARY_OUTPUT_DIRECTORY LIBRARY_OUTPUT_NAME LINKER_LANGUAGE LINK_DEPENDS LINK_DEPENDS_NO_SHARED LINK_DIRECTORIES LINK_FLAGS LINK_INTERFACE_LIBRARIES LINK_INTERFACE_MULTIPLICITY LINK_LIBRARIES LINK_SEARCH_END_STATIC LINK_SEARCH_START_STATIC LINK_WHAT_YOU_USE LISTFILE_STACK LOCATION MACOSX_BUNDLE MACOSX_BUNDLE_INFO_PLIST MACOSX_FRAMEWORK_INFO_PLIST MACOSX_PACKAGE_LOCATION MACOSX_RPATH MACROS MANUALLY_ADDED_DEPENDENCIES MEASUREMENT MODIFIED NAME NO_SONAME NO_SYSTEM_FROM_IMPORTED OBJECT_DEPENDS OBJECT_OUTPUTS OSX_ARCHITECTURES OUTPUT_NAME PACKAGES_FOUND PACKAGES_NOT_FOUND PARENT_DIRECTORY PASS_REGULAR_EXPRESSION PDB_NAME PDB_OUTPUT_DIRECTORY POSITION_INDEPENDENT_CODE POST_INSTALL_SCRIPT PREDEFINED_TARGETS_FOLDER PREFIX PRE_INSTALL_SCRIPT PRIVATE_HEADER PROCESSORS PROJECT_LABEL PUBLIC_HEADER REPORT_UNDEFINED_PROPERTIES REQUIRED_FILES RESOURCE RESOURCE_LOCK RULE_LAUNCH_COMPILE RULE_LAUNCH_CUSTOM RULE_LAUNCH_LINK RULE_MESSAGES RUNTIME_OUTPUT_DIRECTORY RUNTIME_OUTPUT_NAME RUN_SERIAL SKIP_AUTOGEN SKIP_AUTOMOC SKIP_AUTORCC SKIP_AUTOUIC SKIP_BUILD_RPATH SKIP_RETURN_CODE SOURCES SOURCE_DIR SOVERSION STATIC_LIBRARY_FLAGS STRINGS SUBDIRECTORIES SUFFIX SYMBOLIC TARGET_ARCHIVES_MAY_BE_SHARED_LIBS TARGET_MESSAGES TARGET_SUPPORTS_SHARED_LIBS TEST_INCLUDE_FILE TEST_INCLUDE_FILES TIMEOUT TIMEOUT_AFTER_MATCH TYPE USE_FOLDERS VALUE VARIABLES VERSION VISIBILITY_INLINES_HIDDEN VS_CONFIGURATION_TYPE VS_COPY_TO_OUT_DIR VS_DEBUGGER_WORKING_DIRECTORY VS_DEPLOYMENT_CONTENT VS_DEPLOYMENT_LOCATION VS_DESKTOP_EXTENSIONS_VERSION VS_DOTNET_REFERENCES VS_DOTNET_REFERENCES_COPY_LOCAL VS_DOTNET_TARGET_FRAMEWORK_VERSION VS_GLOBAL_KEYWORD VS_GLOBAL_PROJECT_TYPES VS_GLOBAL_ROOTNAMESPACE VS_INCLUDE_IN_VSIX VS_IOT_EXTENSIONS_VERSION VS_IOT_STARTUP_TASK VS_KEYWORD VS_MOBILE_EXTENSIONS_VERSION VS_RESOURCE_GENERATOR VS_SCC_AUXPATH VS_SCC_LOCALPATH VS_SCC_PROJECTNAME VS_SCC_PROVIDER VS_SDK_REFERENCES VS_SHADER_ENTRYPOINT VS_SHADER_FLAGS VS_SHADER_MODEL VS_SHADER_TYPE VS_SHADER_OUTPUT_HEADER_FILE VS_SHADER_VARIABLE_NAME VS_STARTUP_PROJECT VS_TOOL_OVERRIDE VS_USER_PROPS VS_WINDOWS_TARGET_PLATFORM_MIN_VERSION VS_WINRT_COMPONENT VS_WINRT_EXTENSIONS VS_WINRT_REFERENCES VS_XAML_TYPE WILL_FAIL WIN32_EXECUTABLE WINDOWS_EXPORT_ALL_SYMBOLS WORKING_DIRECTORY WRAP_EXCLUDE XCODE_EMIT_EFFECTIVE_PLATFORM_NAME XCODE_EXPLICIT_FILE_TYPE XCODE_FILE_ATTRIBUTES XCODE_LAST_KNOWN_FILE_TYPE XCODE_PRODUCT_TYPE XCTEST syn keyword cmakeVariable contained \ ANDROID APPLE BORLAND BUILD_SHARED_LIBS CMAKE_ABSOLUTE_DESTINATION_FILES CMAKE_ANDROID_ANT_ADDITIONAL_OPTIONS CMAKE_ANDROID_API CMAKE_ANDROID_API_MIN CMAKE_ANDROID_ARCH CMAKE_ANDROID_ARCH_ABI CMAKE_ANDROID_ARM_MODE CMAKE_ANDROID_ARM_NEON CMAKE_ANDROID_ASSETS_DIRECTORIES CMAKE_ANDROID_GUI CMAKE_ANDROID_JAR_DEPENDENCIES CMAKE_ANDROID_JAR_DIRECTORIES CMAKE_ANDROID_JAVA_SOURCE_DIR CMAKE_ANDROID_NATIVE_LIB_DEPENDENCIES CMAKE_ANDROID_NATIVE_LIB_DIRECTORIES CMAKE_ANDROID_NDK CMAKE_ANDROID_NDK_DEPRECATED_HEADERS CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION CMAKE_ANDROID_PROCESS_MAX CMAKE_ANDROID_PROGUARD CMAKE_ANDROID_PROGUARD_CONFIG_PATH CMAKE_ANDROID_SECURE_PROPS_PATH CMAKE_ANDROID_SKIP_ANT_STEP CMAKE_ANDROID_STANDALONE_TOOLCHAIN CMAKE_ANDROID_STL_TYPE CMAKE_APPBUNDLE_PATH CMAKE_AR CMAKE_ARCHIVE_OUTPUT_DIRECTORY CMAKE_ARGC CMAKE_ARGV0 CMAKE_AUTOMOC CMAKE_AUTOMOC_DEPEND_FILTERS CMAKE_AUTOMOC_MACRO_NAMES CMAKE_AUTOMOC_MOC_OPTIONS CMAKE_AUTOMOC_RELAXED_MODE CMAKE_AUTORCC CMAKE_AUTORCC_OPTIONS CMAKE_AUTOUIC CMAKE_AUTOUIC_OPTIONS CMAKE_AUTOUIC_SEARCH_PATHS CMAKE_BACKWARDS_COMPATIBILITY CMAKE_BINARY_DIR CMAKE_BUILD_RPATH CMAKE_BUILD_TOOL CMAKE_BUILD_TYPE CMAKE_BUILD_WITH_INSTALL_NAME_DIR CMAKE_BUILD_WITH_INSTALL_RPATH CMAKE_CACHEFILE_DIR CMAKE_CACHE_MAJOR_VERSION CMAKE_CACHE_MINOR_VERSION CMAKE_CACHE_PATCH_VERSION CMAKE_CFG_INTDIR CMAKE_CL_64 CMAKE_CODELITE_USE_TARGETS CMAKE_COLOR_MAKEFILE CMAKE_COMMAND CMAKE_COMPILER_2005 CMAKE_COMPILER_IS_GNUCC CMAKE_COMPILER_IS_GNUCXX CMAKE_COMPILER_IS_GNUG77 CMAKE_COMPILE_PDB_OUTPUT_DIRECTORY CMAKE_CONFIGURATION_TYPES CMAKE_CROSSCOMPILING CMAKE_CROSSCOMPILING_EMULATOR CMAKE_CTEST_COMMAND CMAKE_CUDA_EXTENSIONS CMAKE_CUDA_STANDARD CMAKE_CUDA_STANDARD_REQUIRED CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES CMAKE_CURRENT_BINARY_DIR CMAKE_CURRENT_LIST_DIR CMAKE_CURRENT_LIST_FILE CMAKE_CURRENT_LIST_LINE CMAKE_CURRENT_SOURCE_DIR CMAKE_CXX_COMPILE_FEATURES CMAKE_CXX_EXTENSIONS CMAKE_CXX_STANDARD CMAKE_CXX_STANDARD_REQUIRED CMAKE_C_COMPILE_FEATURES CMAKE_C_EXTENSIONS CMAKE_C_STANDARD CMAKE_C_STANDARD_REQUIRED CMAKE_DEBUG_POSTFIX CMAKE_DEBUG_TARGET_PROPERTIES CMAKE_DEPENDS_IN_PROJECT_ONLY CMAKE_DIRECTORY_LABELS CMAKE_DL_LIBS CMAKE_ECLIPSE_GENERATE_LINKED_RESOURCES CMAKE_ECLIPSE_GENERATE_SOURCE_PROJECT CMAKE_ECLIPSE_MAKE_ARGUMENTS CMAKE_ECLIPSE_VERSION CMAKE_EDIT_COMMAND CMAKE_ENABLE_EXPORTS CMAKE_ERROR_DEPRECATED CMAKE_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION CMAKE_EXECUTABLE_SUFFIX CMAKE_EXE_LINKER_FLAGS CMAKE_EXE_LINKER_FLAGS_INIT CMAKE_EXPORT_COMPILE_COMMANDS CMAKE_EXPORT_NO_PACKAGE_REGISTRY CMAKE_EXTRA_GENERATOR CMAKE_EXTRA_SHARED_LIBRARY_SUFFIXES CMAKE_FIND_APPBUNDLE CMAKE_FIND_FRAMEWORK CMAKE_FIND_LIBRARY_CUSTOM_LIB_SUFFIX CMAKE_FIND_LIBRARY_PREFIXES CMAKE_FIND_LIBRARY_SUFFIXES CMAKE_FIND_NO_INSTALL_PREFIX CMAKE_FIND_PACKAGE_NAME CMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY CMAKE_FIND_PACKAGE_NO_SYSTEM_PACKAGE_REGISTRY CMAKE_FIND_PACKAGE_SORT_DIRECTION CMAKE_FIND_PACKAGE_SORT_ORDER CMAKE_FIND_PACKAGE_WARN_NO_MODULE CMAKE_FIND_ROOT_PATH CMAKE_FIND_ROOT_PATH_MODE_INCLUDE CMAKE_FIND_ROOT_PATH_MODE_LIBRARY CMAKE_FIND_ROOT_PATH_MODE_PACKAGE CMAKE_FIND_ROOT_PATH_MODE_PROGRAM CMAKE_FRAMEWORK_PATH CMAKE_Fortran_FORMAT CMAKE_Fortran_MODDIR_DEFAULT CMAKE_Fortran_MODDIR_FLAG CMAKE_Fortran_MODOUT_FLAG CMAKE_Fortran_MODULE_DIRECTORY CMAKE_GENERATOR CMAKE_GENERATOR_PLATFORM CMAKE_GENERATOR_TOOLSET CMAKE_GNUtoMS CMAKE_HOME_DIRECTORY CMAKE_HOST_APPLE CMAKE_HOST_SOLARIS CMAKE_HOST_SYSTEM CMAKE_HOST_SYSTEM_NAME CMAKE_HOST_SYSTEM_PROCESSOR CMAKE_HOST_SYSTEM_VERSION CMAKE_HOST_UNIX CMAKE_HOST_WIN32 CMAKE_IGNORE_PATH CMAKE_IMPORT_LIBRARY_PREFIX CMAKE_IMPORT_LIBRARY_SUFFIX CMAKE_INCLUDE_CURRENT_DIR CMAKE_INCLUDE_CURRENT_DIR_IN_INTERFACE CMAKE_INCLUDE_DIRECTORIES_BEFORE CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE CMAKE_INCLUDE_PATH CMAKE_INSTALL_DEFAULT_COMPONENT_NAME CMAKE_INSTALL_MESSAGE CMAKE_INSTALL_NAME_DIR CMAKE_INSTALL_PREFIX CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT CMAKE_INSTALL_RPATH CMAKE_INSTALL_RPATH_USE_LINK_PATH CMAKE_INTERNAL_PLATFORM_ABI CMAKE_INTERPROCEDURAL_OPTIMIZATION CMAKE_IOS_INSTALL_COMBINED CMAKE_JOB_POOL_COMPILE CMAKE_JOB_POOL_LINK CMAKE_LIBRARY_ARCHITECTURE CMAKE_LIBRARY_ARCHITECTURE_REGEX CMAKE_LIBRARY_OUTPUT_DIRECTORY CMAKE_LIBRARY_PATH CMAKE_LIBRARY_PATH_FLAG CMAKE_LINK_DEF_FILE_FLAG CMAKE_LINK_DEPENDS_NO_SHARED CMAKE_LINK_INTERFACE_LIBRARIES CMAKE_LINK_LIBRARY_FILE_FLAG CMAKE_LINK_LIBRARY_FLAG CMAKE_LINK_LIBRARY_SUFFIX CMAKE_LINK_SEARCH_END_STATIC CMAKE_LINK_SEARCH_START_STATIC CMAKE_LINK_WHAT_YOU_USE CMAKE_MACOSX_BUNDLE CMAKE_MACOSX_RPATH CMAKE_MAJOR_VERSION CMAKE_MAKE_PROGRAM CMAKE_MATCH_COUNT CMAKE_MFC_FLAG CMAKE_MINIMUM_REQUIRED_VERSION CMAKE_MINOR_VERSION CMAKE_MODULE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS_INIT CMAKE_MODULE_PATH CMAKE_MSVCIDE_RUN_PATH CMAKE_NINJA_OUTPUT_PATH_PREFIX CMAKE_NOT_USING_CONFIG_FLAGS CMAKE_NO_BUILTIN_CHRPATH CMAKE_NO_SYSTEM_FROM_IMPORTED CMAKE_OBJECT_PATH_MAX CMAKE_OSX_ARCHITECTURES CMAKE_OSX_DEPLOYMENT_TARGET CMAKE_OSX_SYSROOT CMAKE_PARENT_LIST_FILE CMAKE_PATCH_VERSION CMAKE_PDB_OUTPUT_DIRECTORY CMAKE_POSITION_INDEPENDENT_CODE CMAKE_PREFIX_PATH CMAKE_PROGRAM_PATH CMAKE_PROJECT_DESCRIPTION CMAKE_PROJECT_NAME CMAKE_RANLIB CMAKE_ROOT CMAKE_RUNTIME_OUTPUT_DIRECTORY CMAKE_SCRIPT_MODE_FILE CMAKE_SHARED_LIBRARY_PREFIX CMAKE_SHARED_LIBRARY_SUFFIX CMAKE_SHARED_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS_INIT CMAKE_SHARED_MODULE_PREFIX CMAKE_SHARED_MODULE_SUFFIX CMAKE_SIZEOF_VOID_P CMAKE_SKIP_BUILD_RPATH CMAKE_SKIP_INSTALL_ALL_DEPENDENCY CMAKE_SKIP_INSTALL_RPATH CMAKE_SKIP_INSTALL_RULES CMAKE_SKIP_RPATH CMAKE_SOURCE_DIR CMAKE_STAGING_PREFIX CMAKE_STATIC_LIBRARY_PREFIX CMAKE_STATIC_LIBRARY_SUFFIX CMAKE_STATIC_LINKER_FLAGS CMAKE_STATIC_LINKER_FLAGS_INIT CMAKE_SUBLIME_TEXT_2_ENV_SETTINGS CMAKE_SUBLIME_TEXT_2_EXCLUDE_BUILD_TREE CMAKE_SYSROOT CMAKE_SYSROOT_COMPILE CMAKE_SYSROOT_LINK CMAKE_SYSTEM CMAKE_SYSTEM_APPBUNDLE_PATH CMAKE_SYSTEM_FRAMEWORK_PATH CMAKE_SYSTEM_IGNORE_PATH CMAKE_SYSTEM_INCLUDE_PATH CMAKE_SYSTEM_LIBRARY_PATH CMAKE_SYSTEM_NAME CMAKE_SYSTEM_PREFIX_PATH CMAKE_SYSTEM_PROCESSOR CMAKE_SYSTEM_PROGRAM_PATH CMAKE_SYSTEM_VERSION CMAKE_Swift_LANGUAGE_VERSION CMAKE_TOOLCHAIN_FILE CMAKE_TRY_COMPILE_CONFIGURATION CMAKE_TRY_COMPILE_PLATFORM_VARIABLES CMAKE_TRY_COMPILE_TARGET_TYPE CMAKE_TWEAK_VERSION CMAKE_USER_MAKE_RULES_OVERRIDE CMAKE_USE_RELATIVE_PATHS CMAKE_VERBOSE_MAKEFILE CMAKE_VERSION CMAKE_VISIBILITY_INLINES_HIDDEN CMAKE_VS_DEVENV_COMMAND CMAKE_VS_INCLUDE_INSTALL_TO_DEFAULT_BUILD CMAKE_VS_INCLUDE_PACKAGE_TO_DEFAULT_BUILD CMAKE_VS_INTEL_Fortran_PROJECT_VERSION CMAKE_VS_MSBUILD_COMMAND CMAKE_VS_NsightTegra_VERSION CMAKE_VS_PLATFORM_NAME CMAKE_VS_PLATFORM_TOOLSET CMAKE_VS_PLATFORM_TOOLSET_CUDA CMAKE_VS_PLATFORM_TOOLSET_HOST_ARCHITECTURE CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION CMAKE_WARN_DEPRECATED CMAKE_WARN_ON_ABSOLUTE_INSTALL_DESTINATION CMAKE_WIN32_EXECUTABLE CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS CMAKE_XCODE_GENERATE_SCHEME CMAKE_XCODE_PLATFORM_TOOLSET CPACK_ABSOLUTE_DESTINATION_FILES CPACK_COMPONENT_INCLUDE_TOPLEVEL_DIRECTORY CPACK_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION CPACK_INCLUDE_TOPLEVEL_DIRECTORY CPACK_INSTALL_SCRIPT CPACK_PACKAGING_INSTALL_PREFIX CPACK_SET_DESTDIR CPACK_WARN_ON_ABSOLUTE_INSTALL_DESTINATION CTEST_BINARY_DIRECTORY CTEST_BUILD_COMMAND CTEST_BUILD_NAME CTEST_BZR_COMMAND CTEST_BZR_UPDATE_OPTIONS CTEST_CHANGE_ID CTEST_CHECKOUT_COMMAND CTEST_CONFIGURATION_TYPE CTEST_CONFIGURE_COMMAND CTEST_COVERAGE_COMMAND CTEST_COVERAGE_EXTRA_FLAGS CTEST_CURL_OPTIONS CTEST_CUSTOM_COVERAGE_EXCLUDE CTEST_CUSTOM_ERROR_EXCEPTION CTEST_CUSTOM_ERROR_MATCH CTEST_CUSTOM_ERROR_POST_CONTEXT CTEST_CUSTOM_ERROR_PRE_CONTEXT CTEST_CUSTOM_MAXIMUM_FAILED_TEST_OUTPUT_SIZE CTEST_CUSTOM_MAXIMUM_NUMBER_OF_ERRORS CTEST_CUSTOM_MAXIMUM_NUMBER_OF_WARNINGS CTEST_CUSTOM_MAXIMUM_PASSED_TEST_OUTPUT_SIZE CTEST_CUSTOM_MEMCHECK_IGNORE CTEST_CUSTOM_POST_MEMCHECK CTEST_CUSTOM_POST_TEST CTEST_CUSTOM_PRE_MEMCHECK CTEST_CUSTOM_PRE_TEST CTEST_CUSTOM_TEST_IGNORE CTEST_CUSTOM_WARNING_EXCEPTION CTEST_CUSTOM_WARNING_MATCH CTEST_CVS_CHECKOUT CTEST_CVS_COMMAND CTEST_CVS_UPDATE_OPTIONS CTEST_DROP_LOCATION CTEST_DROP_METHOD CTEST_DROP_SITE CTEST_DROP_SITE_CDASH CTEST_DROP_SITE_PASSWORD CTEST_DROP_SITE_USER CTEST_EXTRA_COVERAGE_GLOB CTEST_GIT_COMMAND CTEST_GIT_INIT_SUBMODULES CTEST_GIT_UPDATE_CUSTOM CTEST_GIT_UPDATE_OPTIONS CTEST_HG_COMMAND CTEST_HG_UPDATE_OPTIONS CTEST_LABELS_FOR_SUBPROJECTS CTEST_MEMORYCHECK_COMMAND CTEST_MEMORYCHECK_COMMAND_OPTIONS CTEST_MEMORYCHECK_SANITIZER_OPTIONS CTEST_MEMORYCHECK_SUPPRESSIONS_FILE CTEST_MEMORYCHECK_TYPE CTEST_NIGHTLY_START_TIME CTEST_P4_CLIENT CTEST_P4_COMMAND CTEST_P4_OPTIONS CTEST_P4_UPDATE_OPTIONS CTEST_SCP_COMMAND CTEST_SITE CTEST_SOURCE_DIRECTORY CTEST_SVN_COMMAND CTEST_SVN_OPTIONS CTEST_SVN_UPDATE_OPTIONS CTEST_TEST_LOAD CTEST_TEST_TIMEOUT CTEST_TRIGGER_SITE CTEST_UPDATE_COMMAND CTEST_UPDATE_OPTIONS CTEST_UPDATE_VERSION_ONLY CTEST_USE_LAUNCHERS CYGWIN ENV EXECUTABLE_OUTPUT_PATH GHS-MULTI LIBRARY_OUTPUT_PATH MINGW MSVC MSVC10 MSVC11 MSVC12 MSVC14 MSVC60 MSVC70 MSVC71 MSVC80 MSVC90 MSVC_IDE MSVC_VERSION PROJECT_BINARY_DIR PROJECT_DESCRIPTION PROJECT_NAME PROJECT_SOURCE_DIR PROJECT_VERSION PROJECT_VERSION_MAJOR PROJECT_VERSION_MINOR PROJECT_VERSION_PATCH PROJECT_VERSION_TWEAK UNIX WIN32 WINCE WINDOWS_PHONE WINDOWS_STORE XCODE XCODE_VERSION syn keyword cmakeModule contained \ ExternalProject syn keyword cmakeKWExternalProject contained \ ALGO AWS BINARY_DIR BUILD_ALWAYS BUILD_BYPRODUCTS BUILD_COMMAND BUILD_IN_SOURCE CMAKE_ARGS CMAKE_CACHE_ARGS CMAKE_CACHE_DEFAULT_ARGS CMAKE_TLS_CAINFO CMAKE_TLS_VERIFY COMMENT CONFIGURE_COMMAND CVS CVSROOT CVS_MODULE CVS_REPOSITORY CVS_TAG DEPENDEES DEPENDERS DEPENDS DOWNLOADED_FILE DOWNLOAD_COMMAND DOWNLOAD_DIR DOWNLOAD_NAME DOWNLOAD_NO_EXTRACT DOWNLOAD_NO_PROGRESS EP_BASE EP_INDEPENDENT_STEP_TARGETS EP_PREFIX EP_STEP_TARGETS EP_UPDATE_DISCONNECTED EXCLUDE_FROM_ALL FORCE GIT_CONFIG GIT_PROGRESS GIT_REMOTE_NAME GIT_REPOSITORY GIT_SHALLOW GIT_SUBMODULES GIT_TAG HG_REPOSITORY HG_TAG HTTP_HEADER HTTP_PASSWORD HTTP_USERNAME INDEPENDENT_STEP_TARGETS INSTALL_COMMAND INSTALL_DIR JOB_POOLS LIST_SEPARATOR LOG_ LOG_BUILD LOG_CONFIGURE LOG_DOWNLOAD LOG_INSTALL LOG_TEST LOG_UPDATE MAKE_EXE NAMES NOTE NO_DEPENDS PATCH_COMMAND PREFIX PROPERTY SOURCE_DIR SOURCE_SUBDIR STAMP_DIR STEP_TARGETS STRING SVN_PASSWORD SVN_REPOSITORY SVN_REVISION SVN_TRUST_CERT SVN_USERNAME TEST_AFTER_INSTALL TEST_BEFORE_INSTALL TEST_COMMAND TEST_EXCLUDE_FROM_MAIN TIMEOUT TLS_CAINFO TLS_VERIFY TMP_DIR TRUE UPDATE_COMMAND UPDATE_DISCONNECTED URL URL_HASH USES_TERMINAL_BUILD USES_TERMINAL_CONFIGURE USES_TERMINAL_DOWNLOAD USES_TERMINAL_INSTALL USES_TERMINAL_TEST USES_TERMINAL_UPDATE WORKING_DIRECTORY syn keyword cmakeKWadd_compile_options contained \ COMPILE_OPTIONS syn keyword cmakeKWadd_custom_command contained \ APPEND ARGS BYPRODUCTS CC COMMAND COMMAND_EXPAND_LISTS COMMENT CROSSCOMPILING_EMULATOR DEPENDS DEPFILE GENERATED IMPLICIT_DEPENDS INCLUDE_DIRECTORIES JOIN MAIN_DEPENDENCY NOT OUTPUT POST_BUILD PRE_BUILD PRE_LINK SYMBOLIC TARGET_FILE TARGET_PROPERTY USES_TERMINAL VERBATIM WORKING_DIRECTORY syn keyword cmakeKWadd_custom_target contained \ ALL BYPRODUCTS CC COMMAND COMMAND_EXPAND_LISTS COMMENT CROSSCOMPILING_EMULATOR DEPENDS GENERATED INCLUDE_DIRECTORIES JOIN SOURCES TARGET_PROPERTY USES_TERMINAL VERBATIM WORKING_DIRECTORY syn keyword cmakeKWadd_definitions contained \ COMPILE_DEFINITIONS syn keyword cmakeKWadd_dependencies contained \ DEPENDS OBJECT_DEPENDS syn keyword cmakeKWadd_executable contained \ ALIAS CONFIG EXCLUDE_FROM_ALL GLOBAL HEADER_FILE_ONLY IMPORTED IMPORTED_ IMPORTED_LOCATION IMPORTED_LOCATION_ MACOSX_BUNDLE OUTPUT_NAME RUNTIME_OUTPUT_DIRECTORY TARGET syn keyword cmakeKWadd_library contained \ ALIAS ARCHIVE_OUTPUT_DIRECTORY CLI CONFIG DLL EXCLUDE_FROM_ALL FRAMEWORK GLOBAL HEADER_FILE_ONLY IMPORTED IMPORTED_ IMPORTED_LOCATION IMPORTED_LOCATION_ INTERFACE_ LIBRARY_OUTPUT_DIRECTORY MODULE OBJECT ON OUTPUT_NAME POSITION_INDEPENDENT_CODE POST_BUILD PRE_BUILD PRE_LINK RUNTIME_OUTPUT_DIRECTORY SHARED STATIC TARGET_OBJECTS UNKNOWN syn keyword cmakeKWadd_subdirectory contained \ EXCLUDE_FROM_ALL syn keyword cmakeKWadd_test contained \ BUILD_TESTING COMMAND CONFIGURATIONS FAIL_REGULAR_EXPRESSION NAME PASS_REGULAR_EXPRESSION TARGET_FILE WILL_FAIL WORKING_DIRECTORY syn keyword cmakeKWbuild_command contained \ CONFIGURATION TARGET syn keyword cmakeKWbuild_name contained \ CMAKE_CXX_COMPILER syn keyword cmakeKWcmake_host_system_information contained \ AVAILABLE_PHYSICAL_MEMORY AVAILABLE_VIRTUAL_MEMORY FQDN HAS_FPU HAS_MMX HAS_MMX_PLUS HAS_SERIAL_NUMBER HAS_SSE HAS_SSE_FP HAS_SSE_MMX HOSTNAME ID NUMBER_OF_LOGICAL_CORES NUMBER_OF_PHYSICAL_CORES OS_NAME OS_PLATFORM OS_RELEASE OS_VERSION PROCESSOR_DESCRIPTION PROCESSOR_NAME PROCESSOR_SERIAL_NUMBER QUERY RESULT TOTAL_PHYSICAL_MEMORY TOTAL_VIRTUAL_MEMORY syn keyword cmakeKWcmake_minimum_required contained \ FATAL_ERROR VERSION syn keyword cmakeKWcmake_parse_arguments contained \ ARGN CONFIGURATIONS DESTINATION FALSE FAST FILES MY_INSTALL MY_INSTALL_CONFIGURATIONS MY_INSTALL_DESTINATION MY_INSTALL_FAST MY_INSTALL_OPTIONAL MY_INSTALL_RENAME MY_INSTALL_TARGETS MY_INSTALL_UNPARSED_ARGUMENTS OPTIONAL PARSE_ARGV RENAME TARGETS TRUE _UNPARSED_ARGUMENTS syn keyword cmakeKWcmake_policy contained \ CMAKE_POLICY_DEFAULT_CMP CMP GET NNNN NO_POLICY_SCOPE OLD POP PUSH SET VERSION syn keyword cmakeKWconfigure_file contained \ COPYONLY CRLF DOS ESCAPE_QUOTES FOO_ENABLE FOO_STRING LF NEWLINE_STYLE VAR syn keyword cmakeKWcreate_test_sourcelist contained \ CMAKE_TESTDRIVER_AFTER_TESTMAIN CMAKE_TESTDRIVER_BEFORE_TESTMAIN EXTRA_INCLUDE FUNCTION syn keyword cmakeKWctest_build contained \ ALL_BUILD APPEND BUILD CAPTURE_CMAKE_ERROR CONFIGURATION CTEST_BUILD_CONFIGURATION CTEST_BUILD_FLAGS CTEST_BUILD_TARGET CTEST_PROJECT_NAME FLAGS NUMBER_ERRORS NUMBER_WARNINGS QUIET RETURN_VALUE TARGET syn keyword cmakeKWctest_configure contained \ APPEND BUILD CAPTURE_CMAKE_ERROR OPTIONS QUIET RETURN_VALUE SOURCE syn keyword cmakeKWctest_coverage contained \ APPEND BUILD CAPTURE_CMAKE_ERROR LABELS QUIET RETURN_VALUE syn keyword cmakeKWctest_memcheck contained \ APPEND BUILD DEFECT_COUNT EXCLUDE EXCLUDE_FIXTURE EXCLUDE_FIXTURE_CLEANUP EXCLUDE_FIXTURE_SETUP EXCLUDE_LABEL INCLUDE INCLUDE_LABEL OFF ON PARALLEL_LEVEL QUIET RETURN_VALUE SCHEDULE_RANDOM START STOP_TIME STRIDE TEST_LOAD syn keyword cmakeKWctest_run_script contained \ NEW_PROCESS RETURN_VALUE syn keyword cmakeKWctest_start contained \ APPEND QUIET TAG TRACK syn keyword cmakeKWctest_submit contained \ API CDASH_UPLOAD CDASH_UPLOAD_TYPE CTEST_EXTRA_SUBMIT_FILES CTEST_NOTES_FILES FILES HTTPHEADER PARTS QUIET RETRY_COUNT RETRY_DELAY RETURN_VALUE syn keyword cmakeKWctest_test contained \ APPEND BUILD CAPTURE_CMAKE_ERROR CPU EXCLUDE EXCLUDE_FIXTURE EXCLUDE_FIXTURE_CLEANUP EXCLUDE_FIXTURE_SETUP EXCLUDE_LABEL INCLUDE INCLUDE_LABEL OFF ON PARALLEL_LEVEL QUIET RETURN_VALUE SCHEDULE_RANDOM START STOP_TIME STRIDE TEST_LOAD syn keyword cmakeKWctest_update contained \ QUIET RETURN_VALUE SOURCE syn keyword cmakeKWctest_upload contained \ CAPTURE_CMAKE_ERROR FILES QUIET syn keyword cmakeKWdefine_property contained \ BRIEF_DOCS CACHED_VARIABLE DIRECTORY FULL_DOCS GLOBAL INHERITED PROPERTY SOURCE TARGET TEST VARIABLE syn keyword cmakeKWenable_language contained \ OPTIONAL syn keyword cmakeKWexec_program contained \ ARGS OUTPUT_VARIABLE RETURN_VALUE syn keyword cmakeKWexecute_process contained \ ANSI AUTO COMMAND ENCODING ERROR_FILE ERROR_QUIET ERROR_STRIP_TRAILING_WHITESPACE ERROR_VARIABLE INPUT_FILE NONE OEM OUTPUT_FILE OUTPUT_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE RESULTS_VARIABLE RESULT_VARIABLE TIMEOUT UTF VERBATIM WORKING_DIRECTORY syn keyword cmakeKWexport contained \ ANDROID_MK APPEND CONFIG EXPORT EXPORT_LINK_INTERFACE_LIBRARIES FILE IMPORTED IMPORTED_ NAMESPACE NDK OLD PACKAGE TARGETS syn keyword cmakeKWexport_library_dependencies contained \ APPEND EXPORT INCLUDE LINK_INTERFACE_LIBRARIES SET syn keyword cmakeKWfile contained \ ALGO APPEND ASCII CMAKE_TLS_CAINFO CMAKE_TLS_VERIFY CONDITION CONFIG CONTENT COPY CR DESTINATION DIRECTORY_PERMISSIONS DOWNLOAD ENCODING EXCLUDE EXPECTED_HASH FILES_MATCHING FILE_PERMISSIONS FOLLOW_SYMLINKS FUNCTION GENERATE GLOB GLOB_RECURSE GUARD HASH HEX HTTPHEADER INACTIVITY_TIMEOUT INSTALL LENGTH_MAXIMUM LENGTH_MINIMUM LF LIMIT LIMIT_COUNT LIMIT_INPUT LIMIT_OUTPUT LIST_DIRECTORIES LOCK LOG MAKE_DIRECTORY NEWLINE_CONSUME NO_HEX_CONVERSION NO_SOURCE_PERMISSIONS OFFSET OLD PATTERN PROCESS READ REGEX RELATIVE RELATIVE_PATH RELEASE REMOVE REMOVE_RECURSE RENAME RESULT_VARIABLE SHOW_PROGRESS SSL STATUS STRINGS TIMESTAMP TLS_CAINFO TLS_VERIFY TO_CMAKE_PATH TO_NATIVE_PATH UPLOAD USERPWD USE_SOURCE_PERMISSIONS UTC UTF WRITE syn keyword cmakeKWfind_file contained \ CMAKE_FIND_ROOT_PATH_BOTH DOC DVAR HINTS INCLUDE NAMES NO_CMAKE_ENVIRONMENT_PATH NO_CMAKE_FIND_ROOT_PATH NO_CMAKE_PATH NO_CMAKE_SYSTEM_PATH NO_DEFAULT_PATH NO_SYSTEM_ENVIRONMENT_PATH ONLY_CMAKE_FIND_ROOT_PATH OS PATHS PATH_SUFFIXES VAR syn keyword cmakeKWfind_library contained \ CMAKE_FIND_ROOT_PATH_BOTH DOC DVAR HINTS LIB NAMES NAMES_PER_DIR NO_CMAKE_ENVIRONMENT_PATH NO_CMAKE_FIND_ROOT_PATH NO_CMAKE_PATH NO_CMAKE_SYSTEM_PATH NO_DEFAULT_PATH NO_SYSTEM_ENVIRONMENT_PATH ONLY_CMAKE_FIND_ROOT_PATH OS PATHS PATH_SUFFIXES VAR syn keyword cmakeKWfind_package contained \ CMAKE_DISABLE_FIND_PACKAGE_ CMAKE_FIND_ROOT_PATH_BOTH COMPONENTS CONFIG CONFIGS DEC DVAR EXACT HINTS MODULE NAMES NATURAL NO_CMAKE_BUILDS_PATH NO_CMAKE_ENVIRONMENT_PATH NO_CMAKE_FIND_ROOT_PATH NO_CMAKE_PACKAGE_REGISTRY NO_CMAKE_PATH NO_CMAKE_SYSTEM_PACKAGE_REGISTRY NO_CMAKE_SYSTEM_PATH NO_DEFAULT_PATH NO_MODULE NO_POLICY_SCOPE NO_SYSTEM_ENVIRONMENT_PATH ONLY_CMAKE_FIND_ROOT_PATH OPTIONAL_COMPONENTS OS PACKAGE_FIND_NAME PACKAGE_FIND_VERSION PACKAGE_FIND_VERSION_COUNT PACKAGE_FIND_VERSION_MAJOR PACKAGE_FIND_VERSION_MINOR PACKAGE_FIND_VERSION_PATCH PACKAGE_FIND_VERSION_TWEAK PACKAGE_VERSION PACKAGE_VERSION_COMPATIBLE PACKAGE_VERSION_EXACT PACKAGE_VERSION_UNSUITABLE PATHS PATH_SUFFIXES QUIET REQUIRED SET TRUE _CONFIG _CONSIDERED_CONFIGS _CONSIDERED_VERSIONS _DIR _FIND_COMPONENTS _FIND_QUIETLY _FIND_REQUIRED _FIND_REQUIRED_ _FIND_VERSION_EXACT _FOUND syn keyword cmakeKWfind_path contained \ CMAKE_FIND_ROOT_PATH_BOTH DOC DVAR HINTS INCLUDE NAMES NO_CMAKE_ENVIRONMENT_PATH NO_CMAKE_FIND_ROOT_PATH NO_CMAKE_PATH NO_CMAKE_SYSTEM_PATH NO_DEFAULT_PATH NO_SYSTEM_ENVIRONMENT_PATH ONLY_CMAKE_FIND_ROOT_PATH OS PATHS PATH_SUFFIXES VAR syn keyword cmakeKWfind_program contained \ CMAKE_FIND_ROOT_PATH_BOTH DOC DVAR HINTS NAMES NAMES_PER_DIR NO_CMAKE_ENVIRONMENT_PATH NO_CMAKE_FIND_ROOT_PATH NO_CMAKE_PATH NO_CMAKE_SYSTEM_PATH NO_DEFAULT_PATH NO_SYSTEM_ENVIRONMENT_PATH ONLY_CMAKE_FIND_ROOT_PATH OS PATHS PATH_SUFFIXES VAR syn keyword cmakeKWfltk_wrap_ui contained \ FLTK syn keyword cmakeKWforeach contained \ ARGS IN ITEMS LISTS RANGE syn keyword cmakeKWfunction contained \ ARGC ARGN ARGS ARGV PARENT_SCOPE syn keyword cmakeKWget_cmake_property contained \ COMPONENTS GLOBAL MACROS VAR VARIABLES syn keyword cmakeKWget_directory_property contained \ DEFINITION DIRECTORY syn keyword cmakeKWget_filename_component contained \ ABSOLUTE ARG_VAR BASE_DIR CACHE COMP DIRECTORY EXT NAME NAME_WE PATH PROGRAM PROGRAM_ARGS REALPATH VAR syn keyword cmakeKWget_property contained \ BRIEF_DOCS CACHE DEFINED DIRECTORY FULL_DOCS GLOBAL INSTALL PROPERTY SET SOURCE TARGET TEST VARIABLE syn keyword cmakeKWget_source_file_property contained \ LOCATION VAR syn keyword cmakeKWget_target_property contained \ VAR syn keyword cmakeKWget_test_property contained \ VAR syn keyword cmakeKWif contained \ ARGS CMAKE_MATCH_ CMP COMMAND DEFINED EQUAL EXISTS FALSE GREATER GREATER_EQUAL IGNORE IN_LIST IS_ABSOLUTE IS_DIRECTORY IS_NEWER_THAN IS_SYMLINK LESS LESS_EQUAL MATCHES NNNN NOT OFF OR POLICY STREQUAL STRGREATER STRGREATER_EQUAL STRLESS STRLESS_EQUAL TARGET TEST THEN TRUE VERSION_EQUAL VERSION_GREATER VERSION_GREATER_EQUAL VERSION_LESS VERSION_LESS_EQUAL YES syn keyword cmakeKWinclude contained \ NO_POLICY_SCOPE OPTIONAL RESULT_VARIABLE syn keyword cmakeKWinclude_directories contained \ AFTER BEFORE INCLUDE_DIRECTORIES ON SYSTEM syn keyword cmakeKWinclude_external_msproject contained \ GUID MAP_IMPORTED_CONFIG_ PLATFORM TYPE WIX syn keyword cmakeKWinclude_guard contained \ DIRECTORY GLOBAL TRUE __CURRENT_FILE_VAR__ syn keyword cmakeKWinstall contained \ ARCHIVE BUNDLE CODE COMPONENT CONFIGURATIONS CVS DESTDIR DESTINATION DIRECTORY DIRECTORY_PERMISSIONS DLL EXCLUDE_FROM_ALL EXPORT EXPORT_ANDROID_MK EXPORT_LINK_INTERFACE_LIBRARIES FILES FILES_MATCHING FILE_PERMISSIONS FRAMEWORK GROUP_EXECUTE GROUP_READ GROUP_WRITE IMPORTED_ INCLUDES INSTALL_PREFIX INTERFACE_INCLUDE_DIRECTORIES LIBRARY MACOSX_BUNDLE MESSAGE_NEVER NAMELINK_ONLY NAMELINK_SKIP NAMESPACE NDK OBJECTS OPTIONAL OWNER_EXECUTE OWNER_READ OWNER_WRITE PATTERN PERMISSIONS POST_INSTALL_SCRIPT PRE_INSTALL_SCRIPT PRIVATE_HEADER PROGRAMS PUBLIC_HEADER REGEX RENAME RESOURCE RUNTIME SCRIPT SETGID SETUID SOVERSION TARGETS TRUE USE_SOURCE_PERMISSIONS VERSION WORLD_EXECUTE WORLD_READ WORLD_WRITE syn keyword cmakeKWinstall_files contained \ FILES GLOB syn keyword cmakeKWinstall_programs contained \ FILES GLOB PROGRAMS TARGETS syn keyword cmakeKWinstall_targets contained \ DLL RUNTIME_DIRECTORY TARGETS syn keyword cmakeKWlist contained \ APPEND CACHE EXCLUDE FILTER FIND GET INCLUDE INSERT INTERNAL LENGTH LIST NOTES PARENT_SCOPE REGEX REMOVE_AT REMOVE_DUPLICATES REMOVE_ITEM REVERSE SORT syn keyword cmakeKWload_cache contained \ EXCLUDE INCLUDE_INTERNALS READ_WITH_PREFIX syn keyword cmakeKWload_command contained \ CMAKE_LOADED_COMMAND_ COMMAND_NAME syn keyword cmakeKWmacro contained \ ARGC ARGN ARGS ARGV DEFINED GREATER LISTS NOT _BAR _FOO syn keyword cmakeKWmake_directory contained \ MAKE_DIRECTORY syn keyword cmakeKWmark_as_advanced contained \ CLEAR FORCE VAR syn keyword cmakeKWmath contained \ EXPR syn keyword cmakeKWmessage contained \ AUTHOR_WARNING DEPRECATION FATAL_ERROR GUI SEND_ERROR STATUS WARNING syn keyword cmakeKWoption contained \ OFF ON syn keyword cmakeKWproject contained \ CMAKE_PROJECT_ DESCRIPTION LANGUAGES NAME NONE PROJECT VERSION _BINARY_DIR _INCLUDE _SOURCE_DIR _VERSION _VERSION_MAJOR _VERSION_MINOR _VERSION_PATCH _VERSION_TWEAK syn keyword cmakeKWremove contained \ REMOVE_ITEM VALUE VAR syn keyword cmakeKWseparate_arguments contained \ MSDN NATIVE NATIVE_COMMAND UNIX_COMMAND WINDOWS WINDOWS_COMMAND _COMMAND syn keyword cmakeKWset contained \ BOOL CACHE FILEPATH FORCE INTERNAL OFF ON PARENT_SCOPE STRING STRINGS syn keyword cmakeKWset_directory_properties contained \ PROPERTIES syn keyword cmakeKWset_property contained \ APPEND APPEND_STRING CACHE DIRECTORY GLOBAL INSTALL PROPERTY SOURCE TARGET TEST WIX syn keyword cmakeKWset_source_files_properties contained \ PROPERTIES syn keyword cmakeKWset_target_properties contained \ PROPERTIES syn keyword cmakeKWset_tests_properties contained \ PROPERTIES syn keyword cmakeKWsource_group contained \ FILES PREFIX REGULAR_EXPRESSION TREE syn keyword cmakeKWstring contained \ ALPHABET APPEND ASCII CMAKE_MATCH_ COMPARE CONCAT CONFIGURE EQUAL ESCAPE_QUOTES FIND GENEX_STRIP GREATER GREATER_EQUAL GUID HASH LENGTH LESS LESS_EQUAL MAKE_C_IDENTIFIER MATCH MATCHALL MATCHES NAMESPACE NOTEQUAL ONLY PREPEND RANDOM RANDOM_SEED REGEX REPLACE REVERSE RFC SHA SOURCE_DATE_EPOCH STRIP SUBSTRING SZ TIMESTAMP TOLOWER TOUPPER TYPE US UTC UUID syn keyword cmakeKWsubdirs contained \ EXCLUDE_FROM_ALL PREORDER syn keyword cmakeKWtarget_compile_definitions contained \ COMPILE_DEFINITIONS INTERFACE INTERFACE_COMPILE_DEFINITIONS PRIVATE PUBLIC syn keyword cmakeKWtarget_compile_features contained \ COMPILE_FEATURES IMPORTED INTERFACE INTERFACE_COMPILE_FEATURES PRIVATE PUBLIC syn keyword cmakeKWtarget_compile_options contained \ BEFORE COMPILE_OPTIONS IMPORTED INTERFACE INTERFACE_COMPILE_OPTIONS PRIVATE PUBLIC syn keyword cmakeKWtarget_include_directories contained \ BEFORE BUILD_INTERFACE IMPORTED INCLUDE_DIRECTORIES INSTALL_INTERFACE INTERFACE INTERFACE_INCLUDE_DIRECTORIES INTERFACE_LINK_LIBRARIES INTERFACE_SYSTEM_INCLUDE_DIRECTORIES PRIVATE PUBLIC SYSTEM syn keyword cmakeKWtarget_link_libraries contained \ ALIAS DAG DEBUG_CONFIGURATIONS IMPORTED IMPORTED_NO_SONAME INTERFACE INTERFACE_LINK_LIBRARIES LINK_FLAGS LINK_INTERFACE_LIBRARIES LINK_INTERFACE_LIBRARIES_DEBUG LINK_INTERFACE_MULTIPLICITY LINK_PRIVATE LINK_PUBLIC OLD OSX PRIVATE PUBLIC STATIC syn keyword cmakeKWtarget_sources contained \ IMPORTED INTERFACE INTERFACE_SOURCES PRIVATE PUBLIC SOURCES syn keyword cmakeKWtry_compile contained \ ALL_BUILD CMAKE_FLAGS COMPILE_DEFINITIONS COPY_FILE COPY_FILE_ERROR CUDA_EXTENSIONS CUDA_STANDARD CUDA_STANDARD_REQUIRED CXX_EXTENSIONS CXX_STANDARD CXX_STANDARD_REQUIRED C_EXTENSIONS C_STANDARD C_STANDARD_REQUIRED DEFINED DLINK_LIBRARIES DVAR FALSE INCLUDE_DIRECTORIES LANG LINK_DIRECTORIES LINK_LIBRARIES NOT OUTPUT_VARIABLE RESULT_VAR SOURCES TRUE TYPE VALUE _EXTENSIONS _STANDARD _STANDARD_REQUIRED syn keyword cmakeKWtry_run contained \ ARGS CMAKE_FLAGS COMPILE_DEFINITIONS COMPILE_OUTPUT_VARIABLE COMPILE_RESULT_VAR DLINK_LIBRARIES DVAR FAILED_TO_RUN FALSE INCLUDE_DIRECTORIES LINK_DIRECTORIES LINK_LIBRARIES RUN_OUTPUT_VARIABLE RUN_RESULT_VAR TRUE TYPE VALUE __TRYRUN_OUTPUT syn keyword cmakeKWunset contained \ CACHE LD_LIBRARY_PATH PARENT_SCOPE syn keyword cmakeKWuse_mangled_mesa contained \ GL OUTPUT_DIRECTORY PATH_TO_MESA syn keyword cmakeKWvariable_requires contained \ RESULT_VARIABLE TEST_VARIABLE syn keyword cmakeKWvariable_watch contained \ COMMAND syn keyword cmakeKWwhile contained \ ARGS syn keyword cmakeKWwrite_file contained \ APPEND CONFIGURE_FILE NOTE WRITE syn keyword cmakeGeneratorExpressions contained \ LINK_LIBRARIES INCLUDE_DIRECTORIES COMPILE_DEFINITIONS CONFIG DEBUG_MODE BOOL AND NOT IF STREQUAL MAP_IMPORTED_CONFIG_ PLATFORM_ID C_COMPILER_ID CXX_COMPILER_ID VERSION_LESS VERSION_GREATER VERSION_EQUAL VERSION_LESS_EQUAL VERSION_GREATER_EQUAL C_COMPILER_VERSION CXX_COMPILER_VERSION TARGET_POLICY COMPILE_FEATURES C_STANDARD CXX_STANDARD COMPILE_LANGUAGE PRIVATE PUBLIC COMPILING_CXX GNU OLD_COMPILER CMAKE_CXX_COMPILER_VERSION CONFIGURATION TARGET_FILE TARGET_FILE_NAME TARGET_FILE_DIR TARGET_LINKER_FILE TARGET_LINKER_FILE_NAME TARGET_LINKER_FILE_DIR TARGET_SONAME_FILE TARGET_SONAME_FILE_NAME TARGET_SONAME_FILE_DIR TARGET_PDB_FILE PDB_NAME PDB_OUTPUT_DIRECTORY PDB_NAME_ PDB_OUTPUT_DIRECTORY_ TARGET_PDB_FILE_NAME TARGET_PDB_FILE_DIR TARGET_BUNDLE_DIR TARGET_BUNDLE_CONTENT_DIR SDK TARGET_PROPERTY INSTALL_PREFIX EXPORT JOIN ANGLE COMMA SEMICOLON TARGET_NAME LINK_ONLY INTERFACE_LINK_LIBRARIES INSTALL_INTERFACE BUILD_INTERFACE LOWER_CASE UPPER_CASE MAKE_C_IDENTIFIER TARGET_OBJECTS OBJECT_LIBRARY SHELL_PATH MSYS syn case ignore syn keyword cmakeCommand \ add_compile_options add_custom_command add_custom_target add_definitions add_dependencies add_executable add_library add_subdirectory add_test aux_source_directory break build_command cmake_host_system_information cmake_minimum_required cmake_parse_arguments cmake_policy configure_file continue create_test_sourcelist ctest_build ctest_configure ctest_coverage ctest_empty_binary_directory ctest_memcheck ctest_read_custom_files ctest_run_script ctest_sleep ctest_start ctest_submit ctest_test ctest_update ctest_upload define_property enable_language enable_testing endfunction endmacro execute_process export file find_file find_library find_package find_path find_program fltk_wrap_ui function get_cmake_property get_directory_property get_filename_component get_property get_source_file_property get_target_property get_test_property include include_directories include_external_msproject include_guard include_regular_expression install link_directories list load_cache load_command macro mark_as_advanced math message option project qt_wrap_cpp qt_wrap_ui remove_definitions return separate_arguments set set_directory_properties set_property set_source_files_properties set_target_properties set_tests_properties site_name source_group string target_compile_definitions target_compile_features target_compile_options target_include_directories target_link_libraries target_sources try_compile try_run unset variable_watch \ nextgroup=cmakeArguments syn keyword cmakeCommandConditional \ else elseif endif if \ nextgroup=cmakeArguments syn keyword cmakeCommandRepeat \ endforeach endwhile foreach while \ nextgroup=cmakeArguments syn keyword cmakeCommandDeprecated \ build_name exec_program export_library_dependencies install_files install_programs install_targets link_libraries make_directory output_required_files remove subdir_depends subdirs use_mangled_mesa utility_source variable_requires write_file \ nextgroup=cmakeArguments syn case match syn keyword cmakeTodo \ TODO FIXME XXX \ contained hi def link cmakeCommand Function hi def link cmakeCommandConditional Conditional hi def link cmakeCommandDeprecated WarningMsg hi def link cmakeCommandRepeat Repeat hi def link cmakeComment Comment hi def link cmakeEnvironment Special hi def link cmakeEscaped Special hi def link cmakeGeneratorExpression WarningMsg hi def link cmakeGeneratorExpressions Constant hi def link cmakeLuaComment Comment hi def link cmakeModule Include hi def link cmakeProperty Constant hi def link cmakeRegistry Underlined hi def link cmakeString String hi def link cmakeTodo TODO hi def link cmakeVariableValue Type hi def link cmakeVariable Identifier hi def link cmakeKWExternalProject ModeMsg hi def link cmakeKWadd_compile_options ModeMsg hi def link cmakeKWadd_custom_command ModeMsg hi def link cmakeKWadd_custom_target ModeMsg hi def link cmakeKWadd_definitions ModeMsg hi def link cmakeKWadd_dependencies ModeMsg hi def link cmakeKWadd_executable ModeMsg hi def link cmakeKWadd_library ModeMsg hi def link cmakeKWadd_subdirectory ModeMsg hi def link cmakeKWadd_test ModeMsg hi def link cmakeKWbuild_command ModeMsg hi def link cmakeKWbuild_name ModeMsg hi def link cmakeKWcmake_host_system_information ModeMsg hi def link cmakeKWcmake_minimum_required ModeMsg hi def link cmakeKWcmake_parse_arguments ModeMsg hi def link cmakeKWcmake_policy ModeMsg hi def link cmakeKWconfigure_file ModeMsg hi def link cmakeKWcreate_test_sourcelist ModeMsg hi def link cmakeKWctest_build ModeMsg hi def link cmakeKWctest_configure ModeMsg hi def link cmakeKWctest_coverage ModeMsg hi def link cmakeKWctest_memcheck ModeMsg hi def link cmakeKWctest_run_script ModeMsg hi def link cmakeKWctest_start ModeMsg hi def link cmakeKWctest_submit ModeMsg hi def link cmakeKWctest_test ModeMsg hi def link cmakeKWctest_update ModeMsg hi def link cmakeKWctest_upload ModeMsg hi def link cmakeKWdefine_property ModeMsg hi def link cmakeKWenable_language ModeMsg hi def link cmakeKWexec_program ModeMsg hi def link cmakeKWexecute_process ModeMsg hi def link cmakeKWexport ModeMsg hi def link cmakeKWexport_library_dependencies ModeMsg hi def link cmakeKWfile ModeMsg hi def link cmakeKWfind_file ModeMsg hi def link cmakeKWfind_library ModeMsg hi def link cmakeKWfind_package ModeMsg hi def link cmakeKWfind_path ModeMsg hi def link cmakeKWfind_program ModeMsg hi def link cmakeKWfltk_wrap_ui ModeMsg hi def link cmakeKWforeach ModeMsg hi def link cmakeKWfunction ModeMsg hi def link cmakeKWget_cmake_property ModeMsg hi def link cmakeKWget_directory_property ModeMsg hi def link cmakeKWget_filename_component ModeMsg hi def link cmakeKWget_property ModeMsg hi def link cmakeKWget_source_file_property ModeMsg hi def link cmakeKWget_target_property ModeMsg hi def link cmakeKWget_test_property ModeMsg hi def link cmakeKWif ModeMsg hi def link cmakeKWinclude ModeMsg hi def link cmakeKWinclude_directories ModeMsg hi def link cmakeKWinclude_external_msproject ModeMsg hi def link cmakeKWinclude_guard ModeMsg hi def link cmakeKWinstall ModeMsg hi def link cmakeKWinstall_files ModeMsg hi def link cmakeKWinstall_programs ModeMsg hi def link cmakeKWinstall_targets ModeMsg hi def link cmakeKWlist ModeMsg hi def link cmakeKWload_cache ModeMsg hi def link cmakeKWload_command ModeMsg hi def link cmakeKWmacro ModeMsg hi def link cmakeKWmake_directory ModeMsg hi def link cmakeKWmark_as_advanced ModeMsg hi def link cmakeKWmath ModeMsg hi def link cmakeKWmessage ModeMsg hi def link cmakeKWoption ModeMsg hi def link cmakeKWproject ModeMsg hi def link cmakeKWremove ModeMsg hi def link cmakeKWseparate_arguments ModeMsg hi def link cmakeKWset ModeMsg hi def link cmakeKWset_directory_properties ModeMsg hi def link cmakeKWset_property ModeMsg hi def link cmakeKWset_source_files_properties ModeMsg hi def link cmakeKWset_target_properties ModeMsg hi def link cmakeKWset_tests_properties ModeMsg hi def link cmakeKWsource_group ModeMsg hi def link cmakeKWstring ModeMsg hi def link cmakeKWsubdirs ModeMsg hi def link cmakeKWtarget_compile_definitions ModeMsg hi def link cmakeKWtarget_compile_features ModeMsg hi def link cmakeKWtarget_compile_options ModeMsg hi def link cmakeKWtarget_include_directories ModeMsg hi def link cmakeKWtarget_link_libraries ModeMsg hi def link cmakeKWtarget_sources ModeMsg hi def link cmakeKWtry_compile ModeMsg hi def link cmakeKWtry_run ModeMsg hi def link cmakeKWunset ModeMsg hi def link cmakeKWuse_mangled_mesa ModeMsg hi def link cmakeKWvariable_requires ModeMsg hi def link cmakeKWvariable_watch ModeMsg hi def link cmakeKWwhile ModeMsg hi def link cmakeKWwrite_file ModeMsg let b:current_syntax = "cmake" let &cpo = s:keepcpo unlet s:keepcpo "EOF" cmake-3.10.2/bootstrap000755 000766 000024 00000136251 13230131714 015435 0ustar00kitwarestaff000000 000000 #!/bin/sh # Distributed under the OSI-approved BSD 3-Clause License. See accompanying # file Copyright.txt or https://cmake.org/licensing for details. die() { echo "$@" 1>&2 ; exit 1 } # Compile flag extraction function. cmake_extract_standard_flags() { sed -n "s/ *set *( *CMAKE_${2}${3}_EXTENSION_COMPILE_OPTION *\"\{0,1\}\([^\")]*\).*/\1/p" \ "${cmake_source_dir}/Modules/Compiler/"${1:-*}-${2}.cmake 2>/dev/null | tr ';' ' ' } # Version number extraction function. cmake_version_component() { sed -n " /^set(CMake_VERSION_${1}/ {s/set(CMake_VERSION_${1} *\([0-9]*\))/\1/;p;} " "${cmake_source_dir}/Source/CMakeVersion.cmake" } # Install destination extraction function. cmake_install_dest_default() { sed -n ' /^ *set(CMAKE_'"${1}"'_DIR_DEFAULT.*) # '"${2}"'$/ { s/^ *set(CMAKE_'"${1}"'_DIR_DEFAULT *"\([^"]*\)").*$/\1/ s/${CMake_VERSION_MAJOR}/'"${cmake_version_major}"'/ s/${CMake_VERSION_MINOR}/'"${cmake_version_minor}"'/ s/${CMake_VERSION_PATCH}/'"${cmake_version_patch}"'/ p q } ' "${cmake_source_dir}/Source/CMakeInstallDestinations.cmake" } cmake_toupper() { echo "$1" | tr '[:lower:]' '[:upper:]' } # Detect system and directory information. cmake_system=`uname` cmake_source_dir=`cd "\`dirname \"$0\"\`";pwd` cmake_binary_dir=`pwd` # Load version information. cmake_version_major="`cmake_version_component MAJOR`" cmake_version_minor="`cmake_version_component MINOR`" cmake_version_patch="`cmake_version_component PATCH`" cmake_version="${cmake_version_major}.${cmake_version_minor}.${cmake_version_patch}" cmake_version_rc="`cmake_version_component RC`" if [ "$cmake_version_rc" != "" ]; then cmake_version="${cmake_version}-rc${cmake_version_rc}" fi cmake_copyright="`grep '^Copyright .* Kitware' "${cmake_source_dir}/Copyright.txt"`" cmake_bin_dir_keyword="OTHER" cmake_data_dir_keyword="OTHER" cmake_doc_dir_keyword="OTHER" cmake_man_dir_keyword="OTHER" cmake_xdgdata_dir_keyword="OTHER" cmake_bin_dir="" cmake_data_dir="" cmake_doc_dir="" cmake_man_dir="" cmake_xdgdata_dir="" cmake_init_file="" cmake_bootstrap_system_libs="" cmake_bootstrap_qt_gui="" cmake_bootstrap_qt_qmake="" cmake_sphinx_man="" cmake_sphinx_html="" cmake_sphinx_qthelp="" cmake_sphinx_build="" cmake_sphinx_flags="" # Determine whether this is a Cygwin environment. if echo "${cmake_system}" | grep CYGWIN >/dev/null 2>&1; then cmake_system_cygwin=true cmake_doc_dir_keyword="CYGWIN" cmake_man_dir_keyword="CYGWIN" else cmake_system_cygwin=false fi # Determine whether this is a MinGW environment. if echo "${cmake_system}" | grep 'MINGW\|MSYS' >/dev/null 2>&1; then cmake_system_mingw=true else cmake_system_mingw=false fi # Determine whether this is OS X if echo "${cmake_system}" | grep Darwin >/dev/null 2>&1; then cmake_system_darwin=true else cmake_system_darwin=false fi # Determine whether this is BeOS if echo "${cmake_system}" | grep BeOS >/dev/null 2>&1; then cmake_system_beos=true cmake_doc_dir_keyword="HAIKU" cmake_man_dir_keyword="HAIKU" else cmake_system_beos=false fi # Determine whether this is Haiku if echo "${cmake_system}" | grep Haiku >/dev/null 2>&1; then cmake_system_haiku=true cmake_doc_dir_keyword="HAIKU" cmake_man_dir_keyword="HAIKU" else cmake_system_haiku=false fi # Determine whether this is OpenVMS if echo "${cmake_system}" | grep OpenVMS >/dev/null 2>&1; then cmake_system_openvms=true else cmake_system_openvms=false fi # Determine whether this is HP-UX if echo "${cmake_system}" | grep HP-UX >/dev/null 2>&1; then die 'CMake no longer compiles on HP-UX. See https://gitlab.kitware.com/cmake/cmake/issues/17137 Use CMake 3.9 or lower instead.' cmake_system_hpux=true else cmake_system_hpux=false fi # Determine whether this is Linux if echo "${cmake_system}" | grep Linux >/dev/null 2>&1; then cmake_system_linux=true else cmake_system_linux=false fi # Determine whether this is a PA-RISC machine # This only works for Linux or HP-UX, not other PA-RISC OSs (BSD maybe?). Also # may falsely detect parisc on HP-UX m68k cmake_machine_parisc=false if ${cmake_system_linux}; then if uname -m | grep parisc >/dev/null 2>&1; then cmake_machine_parisc=true fi elif ${cmake_system_hpux}; then if uname -m | grep ia64 >/dev/null 2>&1; then : ; else cmake_machine_parisc=true fi fi # Choose the generator to use for bootstrapping. if ${cmake_system_mingw}; then # Bootstrapping from an MSYS prompt. cmake_bootstrap_generator="MSYS Makefiles" else # Bootstrapping from a standard UNIX prompt. cmake_bootstrap_generator="Unix Makefiles" fi # Choose tools and extensions for this platform. if ${cmake_system_openvms}; then _tmp="_tmp" _cmk="_cmk" _diff=`which diff` else _tmp=".tmp" _cmk=".cmk" _diff="diff" fi # Construct bootstrap directory name. cmake_bootstrap_dir="${cmake_binary_dir}/Bootstrap${_cmk}" # Helper function to fix windows paths. case "${cmake_system}" in *MINGW*) cmake_fix_slashes() { cmd //c echo "$(echo "$1" | sed 's/\\/\//g')" | sed 's/^"//;s/" *$//' } ;; *) cmake_fix_slashes() { echo "$1" | sed 's/\\/\//g' } ;; esac # Choose the default install prefix. if ${cmake_system_mingw}; then if [ "x${PROGRAMFILES}" != "x" ]; then cmake_default_prefix=`cmake_fix_slashes "${PROGRAMFILES}/CMake"` elif [ "x${ProgramFiles}" != "x" ]; then cmake_default_prefix=`cmake_fix_slashes "${ProgramFiles}/CMake"` elif [ "x${SYSTEMDRIVE}" != "x" ]; then cmake_default_prefix=`cmake_fix_slashes "${SYSTEMDRIVE}/Program Files/CMake"` elif [ "x${SystemDrive}" != "x" ]; then cmake_default_prefix=`cmake_fix_slashes "${SystemDrive}/Program Files/CMake"` else cmake_default_prefix="c:/Program Files/CMake" fi elif ${cmake_system_haiku}; then cmake_default_prefix=`finddir B_COMMON_DIRECTORY` else cmake_default_prefix="/usr/local" fi # Lookup default install destinations. cmake_bin_dir_default="`cmake_install_dest_default BIN ${cmake_bin_dir_keyword}`" cmake_data_dir_default="`cmake_install_dest_default DATA ${cmake_data_dir_keyword}`" cmake_doc_dir_default="`cmake_install_dest_default DOC ${cmake_doc_dir_keyword}`" cmake_man_dir_default="`cmake_install_dest_default MAN ${cmake_man_dir_keyword}`" cmake_xdgdata_dir_default="`cmake_install_dest_default XDGDATA ${cmake_xdgdata_dir_keyword}`" CMAKE_KNOWN_C_COMPILERS="cc gcc xlc icc tcc" CMAKE_KNOWN_CXX_COMPILERS="aCC xlC CC g++ c++ icc como " CMAKE_KNOWN_MAKE_PROCESSORS="gmake make" CMAKE_PROBLEMATIC_FILES="\ CMakeCache.txt \ CMakeSystem.cmake \ CMakeCCompiler.cmake \ CMakeCXXCompiler.cmake \ */CMakeSystem.cmake \ */CMakeCCompiler.cmake \ */CMakeCXXCompiler.cmake \ Source/cmConfigure.h \ Source/CTest/Curl/config.h \ Utilities/cmexpat/expatConfig.h \ Utilities/cmexpat/expatDllConfig.h \ " CMAKE_UNUSED_SOURCES="\ cmGlobalXCodeGenerator \ cmLocalXCodeGenerator \ cmXCodeObject \ cmXCode21Object \ cmSourceGroup \ " CMAKE_CXX_SOURCES="\ cmAddCustomCommandCommand \ cmAddCustomTargetCommand \ cmAddDefinitionsCommand \ cmAddDependenciesCommand \ cmAddExecutableCommand \ cmAddLibraryCommand \ cmAddSubDirectoryCommand \ cmAddTestCommand \ cmBreakCommand \ cmBuildCommand \ cmCMakeMinimumRequired \ cmCMakePolicyCommand \ cmCPackPropertiesGenerator \ cmCacheManager \ cmCommand \ cmCommandArgumentParserHelper \ cmCommandArgumentsHelper \ cmCommands \ cmCommonTargetGenerator \ cmComputeComponentGraph \ cmComputeLinkDepends \ cmComputeLinkInformation \ cmComputeTargetDepends \ cmConditionEvaluator \ cmConfigureFileCommand \ cmContinueCommand \ cmCoreTryCompile \ cmCreateTestSourceList \ cmCustomCommand \ cmCustomCommandGenerator \ cmDefinePropertyCommand \ cmDefinitions \ cmDepends \ cmDependsC \ cmDisallowedCommand \ cmDocumentationFormatter \ cmEnableLanguageCommand \ cmEnableTestingCommand \ cmExecProgramCommand \ cmExecuteProcessCommand \ cmExpandedCommandArgument \ cmExportBuildFileGenerator \ cmExportFileGenerator \ cmExportInstallFileGenerator \ cmExportSet \ cmExportSetMap \ cmExportTryCompileFileGenerator \ cmExprParserHelper \ cmExternalMakefileProjectGenerator \ cmFileCommand \ cmFileTimeComparison \ cmFindBase \ cmFindCommon \ cmFindFileCommand \ cmFindLibraryCommand \ cmFindPackageCommand \ cmFindPathCommand \ cmFindProgramCommand \ cmForEachCommand \ cmFunctionCommand \ cmGeneratedFileStream \ cmGeneratorExpression \ cmGeneratorExpressionContext \ cmGeneratorExpressionDAGChecker \ cmGeneratorExpressionEvaluationFile \ cmGeneratorExpressionEvaluator \ cmGeneratorExpressionLexer \ cmGeneratorExpressionNode \ cmGeneratorExpressionParser \ cmGeneratorTarget \ cmGetCMakePropertyCommand \ cmGetDirectoryPropertyCommand \ cmGetFilenameComponentCommand \ cmGetPropertyCommand \ cmGetSourceFilePropertyCommand \ cmGetTargetPropertyCommand \ cmGetTestPropertyCommand \ cmGlobalCommonGenerator \ cmGlobalGenerator \ cmGlobalUnixMakefileGenerator3 \ cmHexFileConverter \ cmIfCommand \ cmIncludeCommand \ cmIncludeGuardCommand \ cmIncludeDirectoryCommand \ cmIncludeRegularExpressionCommand \ cmInstallCommand \ cmInstallCommandArguments \ cmInstallDirectoryGenerator \ cmInstallExportGenerator \ cmInstallFilesCommand \ cmInstallFilesGenerator \ cmInstallGenerator \ cmInstallScriptGenerator \ cmInstallTargetGenerator \ cmInstallTargetsCommand \ cmInstalledFile \ cmLinkDirectoriesCommand \ cmLinkLineComputer \ cmListCommand \ cmListFileCache \ cmLocalCommonGenerator \ cmLocalGenerator \ cmLocalUnixMakefileGenerator3 \ cmMSVC60LinkLineComputer \ cmMacroCommand \ cmMakeDirectoryCommand \ cmMakefile \ cmMakefileExecutableTargetGenerator \ cmMakefileLibraryTargetGenerator \ cmMakefileTargetGenerator \ cmMakefileUtilityTargetGenerator \ cmMarkAsAdvancedCommand \ cmMathCommand \ cmMessageCommand \ cmMessenger \ cmNewLineStyle \ cmOSXBundleGenerator \ cmOptionCommand \ cmOrderDirectories \ cmOutputConverter \ cmParseArgumentsCommand \ cmPathLabel \ cmPolicies \ cmProcessOutput \ cmProjectCommand \ cmProperty \ cmPropertyDefinition \ cmPropertyDefinitionMap \ cmPropertyMap \ cmReturnCommand \ cmRulePlaceholderExpander \ cmScriptGenerator \ cmSearchPath \ cmSeparateArgumentsCommand \ cmSetCommand \ cmSetDirectoryPropertiesCommand \ cmSetPropertyCommand \ cmSetSourceFilesPropertiesCommand \ cmSetTargetPropertiesCommand \ cmSetTestsPropertiesCommand \ cmSiteNameCommand \ cmSourceFile \ cmSourceFileLocation \ cmState \ cmStateDirectory \ cmStateSnapshot \ cmStringCommand \ cmSubdirCommand \ cmSystemTools \ cmTarget \ cmTargetCompileDefinitionsCommand \ cmTargetCompileFeaturesCommand \ cmTargetCompileOptionsCommand \ cmTargetIncludeDirectoriesCommand \ cmTargetLinkLibrariesCommand \ cmTargetPropCommandBase \ cmTargetPropertyComputer \ cmTargetSourcesCommand \ cmTest \ cmTestGenerator \ cmTimestamp \ cmTryCompileCommand \ cmTryRunCommand \ cmUnexpectedCommand \ cmUnsetCommand \ cmVersion \ cmWhileCommand \ cmWorkingDirectory \ cmake \ cmakemain \ cmcmd \ " if ${cmake_system_mingw}; then CMAKE_CXX_SOURCES="${CMAKE_CXX_SOURCES}\ cmGlobalMSYSMakefileGenerator \ cmGlobalMinGWMakefileGenerator" fi LexerParser_CXX_SOURCES="\ cmCommandArgumentLexer \ cmCommandArgumentParser \ cmExprLexer \ cmExprParser \ " LexerParser_C_SOURCES="\ cmListFileLexer \ " if ${cmake_system_mingw}; then KWSYS_C_SOURCES="\ EncodingC \ ProcessWin32 \ String \ System \ Terminal" else KWSYS_C_SOURCES="\ EncodingC \ ProcessUNIX \ String \ System \ Terminal" fi KWSYS_CXX_SOURCES="\ Directory \ EncodingCXX \ FStream \ Glob \ RegularExpression \ SystemTools" KWSYS_FILES="\ Directory.hxx \ Encoding.h \ Encoding.hxx \ FStream.hxx \ Glob.hxx \ Process.h \ RegularExpression.hxx \ String.h \ String.hxx \ System.h \ SystemTools.hxx \ Terminal.h" if ${cmake_system_mingw}; then LIBUV_C_SOURCES="\ src/fs-poll.c \ src/inet.c \ src/threadpool.c \ src/uv-common.c \ src/win/async.c \ src/win/core.c \ src/win/detect-wakeup.c \ src/win/dl.c \ src/win/error.c \ src/win/fs-event.c \ src/win/fs.c \ src/win/getaddrinfo.c \ src/win/getnameinfo.c \ src/win/handle.c \ src/win/loop-watcher.c \ src/win/pipe.c \ src/win/poll.c \ src/win/process-stdio.c \ src/win/process.c \ src/win/req.c \ src/win/signal.c \ src/win/stream.c \ src/win/tcp.c \ src/win/thread.c \ src/win/timer.c \ src/win/tty.c \ src/win/udp.c \ src/win/util.c \ src/win/winapi.c \ src/win/winsock.c \ " else LIBUV_C_SOURCES="\ src/uv-common.c \ src/unix/cmake-bootstrap.c \ src/unix/core.c \ src/unix/fs.c \ src/unix/loop.c \ src/unix/loop-watcher.c \ src/unix/no-fsevents.c \ src/unix/pipe.c \ src/unix/poll.c \ src/unix/posix-hrtime.c \ src/unix/posix-poll.c \ src/unix/process.c \ src/unix/signal.c \ src/unix/stream.c \ src/unix/timer.c \ " fi # Display CMake bootstrap usage cmake_usage() { echo ' Usage: '"$0"' [...] [-- ...] Options: [defaults in brackets after descriptions] Configuration: --help print this message --version only print version information --verbose display more information --parallel=n bootstrap cmake in parallel, where n is number of nodes [1] --enable-ccache Enable ccache when building cmake --init=FILE load FILE as script to populate cache --system-libs use all system-installed third-party libraries (for use only by package maintainers) --no-system-libs use all cmake-provided third-party libraries (default) --system-curl use system-installed curl library --no-system-curl use cmake-provided curl library (default) --system-expat use system-installed expat library --no-system-expat use cmake-provided expat library (default) --system-jsoncpp use system-installed jsoncpp library --no-system-jsoncpp use cmake-provided jsoncpp library (default) --system-zlib use system-installed zlib library --no-system-zlib use cmake-provided zlib library (default) --system-bzip2 use system-installed bzip2 library --no-system-bzip2 use cmake-provided bzip2 library (default) --system-liblzma use system-installed liblzma library --no-system-liblzma use cmake-provided liblzma library (default) --system-libarchive use system-installed libarchive library --no-system-libarchive use cmake-provided libarchive library (default) --system-librhash use system-installed librhash library --no-system-librhash use cmake-provided librhash library (default) --qt-gui build the Qt-based GUI (requires Qt >= 4.2) --no-qt-gui do not build the Qt-based GUI (default) --qt-qmake= use as the qmake executable to find Qt --sphinx-man build man pages with Sphinx --sphinx-html build html help with Sphinx --sphinx-qthelp build qch help with Sphinx --sphinx-build= use as the sphinx-build executable --sphinx-flags= pass to sphinx-build executable Directory and file names: --prefix=PREFIX install files in tree rooted at PREFIX ['"${cmake_default_prefix}"'] --bindir=DIR install binaries in PREFIX/DIR ['"${cmake_bin_dir_default}"'] --datadir=DIR install data files in PREFIX/DIR ['"${cmake_data_dir_default}"'] --docdir=DIR install documentation files in PREFIX/DIR ['"${cmake_doc_dir_default}"'] --mandir=DIR install man pages files in PREFIX/DIR/manN ['"${cmake_man_dir_default}"'] --xdgdatadir=DIR install XDG specific files in PREFIX/DIR ['"${cmake_xdgdata_dir_default}"'] ' exit 10 } # Display CMake bootstrap usage cmake_version_display() { echo "CMake ${cmake_version}, ${cmake_copyright}" } # Display CMake bootstrap error, display the log file and exit cmake_error() { res=$1 shift 1 echo "---------------------------------------------" echo "Error when bootstrapping CMake:" echo "$*" echo "---------------------------------------------" if [ -f cmake_bootstrap.log ]; then echo "Log of errors: `pwd`/cmake_bootstrap.log" #cat cmake_bootstrap.log echo "---------------------------------------------" fi exit ${res} } cmake_generate_file () { OUTFILE="$1" CONTENT="$2" echo "$CONTENT" > "$OUTFILE.tmp" if "${_diff}" "$OUTFILE.tmp" "$OUTFILE" > /dev/null 2> /dev/null ; then rm -f "$OUTFILE.tmp" else mv -f "$OUTFILE.tmp" "$OUTFILE" fi } # Replace KWSYS_NAMESPACE with cmsys cmake_replace_string () { INFILE="$1" OUTFILE="$2" SEARCHFOR="$3" REPLACEWITH="$4" if [ -f "${INFILE}" ] || ${cmake_system_openvms}; then sed "s/\@${SEARCHFOR}\@/${REPLACEWITH}/g" "${INFILE}" > "${OUTFILE}${_tmp}" if [ -f "${OUTFILE}${_tmp}" ]; then if "${_diff}" "${OUTFILE}" "${OUTFILE}${_tmp}" > /dev/null 2> /dev/null ; then #echo "Files are the same" rm -f "${OUTFILE}${_tmp}" else mv -f "${OUTFILE}${_tmp}" "${OUTFILE}" fi fi else cmake_error 1 "Cannot find file ${INFILE}" fi } cmake_kwsys_config_replace_string () { INFILE="$1" OUTFILE="$2" shift 2 APPEND="$*" if [ -f "${INFILE}" ] || ${cmake_system_openvms}; then echo "${APPEND}" > "${OUTFILE}${_tmp}" sed "/./ {s/\@KWSYS_NAMESPACE\@/cmsys/g; s/@KWSYS_BUILD_SHARED@/${KWSYS_BUILD_SHARED}/g; s/@KWSYS_LFS_AVAILABLE@/${KWSYS_LFS_AVAILABLE}/g; s/@KWSYS_LFS_REQUESTED@/${KWSYS_LFS_REQUESTED}/g; s/@KWSYS_NAME_IS_KWSYS@/${KWSYS_NAME_IS_KWSYS}/g; s/@KWSYS_STL_HAS_WSTRING@/${KWSYS_STL_HAS_WSTRING}/g; s/@KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H@/${KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H}/g; }" "${INFILE}" >> "${OUTFILE}${_tmp}" if [ -f "${OUTFILE}${_tmp}" ]; then if "${_diff}" "${OUTFILE}" "${OUTFILE}${_tmp}" > /dev/null 2> /dev/null ; then #echo "Files are the same" rm -f "${OUTFILE}${_tmp}" else mv -f "${OUTFILE}${_tmp}" "${OUTFILE}" fi fi else cmake_error 2 "Cannot find file ${INFILE}" fi } # Write string into a file cmake_report () { FILE=$1 shift echo "$*" >> ${FILE} } # Escape spaces in strings cmake_escape () { echo $1 | sed "s/ /\\\\ /g" } # Encode object file names. cmake_obj () { echo $1 | sed 's/\//-/g' | sed 's/$/\.o/' } # Strip prefix from argument cmake_arg () { echo "$1" | sed "s/^${2-[^=]*=}//" } # Write message to the log cmake_log () { echo "$*" >> cmake_bootstrap.log } # Return temp file cmake_tmp_file () { echo "cmake_bootstrap_$$_test" } # Run a compiler test. First argument is compiler, second one are compiler # flags, third one is test source file to be compiled cmake_try_run () { COMPILER=$1 FLAGS=$2 TESTFILE=$3 if [ ! -f "${TESTFILE}" ]; then echo "Test file ${TESTFILE} missing. Please verify your CMake source tree." exit 4 fi TMPFILE=`cmake_tmp_file` echo "Try: ${COMPILER}" echo "Line: ${COMPILER} ${FLAGS} ${TESTFILE} -o ${TMPFILE}" echo "---------- file -----------------------" cat "${TESTFILE}" echo "------------------------------------------" "${COMPILER}" ${FLAGS} "${TESTFILE}" -o "${TMPFILE}" RES=$? if [ "${RES}" -ne "0" ]; then echo "Test failed to compile" return 1 fi if [ ! -f "${TMPFILE}" ] && [ ! -f "${TMPFILE}.exe" ]; then echo "Test failed to produce executable" return 2 fi ./${TMPFILE} RES=$? rm -f "${TMPFILE}" if [ "${RES}" -ne "0" ]; then echo "Test produced non-zero return code" return 3 fi echo "Test succeeded" return 0 } # Run a make test. First argument is the make interpreter. cmake_try_make () { MAKE_PROC="$1" MAKE_FLAGS="$2" echo "Try: ${MAKE_PROC}" "${MAKE_PROC}" ${MAKE_FLAGS} RES=$? if [ "${RES}" -ne "0" ]; then echo "${MAKE_PROC} does not work" return 1 fi if [ ! -f "test" ] && [ ! -f "test.exe" ]; then echo "${COMPILER} does not produce output" return 2 fi ./test RES=$? rm -f "test" if [ "${RES}" -ne "0" ]; then echo "${MAKE_PROC} produces strange executable" return 3 fi echo "${MAKE_PROC} works" return 0 } # Parse arguments cmake_verbose= cmake_parallel_make= cmake_ccache_enabled= cmake_prefix_dir="${cmake_default_prefix}" while test $# != 0; do case "$1" in --prefix=*) dir=`cmake_arg "$1"` cmake_prefix_dir=`cmake_fix_slashes "$dir"` ;; --parallel=*) cmake_parallel_make=`cmake_arg "$1"` ;; --bindir=*) cmake_bin_dir=`cmake_arg "$1"` ;; --datadir=*) cmake_data_dir=`cmake_arg "$1"` ;; --docdir=*) cmake_doc_dir=`cmake_arg "$1"` ;; --mandir=*) cmake_man_dir=`cmake_arg "$1"` ;; --xdgdatadir=*) cmake_xdgdata_dir=`cmake_arg "$1"` ;; --init=*) cmake_init_file=`cmake_arg "$1"` ;; --system-libs) cmake_bootstrap_system_libs="${cmake_bootstrap_system_libs} -DCMAKE_USE_SYSTEM_LIBRARIES=1" ;; --no-system-libs) cmake_bootstrap_system_libs="${cmake_bootstrap_system_libs} -DCMAKE_USE_SYSTEM_LIBRARIES=0" ;; --system-bzip2|--system-curl|--system-expat|--system-jsoncpp|--system-libarchive|--system-librhash|--system-zlib|--system-liblzma) lib=`cmake_arg "$1" "--system-"` cmake_bootstrap_system_libs="${cmake_bootstrap_system_libs} -DCMAKE_USE_SYSTEM_LIBRARY_`cmake_toupper $lib`=1" ;; --no-system-bzip2|--no-system-curl|--no-system-expat|--no-system-jsoncpp|--no-system-libarchive|--no-system-librhash|--no-system-zlib|--no-system-liblzma) lib=`cmake_arg "$1" "--no-system-"` cmake_bootstrap_system_libs="${cmake_bootstrap_system_libs} -DCMAKE_USE_SYSTEM_LIBRARY_`cmake_toupper $lib`=0" ;; --qt-gui) cmake_bootstrap_qt_gui="1" ;; --no-qt-gui) cmake_bootstrap_qt_gui="0" ;; --qt-qmake=*) cmake_bootstrap_qt_qmake=`cmake_arg "$1"` ;; --sphinx-man) cmake_sphinx_man="1" ;; --sphinx-html) cmake_sphinx_html="1" ;; --sphinx-qthelp) cmake_sphinx_qthelp="1" ;; --sphinx-build=*) cmake_sphinx_build=`cmake_arg "$1"` ;; --sphinx-flags=*) cmake_sphinx_flags=`cmake_arg "$1"` ;; --help) cmake_usage ;; --version) cmake_version_display ; exit 2 ;; --verbose) cmake_verbose=TRUE ;; --enable-ccache) cmake_ccache_enabled=TRUE ;; --) shift; break ;; *) die "Unknown option: $1" ;; esac shift done # If verbose, display some information about bootstrap if [ -n "${cmake_verbose}" ]; then echo "---------------------------------------------" echo "Source directory: ${cmake_source_dir}" echo "Binary directory: ${cmake_binary_dir}" echo "Prefix directory: ${cmake_prefix_dir}" echo "System: ${cmake_system}" if [ "x${cmake_parallel_make}" != "x" ]; then echo "Doing parallel make: ${cmake_parallel_make}" fi echo "" fi echo "---------------------------------------------" # Get CMake version echo "`cmake_version_display`" # Check for in-source build cmake_in_source_build= if [ -f "${cmake_binary_dir}/Source/cmake.cxx" -a \ -f "${cmake_binary_dir}/Source/cmake.h" ]; then if [ -n "${cmake_verbose}" ]; then echo "Warning: This is an in-source build" fi cmake_in_source_build=TRUE fi # If this is not an in-source build, then Bootstrap stuff should not exist. if [ -z "${cmake_in_source_build}" ]; then # Did somebody bootstrap in the source tree? if [ -d "${cmake_source_dir}/Bootstrap${_cmk}" ]; then cmake_error 10 "Found directory \"${cmake_source_dir}/Bootstrap${_cmk}\". Looks like somebody did bootstrap CMake in the source tree, but now you are trying to do bootstrap in the binary tree. Please remove Bootstrap${_cmk} directory from the source tree." fi # Is there a cache in the source tree? for cmake_problematic_file in ${CMAKE_PROBLEMATIC_FILES}; do if [ -f "${cmake_source_dir}/${cmake_problematic_file}" ]; then cmake_error 10 "Found \"${cmake_source_dir}/${cmake_problematic_file}\". Looks like somebody tried to build CMake in the source tree, but now you are trying to do bootstrap in the binary tree. Please remove \"${cmake_problematic_file}\" from the source tree." fi done fi # Make bootstrap directory [ -d "${cmake_bootstrap_dir}" ] || mkdir "${cmake_bootstrap_dir}" if [ ! -d "${cmake_bootstrap_dir}" ]; then cmake_error 3 "Cannot create directory ${cmake_bootstrap_dir} to bootstrap CMake." fi cd "${cmake_bootstrap_dir}" [ -d "cmsys" ] || mkdir "cmsys" if [ ! -d "cmsys" ]; then cmake_error 4 "Cannot create directory ${cmake_bootstrap_dir}/cmsys" fi # Delete all the bootstrap files rm -f "${cmake_bootstrap_dir}/cmake_bootstrap.log" rm -f "${cmake_bootstrap_dir}/cmConfigure.h${_tmp}" rm -f "${cmake_bootstrap_dir}/cmVersionConfig.h${_tmp}" # If building in-source, remove any cmConfigure.h that may # have been created by a previous run of the bootstrap cmake. if [ -n "${cmake_in_source_build}" ]; then rm -f "${cmake_source_dir}/Source/cmConfigure.h" fi # If exist compiler flags, set them cmake_c_flags=${CFLAGS} cmake_cxx_flags=${CXXFLAGS} cmake_ld_flags=${LDFLAGS} # Add Cygwin-specific flags if ${cmake_system_cygwin}; then cmake_ld_flags="${LDFLAGS} -Wl,--enable-auto-import" fi # Add CoreFoundation framework on Darwin if ${cmake_system_darwin}; then cmake_ld_flags="${LDFLAGS} -framework CoreFoundation" fi # Add BeOS toolkits... if ${cmake_system_beos}; then cmake_ld_flags="${LDFLAGS} -lroot -lbe" fi # Add Haiku toolkits... if ${cmake_system_haiku}; then cmake_ld_flags="${LDFLAGS} -lroot -lbe" fi #----------------------------------------------------------------------------- # Detect known toolchains on some platforms. cmake_toolchains='' case "${cmake_system}" in *AIX*) cmake_toolchains='XL GNU' ;; *CYGWIN*) cmake_toolchains='GNU' ;; *Darwin*) cmake_toolchains='Clang GNU' ;; *Linux*) cmake_toolchains='GNU Clang XL PGI PathScale' ;; *MINGW*) cmake_toolchains='GNU' ;; esac # Toolchain compiler name table. cmake_toolchain_Clang_CC='clang' cmake_toolchain_Clang_CXX='clang++' cmake_toolchain_GNU_CC='gcc' cmake_toolchain_GNU_CXX='g++' cmake_toolchain_PGI_CC='pgcc' cmake_toolchain_PGI_CXX='pgCC' cmake_toolchain_PathScale_CC='pathcc' cmake_toolchain_PathScale_CXX='pathCC' cmake_toolchain_XL_CC='xlc' cmake_toolchain_XL_CXX='xlC' cmake_toolchain_try() { tc="$1" TMPFILE=`cmake_tmp_file` eval "tc_CC=\${cmake_toolchain_${tc}_CC}" echo 'int main() { return 0; }' > "${TMPFILE}.c" cmake_try_run "$tc_CC" "" "${TMPFILE}.c" >> cmake_bootstrap.log 2>&1 tc_result_CC="$?" rm -f "${TMPFILE}.c" test "${tc_result_CC}" = "0" || return 1 eval "tc_CXX=\${cmake_toolchain_${tc}_CXX}" echo 'int main() { return 0; }' > "${TMPFILE}.cpp" cmake_try_run "$tc_CXX" "" "${TMPFILE}.cpp" >> cmake_bootstrap.log 2>&1 tc_result_CXX="$?" rm -f "${TMPFILE}.cpp" test "${tc_result_CXX}" = "0" || return 1 cmake_toolchain="$tc" } cmake_toolchain_detect() { cmake_toolchain= for tc in ${cmake_toolchains}; do echo "Checking for $tc toolchain" >> cmake_bootstrap.log 2>&1 cmake_toolchain_try "$tc" && echo "Found $tc toolchain" && break done } if [ -z "${CC}" -a -z "${CXX}" ]; then cmake_toolchain_detect fi #----------------------------------------------------------------------------- # Test C compiler cmake_c_compiler= # If CC is set, use that for compiler, otherwise use list of known compilers if [ -n "${cmake_toolchain}" ]; then eval cmake_c_compilers="\${cmake_toolchain_${cmake_toolchain}_CC}" elif [ -n "${CC}" ]; then cmake_c_compilers="${CC}" else cmake_c_compilers="${CMAKE_KNOWN_C_COMPILERS}" fi # Check if C compiler works TMPFILE=`cmake_tmp_file` echo ' #ifdef __cplusplus # error "The CMAKE_C_COMPILER is set to a C++ compiler" #endif #if defined(__sun) && __STDC_VERSION__ < 199901L #error "On Solaris we need C99." #endif #include int main(int argc, char* argv[]) { printf("%d%c", (argv != 0), (char)0x0a); return argc - 1; } ' > "${TMPFILE}.c" for std in 11 99 90; do try_flags="`cmake_extract_standard_flags \"${cmake_toolchain}\" C \"${std}\"`" for compiler in ${cmake_c_compilers}; do for flag in '' $try_flags; do echo "Checking whether '${compiler} ${cmake_c_flags} ${flag}' works." >> cmake_bootstrap.log 2>&1 if cmake_try_run "${compiler}" "${cmake_c_flags} ${flag}" \ "${TMPFILE}.c" >> cmake_bootstrap.log 2>&1; then cmake_c_compiler="${compiler}" cmake_c_flags="${cmake_c_flags} ${flag}" break 3 fi done done done rm -f "${TMPFILE}.c" if [ -z "${cmake_c_compiler}" ]; then cmake_error 6 "Cannot find appropriate C compiler on this system. Please specify one using environment variable CC. See cmake_bootstrap.log for compilers attempted. " fi echo "C compiler on this system is: ${cmake_c_compiler} ${cmake_c_flags}" #----------------------------------------------------------------------------- # Test CXX compiler cmake_cxx_compiler= # On Mac OSX, CC is the same as cc, so make sure not to try CC as c++ compiler. # If CC is set, use that for compiler, otherwise use list of known compilers if [ -n "${cmake_toolchain}" ]; then eval cmake_cxx_compilers="\${cmake_toolchain_${cmake_toolchain}_CXX}" elif [ -n "${CXX}" ]; then cmake_cxx_compilers="${CXX}" else cmake_cxx_compilers="${CMAKE_KNOWN_CXX_COMPILERS}" fi # Check if C++ compiler works TMPFILE=`cmake_tmp_file` echo ' #include #include #include #if __cplusplus < 201103L #error "Compiler is not in a mode aware of C++11." #endif #if defined(__SUNPRO_CC) && __SUNPRO_CC < 0x5140 #error "SunPro <= 5.13 mode not supported due to bug in move semantics." #endif class Class { public: int Get() const { return this->Member; } private: int Member = 1; }; int main() { auto const c = std::unique_ptr(new Class); std::cout << c->Get() << std::endl; return 0; } ' > "${TMPFILE}.cxx" for std in 17 14 11; do try_flags="`cmake_extract_standard_flags \"${cmake_toolchain}\" CXX \"${std}\"`" for compiler in ${cmake_cxx_compilers}; do for flag in '' $try_flags; do echo "Checking whether '${compiler} ${cmake_cxx_flags} ${flag}' works." >> cmake_bootstrap.log 2>&1 if cmake_try_run "${compiler}" "${cmake_cxx_flags} ${flag}" \ "${TMPFILE}.cxx" >> cmake_bootstrap.log 2>&1; then cmake_cxx_compiler="${compiler}" cmake_cxx_flags="${cmake_cxx_flags} ${flag} " break 3 fi done done done rm -f "${TMPFILE}.cxx" if [ -z "${cmake_cxx_compiler}" ]; then cmake_error 7 "Cannot find a C++ compiler supporting C++11 on this system. Please specify one using environment variable CXX. See cmake_bootstrap.log for compilers attempted." fi echo "C++ compiler on this system is: ${cmake_cxx_compiler} ${cmake_cxx_flags}" #----------------------------------------------------------------------------- # Test Make cmake_make_processor= cmake_make_flags= # If MAKE is set, use that for make processor, otherwise use list of known make if [ -n "${MAKE}" ]; then cmake_make_processors="${MAKE}" else cmake_make_processors="${CMAKE_KNOWN_MAKE_PROCESSORS}" fi TMPFILE="`cmake_tmp_file`_dir" rm -rf "${cmake_bootstrap_dir}/${TMPFILE}" mkdir "${cmake_bootstrap_dir}/${TMPFILE}" cd "${cmake_bootstrap_dir}/${TMPFILE}" echo ' test: test.c "'"${cmake_c_compiler}"'" '"${cmake_ld_flags} ${cmake_c_flags}"' -o test test.c '>"Makefile" echo ' #include int main(){ printf("1%c", (char)0x0a); return 0; } ' > "test.c" cmake_original_make_flags="${cmake_make_flags}" if [ "x${cmake_parallel_make}" != "x" ]; then cmake_make_flags="${cmake_make_flags} -j ${cmake_parallel_make}" fi for a in ${cmake_make_processors}; do if [ -z "${cmake_make_processor}" ] && cmake_try_make "${a}" "${cmake_make_flags}" >> ../cmake_bootstrap.log 2>&1; then cmake_make_processor="${a}" fi done cmake_full_make_flags="${cmake_make_flags}" if [ "x${cmake_original_make_flags}" != "x${cmake_make_flags}" ]; then if [ -z "${cmake_make_processor}" ]; then cmake_make_flags="${cmake_original_make_flags}" for a in ${cmake_make_processors}; do if [ -z "${cmake_make_processor}" ] && cmake_try_make "${a}" "${cmake_make_flags}" >> ../cmake_bootstrap.log 2>&1; then cmake_make_processor="${a}" fi done fi fi cd "${cmake_bootstrap_dir}" if [ -z "${cmake_make_processor}" ]; then cmake_error 8 "Cannot find appropriate Makefile processor on this system. Please specify one using environment variable MAKE." fi rm -rf "${cmake_bootstrap_dir}/${TMPFILE}" echo "Makefile processor on this system is: ${cmake_make_processor}" if [ "x${cmake_full_make_flags}" != "x${cmake_make_flags}" ]; then echo "---------------------------------------------" echo "Makefile processor ${cmake_make_processor} does not support parallel build" echo "---------------------------------------------" fi # Test for kwsys features KWSYS_NAME_IS_KWSYS=0 KWSYS_BUILD_SHARED=0 KWSYS_LFS_AVAILABLE=0 KWSYS_LFS_REQUESTED=0 KWSYS_STL_HAS_WSTRING=0 KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H=0 KWSYS_CXX_HAS_SETENV=0 KWSYS_CXX_HAS_UNSETENV=0 KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H=0 KWSYS_CXX_HAS_UTIMENSAT=0 KWSYS_CXX_HAS_UTIMES=0 if cmake_try_run "${cmake_cxx_compiler}" \ "${cmake_cxx_flags} -DTEST_KWSYS_CXX_HAS_SETENV" \ "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then KWSYS_CXX_HAS_SETENV=1 echo "${cmake_cxx_compiler} has setenv" else echo "${cmake_cxx_compiler} does not have setenv" fi if cmake_try_run "${cmake_cxx_compiler}" \ "${cmake_cxx_flags} -DTEST_KWSYS_CXX_HAS_UNSETENV" \ "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then KWSYS_CXX_HAS_UNSETENV=1 echo "${cmake_cxx_compiler} has unsetenv" else echo "${cmake_cxx_compiler} does not have unsetenv" fi if cmake_try_run "${cmake_cxx_compiler}" \ "${cmake_cxx_flags} -DTEST_KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H" \ "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H=1 echo "${cmake_cxx_compiler} has environ in stdlib.h" else echo "${cmake_cxx_compiler} does not have environ in stdlib.h" fi if cmake_try_run "${cmake_cxx_compiler}" \ "${cmake_cxx_flags} -DTEST_KWSYS_STL_HAS_WSTRING" \ "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then KWSYS_STL_HAS_WSTRING=1 echo "${cmake_cxx_compiler} has stl wstring" else echo "${cmake_cxx_compiler} does not have stl wstring" fi if cmake_try_run "${cmake_cxx_compiler}" \ "${cmake_cxx_flags} -DTEST_KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H" \ "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H=1 echo "${cmake_cxx_compiler} has " else echo "${cmake_cxx_compiler} does not have " fi # Just to be safe, let us store compiler and flags to the header file cmake_bootstrap_version='$Revision$' cmake_compiler_settings_comment="/* * Generated by ${cmake_source_dir}/bootstrap * Version: ${cmake_bootstrap_version} * * Source directory: ${cmake_source_dir} * Binary directory: ${cmake_bootstrap_dir} * * C compiler: ${cmake_c_compiler} * C flags: ${cmake_c_flags} * * C++ compiler: ${cmake_cxx_compiler} * C++ flags: ${cmake_cxx_flags} * * Make: ${cmake_make_processor} * * Sources: * ${CMAKE_CXX_SOURCES} ${CMAKE_C_SOURCES} * LexerParser Sources: * ${LexerParser_CXX_SOURCES} ${LexerParser_C_SOURCES} * kwSys Sources: * ${KWSYS_CXX_SOURCES} ${KWSYS_C_SOURCES} * libuv Sources: * ${LIBUV_C_SOURCES} */ " cmake_report cmConfigure.h${_tmp} "${cmake_compiler_settings_comment}" # When bootstrapping on MinGW with MSYS we must convert the source # directory to a windows path. if ${cmake_system_mingw}; then CMAKE_BOOTSTRAP_SOURCE_DIR=`cd "${cmake_source_dir}"; pwd -W` CMAKE_BOOTSTRAP_BINARY_DIR=`cd "${cmake_binary_dir}"; pwd -W` else CMAKE_BOOTSTRAP_SOURCE_DIR="${cmake_source_dir}" CMAKE_BOOTSTRAP_BINARY_DIR="${cmake_binary_dir}" fi # Write CMake version cmake_report cmVersionConfig.h${_tmp} "#define CMake_VERSION_MAJOR ${cmake_version_major}" cmake_report cmVersionConfig.h${_tmp} "#define CMake_VERSION_MINOR ${cmake_version_minor}" cmake_report cmVersionConfig.h${_tmp} "#define CMake_VERSION_PATCH ${cmake_version_patch}" cmake_report cmVersionConfig.h${_tmp} "#define CMake_VERSION \"${cmake_version}\"" cmake_report cmConfigure.h${_tmp} "#define CMAKE_BOOTSTRAP_SOURCE_DIR \"${CMAKE_BOOTSTRAP_SOURCE_DIR}\"" cmake_report cmConfigure.h${_tmp} "#define CMAKE_BOOTSTRAP_BINARY_DIR \"${CMAKE_BOOTSTRAP_BINARY_DIR}\"" cmake_report cmConfigure.h${_tmp} "#define CMAKE_BIN_DIR \"/bootstrap-not-insalled\"" cmake_report cmConfigure.h${_tmp} "#define CMAKE_DATA_DIR \"/bootstrap-not-insalled\"" cmake_report cmConfigure.h${_tmp} "#define CMAKE_BOOTSTRAP" cmake_report cmConfigure.h${_tmp} "#define CM_FALLTHROUGH" cmake_report cmConfigure.h${_tmp} "#define CM_DISABLE_COPY(Class)" # Regenerate configured headers for h in Configure VersionConfig; do if "${_diff}" cm${h}.h cm${h}.h${_tmp} > /dev/null 2> /dev/null; then rm -f cm${h}.h${_tmp} else mv -f cm${h}.h${_tmp} cm${h}.h fi done # Prepare KWSYS cmake_kwsys_config_replace_string \ "${cmake_source_dir}/Source/kwsys/Configure.hxx.in" \ "${cmake_bootstrap_dir}/cmsys/Configure.hxx" \ "${cmake_compiler_settings_comment}" cmake_kwsys_config_replace_string \ "${cmake_source_dir}/Source/kwsys/Configure.h.in" \ "${cmake_bootstrap_dir}/cmsys/Configure.h" \ "${cmake_compiler_settings_comment}" for a in ${KWSYS_FILES}; do cmake_replace_string "${cmake_source_dir}/Source/kwsys/${a}.in" \ "${cmake_bootstrap_dir}/cmsys/${a}" KWSYS_NAMESPACE cmsys done cmake_generate_file "${cmake_bootstrap_dir}/cmThirdParty.h" "" # Generate Makefile dep="cmConfigure.h cmsys/*.hxx cmsys/*.h `cmake_escape \"${cmake_source_dir}\"`/Source/*.h" objs="" for a in ${CMAKE_CXX_SOURCES} ${CMAKE_C_SOURCES} ${LexerParser_CXX_SOURCES} ${LexerParser_C_SOURCES} ${KWSYS_CXX_SOURCES} ${KWSYS_C_SOURCES}; do objs="${objs} ${a}.o" done for a in ${LIBUV_C_SOURCES}; do objs="${objs} uv-`cmake_obj ${a}`" done libs="" uv_c_flags="" if ${cmake_system_mingw}; then uv_c_flags="${uv_c_flags} -DWIN32_LEAN_AND_MEAN -D_WIN32_WINNT=0x0600" libs="${libs} -lws2_32 -lpsapi -liphlpapi -lshell32 -luserenv" else uv_c_flags="${uv_c_flags} -DCMAKE_BOOTSTRAP" case "${cmake_system}" in *AIX*) uv_c_flags="${uv_c_flags} -D_ALL_SOURCE -D_XOPEN_SOURCE=500 -D_LINUX_SOURCE_COMPAT -D_THREAD_SAFE" libs="${libs} -lperfstat" ;; *Darwin*) uv_c_flags="${uv_c_flags} -D_DARWIN_USE_64_BIT_INODE=1 -D_DARWIN_UNLIMITED_SELECT=1" ;; *Linux*) uv_c_flags="${uv_c_flags} -D_GNU_SOURCE" libs="${libs} -ldl -lrt" ;; *BSD*) libs="${libs} -lkvm" ;; *SunOS*) # Normally libuv uses '-D_XOPEN_SOURCE=500 -std=c90' on Solaris 5.10, # but we do not need to do that because we bootstrap using POSIX APIs. uv_c_flags="${uv_c_flags} -D__EXTENSIONS__ -D_XOPEN_SOURCE=600" libs="${libs} -lkstat -lnsl -lsendfile -lsocket -lrt" ;; esac fi uv_c_flags="${uv_c_flags} `cmake_escape "-I${cmake_source_dir}/Utilities/cmlibuv/include"`" if ${cmake_system_mingw}; then uv_c_flags="${uv_c_flags} `cmake_escape "-I${cmake_source_dir}/Utilities/cmlibuv/src/win"`" else uv_c_flags="${uv_c_flags} `cmake_escape "-I${cmake_source_dir}/Utilities/cmlibuv/src/unix"`" fi uv_c_flags="${uv_c_flags} `cmake_escape "-I${cmake_source_dir}/Utilities/cmlibuv/src"`" if [ "x${cmake_ansi_cxx_flags}" != "x" ]; then cmake_cxx_flags="${cmake_ansi_cxx_flags} ${cmake_cxx_flags}" fi if [ "x${cmake_c_flags}" != "x" ]; then cmake_c_flags="${cmake_c_flags} " fi if [ "x${cmake_cxx_flags}" != "x" ]; then cmake_cxx_flags="${cmake_cxx_flags} " fi cmake_c_flags_String="-DKWSYS_STRING_C" if ${cmake_system_mingw}; then cmake_c_flags_EncodingC="-DKWSYS_ENCODING_DEFAULT_CODEPAGE=CP_ACP" cmake_cxx_flags_EncodingCXX="${cmake_c_flags_EncodingC}" cmake_cxx_flags_cmProcessOutput="${cmake_c_flags_EncodingC}" fi cmake_cxx_flags_SystemTools=" -DKWSYS_CXX_HAS_SETENV=${KWSYS_CXX_HAS_SETENV} -DKWSYS_CXX_HAS_UNSETENV=${KWSYS_CXX_HAS_UNSETENV} -DKWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H=${KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H} -DKWSYS_CXX_HAS_UTIMENSAT=${KWSYS_CXX_HAS_UTIMENSAT} -DKWSYS_CXX_HAS_UTIMES=${KWSYS_CXX_HAS_UTIMES} " cmake_c_flags="${cmake_c_flags} \ -I`cmake_escape \"${cmake_bootstrap_dir}\"` \ -I`cmake_escape \"${cmake_source_dir}/Source\"` \ -I`cmake_escape \"${cmake_source_dir}/Source/LexerParser\"` \ -I`cmake_escape \"${cmake_source_dir}/Utilities\"`" cmake_cxx_flags="${cmake_cxx_flags} \ -I`cmake_escape \"${cmake_bootstrap_dir}\"` \ -I`cmake_escape \"${cmake_source_dir}/Source\"` \ -I`cmake_escape \"${cmake_source_dir}/Source/LexerParser\"` \ -I`cmake_escape \"${cmake_source_dir}/Utilities\"`" echo "cmake: ${objs}" > "${cmake_bootstrap_dir}/Makefile" echo " ${cmake_cxx_compiler} ${cmake_ld_flags} ${cmake_cxx_flags} ${objs} ${libs} -o cmake" >> "${cmake_bootstrap_dir}/Makefile" for a in ${CMAKE_CXX_SOURCES}; do src=`cmake_escape "${cmake_source_dir}/Source/${a}.cxx"` src_flags=`eval echo \\${cmake_cxx_flags_\${a}}` echo "${a}.o : ${src} ${dep}" >> "${cmake_bootstrap_dir}/Makefile" echo " ${cmake_cxx_compiler} ${cmake_cxx_flags} ${src_flags} -c ${src} -o ${a}.o" >> "${cmake_bootstrap_dir}/Makefile" done for a in ${CMAKE_C_SOURCES}; do src=`cmake_escape "${cmake_source_dir}/Source/${a}.c"` echo "${a}.o : ${src} ${dep}" >> "${cmake_bootstrap_dir}/Makefile" echo " ${cmake_c_compiler} ${cmake_c_flags} -c ${src} -o ${a}.o" >> "${cmake_bootstrap_dir}/Makefile" done for a in ${LexerParser_CXX_SOURCES}; do src=`cmake_escape "${cmake_source_dir}/Source/LexerParser/${a}.cxx"` src_flags=`eval echo \\${cmake_cxx_flags_\${a}}` echo "${a}.o : ${src} ${dep}" >> "${cmake_bootstrap_dir}/Makefile" echo " ${cmake_cxx_compiler} ${cmake_cxx_flags} ${src_flags} -c ${src} -o ${a}.o" >> "${cmake_bootstrap_dir}/Makefile" done for a in ${LexerParser_C_SOURCES}; do src=`cmake_escape "${cmake_source_dir}/Source/LexerParser/${a}.c"` echo "${a}.o : ${src} ${dep}" >> "${cmake_bootstrap_dir}/Makefile" echo " ${cmake_c_compiler} ${cmake_c_flags} -c ${src} -o ${a}.o" >> "${cmake_bootstrap_dir}/Makefile" done for a in ${KWSYS_C_SOURCES}; do src=`cmake_escape "${cmake_source_dir}/Source/kwsys/${a}.c"` src_flags=`eval echo \\${cmake_c_flags_\${a}}` echo "${a}.o : ${src} ${dep}" >> "${cmake_bootstrap_dir}/Makefile" echo " ${cmake_c_compiler} ${cmake_c_flags} -DKWSYS_NAMESPACE=cmsys ${src_flags} -c ${src} -o ${a}.o" >> "${cmake_bootstrap_dir}/Makefile" done for a in ${KWSYS_CXX_SOURCES}; do src=`cmake_escape "${cmake_source_dir}/Source/kwsys/${a}.cxx"` src_flags=`eval echo \\${cmake_cxx_flags_\${a}}` echo "${a}.o : ${src} ${dep}" >> "${cmake_bootstrap_dir}/Makefile" echo " ${cmake_cxx_compiler} ${cmake_cxx_flags} -DKWSYS_NAMESPACE=cmsys ${src_flags} -c ${src} -o ${a}.o" >> "${cmake_bootstrap_dir}/Makefile" done for a in ${LIBUV_C_SOURCES}; do src=`cmake_escape "${cmake_source_dir}/Utilities/cmlibuv/${a}"` echo "uv-`cmake_obj ${a}` : ${src} ${dep}" >> "${cmake_bootstrap_dir}/Makefile" echo " ${cmake_c_compiler} ${cmake_c_flags} ${uv_c_flags} -c ${src} -o uv-`cmake_obj ${a}`" >> "${cmake_bootstrap_dir}/Makefile" done echo ' rebuild_cache: cd "${cmake_binary_dir}" && "${cmake_source_dir}/bootstrap" ' >> "${cmake_bootstrap_dir}/Makefile" # Write our default settings to Bootstrap${_cmk}/InitialCacheFlags.cmake. echo ' # Generated by '"${cmake_source_dir}"'/bootstrap # Default cmake settings. These may be overridden any settings below. set (CMAKE_INSTALL_PREFIX "'"${cmake_prefix_dir}"'" CACHE PATH "Install path prefix, prepended onto install directories." FORCE) set (CMAKE_DOC_DIR "'"${cmake_doc_dir}"'" CACHE PATH "Install location for documentation (relative to prefix)." FORCE) set (CMAKE_MAN_DIR "'"${cmake_man_dir}"'" CACHE PATH "Install location for man pages (relative to prefix)." FORCE) set (CMAKE_BIN_DIR "'"${cmake_bin_dir}"'" CACHE PATH "Install location for binaries (relative to prefix)." FORCE) set (CMAKE_DATA_DIR "'"${cmake_data_dir}"'" CACHE PATH "Install location for data (relative to prefix)." FORCE) set (CMAKE_XDGDATA_DIR "'"${cmake_xdgdata_dir}"'" CACHE PATH "Install location for XDG specific files (relative to prefix)." FORCE) ' > "${cmake_bootstrap_dir}/InitialCacheFlags.cmake" # Add configuration settings given as command-line options. if [ "x${cmake_bootstrap_qt_gui}" != "x" ]; then echo ' set (BUILD_QtDialog '"${cmake_bootstrap_qt_gui}"' CACHE BOOL "Build Qt dialog for CMake" FORCE) ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake" fi if [ "x${cmake_bootstrap_qt_qmake}" != "x" ]; then echo ' set (QT_QMAKE_EXECUTABLE "'"${cmake_bootstrap_qt_qmake}"'" CACHE FILEPATH "Location of Qt qmake" FORCE) ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake" fi if [ "x${cmake_sphinx_man}" != "x" ]; then echo ' set (SPHINX_MAN "'"${cmake_sphinx_man}"'" CACHE BOOL "Build man pages with Sphinx" FORCE) ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake" fi if [ "x${cmake_sphinx_html}" != "x" ]; then echo ' set (SPHINX_HTML "'"${cmake_sphinx_html}"'" CACHE BOOL "Build html help with Sphinx" FORCE) ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake" fi if [ "x${cmake_sphinx_qthelp}" != "x" ]; then echo ' set (SPHINX_QTHELP "'"${cmake_sphinx_qthelp}"'" CACHE BOOL "Build qch help with Sphinx" FORCE) ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake" fi if [ "x${cmake_sphinx_build}" != "x" ]; then echo ' set (SPHINX_EXECUTABLE "'"${cmake_sphinx_build}"'" CACHE FILEPATH "Location of Qt sphinx-build" FORCE) ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake" fi if [ "x${cmake_sphinx_flags}" != "x" ]; then echo ' set (SPHINX_FLAGS [==['"${cmake_sphinx_flags}"']==] CACHE STRING "Flags to pass to sphinx-build" FORCE) ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake" fi # Add user-specified settings. Handle relative-path case for # specification of cmake_init_file. ( cd "${cmake_binary_dir}" if [ -f "${cmake_init_file}" ]; then cat "${cmake_init_file}" >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake" fi ) echo "---------------------------------------------" # Run make to build bootstrap cmake if [ "x${cmake_parallel_make}" != "x" ]; then ${cmake_make_processor} ${cmake_make_flags} else ${cmake_make_processor} fi RES=$? if [ "${RES}" -ne "0" ]; then cmake_error 9 "Problem while running ${cmake_make_processor}" fi cd "${cmake_binary_dir}" # Set C, CXX, and MAKE environment variables, so that real real cmake will be # build with same compiler and make CC="${cmake_c_compiler}" CXX="${cmake_cxx_compiler}" if [ -n "${cmake_ccache_enabled}" ]; then CC="ccache ${CC}" CXX="ccache ${CXX}" fi MAKE="${cmake_make_processor}" export CC export CXX export MAKE # Run bootstrap CMake to configure real CMake cmake_options="-DCMAKE_BOOTSTRAP=1" if [ -n "${cmake_verbose}" ]; then cmake_options="${cmake_options} -DCMAKE_VERBOSE_MAKEFILE=1" fi "${cmake_bootstrap_dir}/cmake" "${cmake_source_dir}" "-C${cmake_bootstrap_dir}/InitialCacheFlags.cmake" "-G${cmake_bootstrap_generator}" ${cmake_options} ${cmake_bootstrap_system_libs} "$@" RES=$? if [ "${RES}" -ne "0" ]; then cmake_error 11 "Problem while running initial CMake" fi echo "---------------------------------------------" # And we are done. Now just run make echo "CMake has bootstrapped. Now run ${cmake_make_processor}." cmake-3.10.2/cmake_uninstall.cmake.in000644 000766 000024 00000001426 13230131714 020245 0ustar00kitwarestaff000000 000000 if(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt") message(FATAL_ERROR "Cannot find install manifest: \"@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt\"") endif() file(READ "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" files) string(REPLACE "\n" ";" files "${files}") foreach(file ${files}) message(STATUS "Uninstalling \"$ENV{DESTDIR}${file}\"") if(EXISTS "$ENV{DESTDIR}${file}") exec_program( "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\"" OUTPUT_VARIABLE rm_out RETURN_VALUE rm_retval ) if("${rm_retval}" STREQUAL 0) else() message(FATAL_ERROR "Problem when removing \"$ENV{DESTDIR}${file}\"") endif() else() message(STATUS "File \"$ENV{DESTDIR}${file}\" does not exist.") endif() endforeach() cmake-3.10.2/CMakeCPack.cmake000644 000766 000024 00000023404 13230131712 016347 0ustar00kitwarestaff000000 000000 # Distributed under the OSI-approved BSD 3-Clause License. See accompanying # file Copyright.txt or https://cmake.org/licensing for details. option(CMAKE_INSTALL_DEBUG_LIBRARIES "Install Microsoft runtime debug libraries with CMake." FALSE) mark_as_advanced(CMAKE_INSTALL_DEBUG_LIBRARIES) # By default, do not warn when built on machines using only VS Express: if(NOT DEFINED CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_NO_WARNINGS) set(CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_NO_WARNINGS ON) endif() if(CMake_INSTALL_DEPENDENCIES) include(${CMake_SOURCE_DIR}/Modules/InstallRequiredSystemLibraries.cmake) endif() set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "CMake is a build tool") set(CPACK_PACKAGE_VENDOR "Kitware") set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/Copyright.txt") set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/Copyright.txt") set(CPACK_PACKAGE_NAME "${CMAKE_PROJECT_NAME}") set(CPACK_PACKAGE_VERSION "${CMake_VERSION}") set(CPACK_PACKAGE_INSTALL_DIRECTORY "${CPACK_PACKAGE_NAME}") set(CPACK_SOURCE_PACKAGE_FILE_NAME "cmake-${CMake_VERSION}") # Installers for 32- vs. 64-bit CMake: # - Root install directory (displayed to end user at installer-run time) # - "NSIS package/display name" (text used in the installer GUI) # - Registry key used to store info about the installation if(CMAKE_CL_64) set(CPACK_NSIS_INSTALL_ROOT "$PROGRAMFILES64") set(CPACK_NSIS_PACKAGE_NAME "${CPACK_PACKAGE_NAME} ${CPACK_PACKAGE_VERSION} (Win64)") else() set(CPACK_NSIS_INSTALL_ROOT "$PROGRAMFILES") set(CPACK_NSIS_PACKAGE_NAME "${CPACK_PACKAGE_NAME} ${CPACK_PACKAGE_VERSION}") endif() set(CPACK_PACKAGE_INSTALL_REGISTRY_KEY "${CPACK_NSIS_PACKAGE_NAME}") if(NOT DEFINED CPACK_SYSTEM_NAME) # make sure package is not Cygwin-unknown, for Cygwin just # cygwin is good for the system name if("x${CMAKE_SYSTEM_NAME}" STREQUAL "xCYGWIN") set(CPACK_SYSTEM_NAME Cygwin) else() set(CPACK_SYSTEM_NAME ${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR}) endif() endif() if(${CPACK_SYSTEM_NAME} MATCHES Windows) if(CMAKE_CL_64) set(CPACK_SYSTEM_NAME win64-x64) set(CPACK_IFW_TARGET_DIRECTORY "@RootDir@/Program Files/${CMAKE_PROJECT_NAME}") else() set(CPACK_SYSTEM_NAME win32-x86) endif() endif() # Command for configure IFW script templates include(${CMake_SOURCE_DIR}/Modules/CPackIFWConfigureFile.cmake) # Advanced IFW configuration set(_cpifwrc CPACK_IFW_COMPONENT_GROUP_CMAKE_) set(_cpifwrcconf _CPACK_IFW_COMPONENT_GROUP_CMAKE) set(${_cpifwrcconf} "# CMake IFW configuration\n") macro(_cmifwarg DESCRIPTION TYPE NAME DEFAULT) set(_var CMake_IFW_ROOT_COMPONENT_${NAME}) if(DEFINED ${_var}) set(${_var} ${${_var}} CACHE ${TYPE} ${DESCRIPTION}) mark_as_advanced(${_var}) elseif(NOT "${DEFAULT}" STREQUAL "") set(${_var} ${DEFAULT}) endif() if(DEFINED ${_var}) set(${_cpifwrcconf} "${${_cpifwrcconf}} set(${_cpifwrc}${NAME}\n \"${${_var}}\")\n") endif() endmacro() _cmifwarg("Package tag (domen-like)" STRING NAME "") _cmifwarg("Package tag" STRING DISPLAY_NAME "") _cmifwarg("Package tag" STRING DESCRIPTION "") _cmifwarg("Package tag (keep empty to auto generate)" STRING RELEASE_DATE "") _cmifwarg("Package tag (values: TRUE, FALSE, SCRIPT)" STRING DEFAULT "") _cmifwarg("Package tag" STRING VERSION "${CMake_VERSION_MAJOR}.${CMake_VERSION_MINOR}.${CMake_VERSION_PATCH}") _cmifwarg("Package tag" STRING PRIORITY "100") _cmifwarg("Package tag" STRING FORCED_INSTALLATION "") set(${_cpifwrc}LICENSES_DEFAULT "${CPACK_PACKAGE_NAME} Copyright;${CPACK_RESOURCE_FILE_LICENSE}") # Components if(CMake_INSTALL_COMPONENTS) set(_CPACK_IFW_COMPONENTS_ALL cmake ctest cpack) if(WIN32 AND NOT CYGWIN) list(APPEND _CPACK_IFW_COMPONENTS_ALL cmcldeps) endif() if(APPLE) list(APPEND _CPACK_IFW_COMPONENTS_ALL cmakexbuild) endif() if(CMAKE_INSTALL_DEFAULT_COMPONENT_NAME) set(_CPACK_IFW_COMPONENT_UNSPECIFIED_NAME ${CMAKE_INSTALL_DEFAULT_COMPONENT_NAME}) else() set(_CPACK_IFW_COMPONENT_UNSPECIFIED_NAME Unspecified) endif() list(APPEND _CPACK_IFW_COMPONENTS_ALL ${_CPACK_IFW_COMPONENT_UNSPECIFIED_NAME}) string(TOUPPER "${_CPACK_IFW_COMPONENT_UNSPECIFIED_NAME}" _CPACK_IFW_COMPONENT_UNSPECIFIED_UNAME) if(BUILD_CursesDialog) list(APPEND _CPACK_IFW_COMPONENTS_ALL ccmake) endif() if(BUILD_QtDialog) list(APPEND _CPACK_IFW_COMPONENTS_ALL cmake-gui) if(USE_LGPL) set(_CPACK_IFW_COMPONENT_CMAKE-GUI_LICENSES "set(CPACK_IFW_COMPONENT_CMAKE-GUI_LICENSES \"LGPLv${USE_LGPL}\" \"${CMake_SOURCE_DIR}/Licenses/LGPLv${USE_LGPL}.txt\")") endif() endif() if(SPHINX_MAN) list(APPEND _CPACK_IFW_COMPONENTS_ALL sphinx-man) endif() if(SPHINX_HTML) list(APPEND _CPACK_IFW_COMPONENTS_ALL sphinx-html) endif() if(SPHINX_SINGLEHTML) list(APPEND _CPACK_IFW_COMPONENTS_ALL sphinx-singlehtml) endif() if(SPHINX_QTHELP) list(APPEND _CPACK_IFW_COMPONENTS_ALL sphinx-qthelp) endif() if(CMake_BUILD_DEVELOPER_REFERENCE) if(CMake_BUILD_DEVELOPER_REFERENCE_HTML) list(APPEND _CPACK_IFW_COMPONENTS_ALL cmake-developer-reference-html) endif() if(CMake_BUILD_DEVELOPER_REFERENCE_QTHELP) list(APPEND _CPACK_IFW_COMPONENTS_ALL cmake-developer-reference-qthelp) endif() endif() set(_CPACK_IFW_COMPONENTS_CONFIGURATION " # Components set(CPACK_COMPONENTS_ALL \"${_CPACK_IFW_COMPONENTS_ALL}\") set(CPACK_COMPONENTS_GROUPING IGNORE) ") _cmifwarg("Package {% endif %} {{ super() }} {% endblock %} {# Put some context in the html title element. Workaround for #} {# https://bitbucket.org/birkenfeld/sphinx/issue/1492/qthelp-generate-html-title-element-should #} {% block htmltitle %} {{ title|striptags|e }} {{ "—"|safe }} {{ docstitle|e }} {% endblock %}