;ELC
;;; Compiled
;;; in Emacs version 26.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(byte-code "\300\301!\210\300\302!\210\303\304\305\306\307\310\311\312&\207" [require rst rx custom-declare-variable cmake-mode-cmake-executable "cmake" "*The name of the cmake executable.\n\nThis can be either absolute or looked up in $PATH.  You can also\nset the path with these commands:\n (setenv \"PATH\" (concat (getenv \"PATH\") \";C:\\\\Program Files\\\\CMake 2.8\\\\bin\"))\n (setenv \"PATH\" (concat (getenv \"PATH\") \":/usr/local/cmake/bin\"))" :type file :group cmake] 8)
(defconst cmake-keywords-block-open '("BLOCK" "IF" "MACRO" "FOREACH" "ELSE" "ELSEIF" "WHILE" "FUNCTION"))
(defconst cmake-keywords-block-close '("ENDBLOCK" "ENDIF" "ENDFOREACH" "ENDMACRO" "ELSE" "ELSEIF" "ENDWHILE" "ENDFUNCTION"))
(defconst cmake-keywords (byte-code "\303	\304#\305\n!)\207" [cmake-keywords-block-open cmake-keywords-block-close kwds append nil delete-dups] 4))
(defconst cmake-regex-blank "^[ 	]*$")
(defconst cmake-regex-comment "#.*")
(defconst cmake-regex-paren-left "(")
(defconst cmake-regex-paren-right ")")
(defconst cmake-regex-closing-parens-line (concat "^[[:space:]]*\\(" cmake-regex-paren-right "+\\)[[:space:]]*$"))
(defconst cmake-regex-argument-quoted "\"\\(?:[^\"\\]\\|\\\\\\(?:.\\|\n\\)\\)*\"")
(defconst cmake-regex-argument-unquoted "\\(?:[^\n\"#()\\[:space:]]\\|\\\\.\\)\\(?:[^\n#()\\[:space:]]\\|\\\\.\\)*")
(defconst cmake-regex-token (byte-code "\303\304\305\306D\307\310\306	D\306\nD\257D!\207" [cmake-regex-comment cmake-regex-argument-unquoted cmake-regex-argument-quoted rx-to-string group or regexp 40 41] 9))
(defconst cmake-regex-indented (byte-code "\301\302\303\304\305\306\307D\310BBDDE!\207" [cmake-regex-token rx-to-string and bol * group or regexp ((any space 10))] 8))
(defconst cmake-regex-block-open (byte-code "\301\302\303\304\305\306\307\"\"B\310BBB!\207" [cmake-keywords-block-open rx-to-string and symbol-start or append mapcar downcase (symbol-end)] 9))
(defconst cmake-regex-block-close (byte-code "\301\302\303\304\305\306\307\"\"B\310BBB!\207" [cmake-keywords-block-close rx-to-string and symbol-start or append mapcar downcase (symbol-end)] 9))
(defconst cmake-regex-close (byte-code "\302\303\304\305\306D\307\306	D\257!\207" [cmake-regex-block-close cmake-regex-paren-left rx-to-string and bol (* space) regexp (* space)] 8))
(defconst cmake-regex-token-paren-left (concat "^" cmake-regex-paren-left "$"))
(defconst cmake-regex-token-paren-right (concat "^" cmake-regex-paren-right "$"))
#@69 Determine whether the beginning of the current line is in a string.
(defalias 'cmake-line-starts-inside-string #[nil "\212\301 \210`eb\210\302\303`\"8*\207" [parse-end beginning-of-line 3 parse-partial-sexp] 4 (#$ . 2863)])
#@73 Move to the beginning of the last line that has meaningful indentation.
(defalias 'cmake-find-last-indented-line #[nil "`\304\305y\210\306`	\"o?\2057\307\n!\204,\310 \204,\311\"\205(G\312\225U?\2057\305y\210\306`	\"\202\f*\207" [region point-start cmake-regex-blank cmake-regex-indented nil -1 buffer-substring-no-properties looking-at cmake-line-starts-inside-string string-match 0] 3 (#$ . 3095)])
#@42 Number of columns to indent cmake blocks
(custom-declare-variable 'cmake-tab-width 2 '(#$ . 3514) :type 'integer :group 'cmake)
#@36 Indent current line as CMake code.
(defalias 'cmake-indent #[nil "\306 ?\205\277o\203\307\310!\207\311\212\312 \210`\313	!\314\311\315 \210\316 \f\203h\310\317
\314#\203X\320\310!\321\n\"\203HT\202+\321\n\"\203+S\202+\310V\204dZ)\202\270\313	!\204\251\317
\314#\203\251\320\310!\321\n\"\204\224\321\n\"\203\231\313\322P!\203\231\\\321\n\"\203nZ\202n
b\210\313!\203\270Z-\307\310]!)\207" [cur-indent cmake-regex-closing-parens-line token case-fold-search closing-parens-only point-start cmake-line-starts-inside-string cmake-indent-line-to 0 nil beginning-of-line looking-at t cmake-find-last-indented-line current-indentation re-search-forward match-string string-match "[ 	]*" open-parens cmake-regex-token cmake-regex-token-paren-left cmake-regex-token-paren-right cmake-tab-width cmake-regex-block-open cmake-regex-paren-left cmake-regex-close] 4 (#$ . 3648) nil])
(defalias 'cmake-point-in-indendation #[nil "\300\301\302 `{\"\207" [string-match "^[ \\t]*$" point-at-bol] 4])
#@175 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
(defalias 'cmake-indent-line-to #[(column) "\301 \203	\302!\207\212\302!)\207" [column cmake-point-in-indendation indent-line-to] 2 (#$ . 4709)])
#@52 Convert all CMake commands to lowercase in buffer.
(defalias 'cmake-unscreamify-buffer #[nil "\212eb\210\300\301\302\303#\205\304\305\306!\305\307!\227\305\310!Q\303\"\210\202)\207" [re-search-forward "^\\([ 	]*\\)\\_<\\(\\(?:\\w\\|\\s_\\)+\\)\\_>\\([ 	]*(\\)" nil t replace-match match-string 1 2 3] 5 (#$ . 5038) nil])
(defconst cmake--regex-defun-start "^[[:space:]]*\\(?:function\\|macro\\)[[:space:]]*(")
(defconst cmake--regex-defun-end "^[[:space:]]*end\\(?:function\\|macro\\)[[:space:]]*([^)]*)")
#@120 Move backward to the beginning of a CMake function or macro.

Return t unless search stops due to beginning of buffer.
(defalias 'cmake-beginning-of-defun #[nil "\302 \204\303 \210\304\305	\306\307#\205\304)\207" [case-fold-search cmake--regex-defun-start region-active-p push-mark t re-search-backward nil move] 4 (#$ . 5555) nil])
#@107 Move forward to the end of a CMake function or macro.

Return t unless search stops due to end of buffer.
(defalias 'cmake-end-of-defun #[nil "\302 \204\303 \210\304\305	\306\307#\205\306y\210\304)\207" [case-fold-search cmake--regex-defun-end region-active-p push-mark t re-search-forward nil move] 4 (#$ . 5900) nil])
#@103 Mark the current CMake function or macro.

This puts the mark at the end, and point at the beginning.
(defalias 'cmake-mark-defun #[nil "\300 \210\301\302\303\304#\210\305 \207" [cmake-end-of-defun push-mark nil :nomsg :activate cmake-beginning-of-defun] 4 (#$ . 6232) nil])
#@42 Highlighting expressions for CMake mode.
(defconst cmake-font-lock-keywords (byte-code "\301\302\303\304\305\306\307\"\"B\310BBB!\311B\312\313B\314\315BE\207" [cmake-keywords rx-to-string and symbol-start or append mapcar downcase (symbol-end) font-lock-keyword-face "\\_<\\(\\(?:[[:word:]]\\|\\s_\\)+\\)[[:blank:]]*(" (1 font-lock-function-name-face) "\\${\\([--/+_[:alnum:]]+\\)}" (1 font-lock-variable-name-face t)] 9) (#$ . 6513))
(defalias 'cmake--syntax-propertize-until-bracket-close #[(syntax) "\306\224\306\225\307\310	{\"\311 \312\216\313\n\f\314#\203*\315\225\316	S	\317\320
!$\210\202,\f*\316\321\224	\322\323$+\207" [mb me cb save-match-data-internal end syntax 2 format "]%s]" match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] search-forward move 0 put-text-property syntax-table string-to-syntax 1 syntax-multiline t] 6])
(defconst cmake--syntax-propertize-function #[(start end) "b\210`	W\205K\303\304	\305#\205K\306\224\203&\307\306\224\306\225\310\311$\210\312\313!\210\202\314\224\203\315\316!\211A\317\n\233\241\210\320\n!\210)\307\306\224\306\225\310\321$\210\312\322!\210\202\207" [start end md re-search-forward "\\(#\\)\\[\\(=*\\)\\[\\|\\(\\[\\)\\(=*\\)\\[" t 1 put-text-property syntax-table (14) cmake--syntax-propertize-until-bracket-close "!" 3 match-data ints 6 set-match-data (15) "|"] 6])
#@30 Syntax table for CMake mode.
(defvar cmake-mode-syntax-table nil (#$ . 7901))
(byte-code "\204(\302 \303\304\305	#\210\303\306\307	#\210\303\310\311	#\210\303\312\313	#\210\303\314\315	#\210	)\302\207" [cmake-mode-syntax-table table make-syntax-table modify-syntax-entry 40 "()" 41 ")(" 35 "<" 10 ">" 36 "'"] 4)
(defvar cmake-mode-hook nil)
(defvar cmake-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [cmake-mode-hook variable-documentation put "Hook run after entering CMake mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp cmake-mode-map definition-name cmake-mode] 4)
(defvar cmake-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204\303\301\302\304\305!#\210\306\307!\204\303\307\310\311#\210\312\313 !\210\307\302N\204-\303\307\302\304\314!#\210\306\300!\204B\303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P\303\300\302\304\320!#\210\303\311\321\322#\207" [cmake-mode-abbrev-table cmake-mode-map variable-documentation put purecopy "Keymap for `cmake-mode'." boundp cmake-mode-syntax-table definition-name cmake-mode (lambda (#1=#:def-tmp-var) (defvar cmake-mode-syntax-table #1#)) make-syntax-table "Syntax table for `cmake-mode'." (lambda (#1#) (defvar cmake-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `cmake-mode'." derived-mode-parent prog-mode] 5)
#@232 Major mode for editing CMake source files.

In addition to any hooks its parent mode `prog-mode' might have run,
this mode runs the hook `cmake-mode-hook', as the final or penultimate step
during initialization.

\{cmake-mode-map}
(defalias 'cmake-mode #[nil "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2036
\321 =\203<\322\f\323 \"\210)\324&\325\"\204V&'=\204V\326&\325'C#\210\327!\210\330\f!\210&'\306\331!\210\332\306\333!\210\334\306\335!\210\336\306\337!\210(\340\341\342\343\307$\210)\344\345!\207" [delay-mode-hooks major-mode mode-name cmake-mode-map cmake-mode-syntax-table parent make-local-variable t prog-mode cmake-mode "CMake" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table font-lock-defaults (cmake-font-lock-keywords) indent-line-function cmake-indent comment-start "#" syntax-propertize-function add-hook syntax-propertize-extend-region-functions syntax-propertize-multiline nil run-mode-hooks cmake-mode-hook cmake-mode-abbrev-table local-abbrev-table cmake--syntax-propertize-function] 6 (#$ . 9376) nil])
(byte-code "\301\302\303#\210\301\304\305#\210\301\306\307#\207" [cmake-mode-map define-key "
" cmake-beginning-of-defun "" cmake-end-of-defun "" cmake-mark-defun] 4)
#@122 Runs the command cmake with the arguments specified.  The
optional argument topic will be appended to the argument list.
(defalias 'cmake-command-run #[(type &optional topic buffer) "\203\202\306	\n\205\307\n\310\260\311!\203 \311!\202#\312!\f\313	\313\n\260\314\315
\"\210\316 r\317\216\320\321\322\"!\210\323 \210\324\325!\210\326\325!.\207" [buffer type topic bufname cmake-mode-cmake-executable command "*CMake" "-" "*" get-buffer generate-new-buffer " " nil shell-command internal--before-save-selected-window #[nil "\301!\207" [save-selected-window--state internal--after-save-selected-window] 2] select-window display-buffer not-this-window cmake-mode read-only-mode 1 view-mode resize-mini-windows save-selected-window--state] 5 (#$ . 10847) "s"])
#@49 `cmake-command-run' but rendered in `rst-mode'.
(defalias 'cmake-command-run-help #[(type &optional topic buffer) "\203\202\306	\n\205\307\n\310\260\311!\203 \311!\202#\312!\f\313	\313\n\260\314\315
\"\210\316 r\317\216\320\321\322\"!\210\323 \210\324\325!\210\326\325!.\207" [buffer type topic bufname cmake-mode-cmake-executable command "*CMake" "-" "*" get-buffer generate-new-buffer " " nil shell-command internal--before-save-selected-window #[nil "\301!\207" [save-selected-window--state internal--after-save-selected-window] 2] select-window display-buffer not-this-window rst-mode read-only-mode 1 view-mode resize-mini-windows save-selected-window--state] 5 (#$ . 11635) "s"])
#@42 Prints out a list of the cmake commands.
(defalias 'cmake-help-list-commands #[nil "\300\301!\207" [cmake-command-run-help "--help-command-list"] 2 (#$ . 12353) nil])
#@46 List of available topics for --help-command.
(defvar cmake-commands nil (#$ . 12526))
#@23 Command read history.
(defvar cmake-help-command-history nil (#$ . 12618))
#@45 List of available topics for --help-module.
(defvar cmake-modules nil (#$ . 12699))
#@22 Module read history.
(defvar cmake-help-module-history nil (#$ . 12789))
#@47 List of available topics for --help-variable.
(defvar cmake-variables nil (#$ . 12868))
#@24 Variable read history.
(defvar cmake-help-variable-history nil (#$ . 12962))
#@47 List of available topics for --help-property.
(defvar cmake-properties nil (#$ . 13045))
#@24 Property read history.
(defvar cmake-help-property-history nil (#$ . 13140))
#@29 Complete help read history.
(defvar cmake-help-complete-history nil (#$ . 13223))
(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)))
#@107 If the value of LISTVAR is nil, run cmake --help-LISTNAME-list
and store the result as a list in LISTVAR.
(defalias 'cmake-get-list #[(listname) "\305	\"A@\211J\204.\306\307 \310\216\311\312\313Q\314#\210rq\210\n\315\316ed\"\317\320#L,\2020\nJ)\207" [listname cmake-string-to-list-symbol listvar temp-buffer-name #1=#:wconfig assoc "*CMake Temporary*" current-window-configuration #[nil "\301!\207" [#1# set-window-configuration] 2] cmake-command-run-help "--help-" "-list" nil split-string buffer-substring-no-properties "\n" t] 6 (#$ . 13572)])
(require 'thingatpt)
(defalias 'cmake-symbol-at-point #[nil "\301 \211??\205\f\302!)\207" [symbol symbol-at-point symbol-name] 3])
(defalias 'cmake-help-type #[(type) "\305 \306	\n\"AA@\307\310\311	\"\312	!\313\314&\211\315\230\203&\316\317!\202'\f+\207" [default-entry type cmake-string-to-list-symbol history input cmake-symbol-at-point assoc completing-read format "CMake %s: " cmake-get-list nil t "" error "No argument given"] 8])
#@63 Prints out the help message for the command the cursor is on.
(defalias 'cmake-help-command #[nil "\300\301\302\303!\304#\207" [cmake-command-run-help "--help-command" cmake-help-type "command" "*CMake Help*"] 4 (#$ . 14582) nil])
#@62 Prints out the help message for the module the cursor is on.
(defalias 'cmake-help-module #[nil "\300\301\302\303!\304#\207" [cmake-command-run-help "--help-module" cmake-help-type "module" "*CMake Help*"] 4 (#$ . 14819) nil])
#@64 Prints out the help message for the variable the cursor is on.
(defalias 'cmake-help-variable #[nil "\300\301\302\303!\304#\207" [cmake-command-run-help "--help-variable" cmake-help-type "variable" "*CMake Help*"] 4 (#$ . 15052) nil])
#@64 Prints out the help message for the property the cursor is on.
(defalias 'cmake-help-property #[nil "\300\301\302\303!\304#\207" [cmake-command-run-help "--help-property" cmake-help-type "property" "*CMake Help*"] 4 (#$ . 15293) nil])
#@88 Queries for any of the four available help topics and prints out the appropriate page.
(defalias 'cmake-help #[nil "\306 \307\310!\307\311!\307\312!\307\313!\314	\n\f$\315\316
\317\320\321&\211\322\230\2031\323\324!\202t	\235\203A\325\326\327#\202t\n\235\203Q\325\330\327#\202t\235\203a\325\331\327#\202t\f\235\203q\325\332\327#\202t\323\333!.\207" [default-entry command-list variable-list module-list property-list all-words cmake-symbol-at-point cmake-get-list "command" "variable" "module" "property" append completing-read "CMake command/module/variable/property: " nil t cmake-help-complete-history "" error "No argument given" cmake-command-run-help "--help-command" "*CMake Help*" "--help-variable" "--help-module" "--help-property" "Not a know help topic." input] 8 (#$ . 15534) nil])
(byte-code "\300\301\302\"\210\300\301\303\"\210\304\305!\207" [add-to-list auto-mode-alist ("CMakeLists\\.txt\\'" . cmake-mode) ("\\.cmake\\'" . cmake-mode) provide cmake-mode] 3)