mirror of
https://github.com/crystalidea/qt-build-tools.git
synced 2024-11-30 07:11:59 +08:00
532 lines
19 KiB
EmacsLisp
532 lines
19 KiB
EmacsLisp
;;; cmake-mode.el --- major-mode for editing CMake sources
|
|
|
|
;; Package-Requires: ((emacs "24.1"))
|
|
|
|
; 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
|
|
;;
|
|
|
|
(require 'rst)
|
|
(require 'rx)
|
|
|
|
(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 '("BLOCK" "IF" "MACRO" "FOREACH" "ELSE" "ELSEIF" "WHILE" "FUNCTION"))
|
|
(defconst cmake-keywords-block-close '("ENDBLOCK" "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-closing-parens-line (concat "^[[:space:]]*\\("
|
|
cmake-regex-paren-right
|
|
"+\\)[[:space:]]*$"))
|
|
(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))))
|
|
(defconst cmake-regex-token-paren-left (concat "^" cmake-regex-paren-left "$"))
|
|
(defconst cmake-regex-token-paren-right (concat "^" cmake-regex-paren-right "$"))
|
|
|
|
;------------------------------------------------------------------------------
|
|
|
|
;; 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))
|
|
(closing-parens-only (looking-at cmake-regex-closing-parens-line))
|
|
(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))
|
|
(if closing-parens-only
|
|
(let ((open-parens 0))
|
|
(while (re-search-forward cmake-regex-token point-start t)
|
|
(setq token (match-string 0))
|
|
(cond
|
|
((string-match cmake-regex-token-paren-left token)
|
|
(setq open-parens (+ open-parens 1)))
|
|
((string-match cmake-regex-token-paren-right token)
|
|
(setq open-parens (- open-parens 1)))))
|
|
;; Don't outdent if last indented line has open parens
|
|
(unless (> open-parens 0)
|
|
(setq cur-indent (- cur-indent cmake-tab-width))))
|
|
;; Skip detailed analysis if last indented line is a 'closing
|
|
;; parens only line'
|
|
(unless (looking-at cmake-regex-closing-parens-line)
|
|
;; 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 cmake-regex-token-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 cmake-regex-token-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))
|
|
)
|
|
)
|
|
|
|
|
|
;------------------------------------------------------------------------------
|
|
|
|
;;
|
|
;; Navigation / marking by function or macro
|
|
;;
|
|
|
|
(defconst cmake--regex-defun-start
|
|
(rx line-start
|
|
(zero-or-more space)
|
|
(or "function" "macro")
|
|
(zero-or-more space)
|
|
"("))
|
|
|
|
(defconst cmake--regex-defun-end
|
|
(rx line-start
|
|
(zero-or-more space)
|
|
"end"
|
|
(or "function" "macro")
|
|
(zero-or-more space)
|
|
"(" (zero-or-more (not-char ")")) ")"))
|
|
|
|
(defun cmake-beginning-of-defun ()
|
|
"Move backward to the beginning of a CMake function or macro.
|
|
|
|
Return t unless search stops due to beginning of buffer."
|
|
(interactive)
|
|
(when (not (region-active-p))
|
|
(push-mark))
|
|
(let ((case-fold-search t))
|
|
(when (re-search-backward cmake--regex-defun-start nil 'move)
|
|
t)))
|
|
|
|
(defun cmake-end-of-defun ()
|
|
"Move forward to the end of a CMake function or macro.
|
|
|
|
Return t unless search stops due to end of buffer."
|
|
(interactive)
|
|
(when (not (region-active-p))
|
|
(push-mark))
|
|
(let ((case-fold-search t))
|
|
(when (re-search-forward cmake--regex-defun-end nil 'move)
|
|
(forward-line)
|
|
t)))
|
|
|
|
(defun cmake-mark-defun ()
|
|
"Mark the current CMake function or macro.
|
|
|
|
This puts the mark at the end, and point at the beginning."
|
|
(interactive)
|
|
(cmake-end-of-defun)
|
|
(push-mark nil :nomsg :activate)
|
|
(cmake-beginning-of-defun))
|
|
|
|
|
|
;------------------------------------------------------------------------------
|
|
|
|
;;
|
|
;; 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.")
|
|
|
|
;------------------------------------------------------------------------------
|
|
|
|
(defun cmake--syntax-propertize-until-bracket-close (syntax)
|
|
;; This function assumes that a previous search has matched the
|
|
;; beginning of a bracket_comment or bracket_argument and that the
|
|
;; second capture group has matched the equal signs between the two
|
|
;; opening brackets
|
|
(let* ((mb (match-beginning 2))
|
|
(me (match-end 2))
|
|
(cb (format "]%s]" (buffer-substring mb me))))
|
|
(save-match-data
|
|
(if (search-forward cb end 'move)
|
|
(progn
|
|
(setq me (match-end 0))
|
|
(put-text-property
|
|
(1- me)
|
|
me
|
|
'syntax-table
|
|
(string-to-syntax syntax)))
|
|
(setq me end)))
|
|
(put-text-property
|
|
(match-beginning 1)
|
|
me
|
|
'syntax-multiline
|
|
t)))
|
|
|
|
(defconst cmake--syntax-propertize-function
|
|
(syntax-propertize-rules
|
|
("\\(#\\)\\[\\(=*\\)\\["
|
|
(1
|
|
(prog1 "!" (cmake--syntax-propertize-until-bracket-close "!"))))
|
|
("\\(\\[\\)\\(=*\\)\\["
|
|
(1
|
|
(prog1 "|" (cmake--syntax-propertize-until-bracket-close "|"))))))
|
|
|
|
;; 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)
|
|
|
|
;;------------------------------------------------------------------------------
|
|
;; Mode definition.
|
|
;;
|
|
;;;###autoload
|
|
(define-derived-mode cmake-mode prog-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) "#")
|
|
;; Setup syntax propertization
|
|
(set (make-local-variable 'syntax-propertize-function) cmake--syntax-propertize-function)
|
|
(add-hook 'syntax-propertize-extend-region-functions #'syntax-propertize-multiline nil t))
|
|
|
|
;; Default cmake-mode key bindings
|
|
(define-key cmake-mode-map "\e\C-a" #'cmake-beginning-of-defun)
|
|
(define-key cmake-mode-map "\e\C-e" #'cmake-end-of-defun)
|
|
(define-key cmake-mode-map "\e\C-h" #'cmake-mark-defun)
|
|
|
|
|
|
; 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 " " (if topic (shell-quote-argument topic) 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)
|
|
(view-mode 1))
|
|
)
|
|
)
|
|
|
|
;;;###autoload
|
|
(defun cmake-command-run-help (type &optional topic buffer)
|
|
"`cmake-command-run' but rendered in `rst-mode'."
|
|
(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 " " (if topic (shell-quote-argument topic) 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))
|
|
(rst-mode)
|
|
(read-only-mode 1)
|
|
(view-mode 1))
|
|
)
|
|
)
|
|
|
|
;;;###autoload
|
|
(defun cmake-help-list-commands ()
|
|
"Prints out a list of the cmake commands."
|
|
(interactive)
|
|
(cmake-command-run-help "--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-help (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 "--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 "--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 "--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 "--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 appropriate 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 "--help-command" input "*CMake Help*")
|
|
(if (member input variable-list)
|
|
(cmake-command-run-help "--help-variable" input "*CMake Help*")
|
|
(if (member input module-list)
|
|
(cmake-command-run-help "--help-module" input "*CMake Help*")
|
|
(if (member input property-list)
|
|
(cmake-command-run-help "--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
|