1 ;;; company-clang.el --- company-mode completion back-end for Clang -*- lexical-binding: t -*-
3 ;; Copyright (C) 2009, 2011, 2013-2014 Free Software Foundation, Inc.
5 ;; Author: Nikolaj Schumacher
7 ;; This file is part of GNU Emacs.
9 ;; GNU Emacs is free software: you can redistribute it and/or modify
10 ;; it under the terms of the GNU General Public License as published by
11 ;; the Free Software Foundation, either version 3 of the License, or
12 ;; (at your option) any later version.
14 ;; GNU Emacs is distributed in the hope that it will be useful,
15 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
16 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 ;; GNU General Public License for more details.
19 ;; You should have received a copy of the GNU General Public License
20 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
29 (require 'company-template)
32 (defgroup company-clang nil
33 "Completion back-end for Clang."
36 (defcustom company-clang-executable
37 (executable-find "clang")
38 "Location of clang executable."
41 (defcustom company-clang-begin-after-member-access t
42 "When non-nil, automatic completion will start whenever the current
43 symbol is preceded by \".\", \"->\" or \"::\", ignoring
44 `company-minimum-prefix-length'.
46 If `company-begin-commands' is a list, it should include `c-electric-lt-gt'
47 and `c-electric-colon', for automatic completion right after \">\" and
50 (defcustom company-clang-arguments nil
51 "Additional arguments to pass to clang when completing.
52 Prefix files (-include ...) can be selected with `company-clang-set-prefix'
53 or automatically through a custom `company-clang-prefix-guesser'."
54 :type '(repeat (string :tag "Argument")))
56 (defcustom company-clang-prefix-guesser 'company-clang-guess-prefix
57 "A function to determine the prefix file for the current buffer."
58 :type '(function :tag "Guesser function" nil))
60 (defvar company-clang-modes '(c-mode c++-mode objc-mode)
61 "Major modes which clang may complete.")
63 (defcustom company-clang-insert-arguments t
64 "When non-nil, insert function arguments as a template after completion."
66 :package-version '(company . "0.8.0"))
68 ;; prefix ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
70 (defvar company-clang--prefix nil)
72 (defsubst company-clang--guess-pch-file (file)
73 (let ((dir (directory-file-name (file-name-directory file))))
74 (when (equal (file-name-nondirectory dir) "Classes")
75 (setq dir (file-name-directory dir)))
76 (car (directory-files dir t "\\([^.]h\\|[^h]\\).pch\\'" t))))
78 (defsubst company-clang--file-substring (file beg end)
80 (insert-file-contents-literally file nil beg end)
83 (defun company-clang-guess-prefix ()
84 "Try to guess the prefix file for the current buffer."
85 ;; Prefixes seem to be called .pch. Pre-compiled headers do, too.
86 ;; So we look at the magic number to rule them out.
87 (let* ((file (company-clang--guess-pch-file buffer-file-name))
88 (magic-number (and file (company-clang--file-substring file 0 4))))
89 (unless (member magic-number '("CPCH" "gpch"))
92 (defun company-clang-set-prefix (&optional prefix)
93 "Use PREFIX as a prefix (-include ...) file for clang completion."
94 (interactive (let ((def (funcall company-clang-prefix-guesser)))
96 (setq def default-directory))
97 (list (read-file-name "Prefix file: "
98 (when def (file-name-directory def))
99 def t (when def (file-name-nondirectory def))))))
100 ;; TODO: pre-compile?
101 (setq company-clang--prefix (and (stringp prefix)
102 (file-regular-p prefix)
106 (add-hook 'kill-emacs-hook 'company-clang-set-prefix)
108 ;; parsing ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
110 ;; TODO: Handle Pattern (syntactic hints would be neat).
111 ;; Do we ever see OVERLOAD (or OVERRIDE)?
112 (defconst company-clang--completion-pattern
113 "^COMPLETION: \\_<\\(%s[a-zA-Z0-9_:]*\\)\\(?: : \\(.*\\)$\\)?$")
115 (defconst company-clang--error-buffer-name "*clang-error*")
117 (defun company-clang--lang-option ()
118 (if (eq major-mode 'objc-mode)
119 (if (string= "m" (file-name-extension buffer-file-name))
120 "objective-c" "objective-c++")
121 (substring (symbol-name major-mode) 0 -5)))
123 (defun company-clang--parse-output (prefix _objc)
124 (goto-char (point-min))
125 (let ((pattern (format company-clang--completion-pattern
126 (regexp-quote prefix)))
127 (case-fold-search nil)
129 (while (re-search-forward pattern nil t)
130 (setq match (match-string-no-properties 1))
131 (unless (equal match "Pattern")
133 (when (string-match ":" match)
134 (setq match (substring match 0 (match-beginning 0)))))
135 (let ((meta (match-string-no-properties 2)))
136 (when (and meta (not (string= match meta)))
137 (put-text-property 0 1 'meta
138 (company-clang--strip-formatting meta)
143 (defun company-clang--meta (candidate)
144 (get-text-property 0 'meta candidate))
146 (defun company-clang--annotation (candidate)
147 (let ((meta (company-clang--meta candidate)))
150 ((string-match "[^:]:[^:]" meta)
151 (substring meta (1+ (match-beginning 0))))
152 ((string-match "\\((.*)[ a-z]*\\'\\)" meta)
153 (let ((paren (match-beginning 1)))
154 (if (not (eq (aref meta (1- paren)) ?>))
155 (match-string 1 meta)
159 (substring meta (1- (search-backward "<"))))))))))
161 (defun company-clang--strip-formatting (text)
162 (replace-regexp-in-string
164 (replace-regexp-in-string "[<{[]#\\|#[>}]" "" text t)
167 (defun company-clang--handle-error (res args)
168 (goto-char (point-min))
169 (let* ((buf (get-buffer-create company-clang--error-buffer-name))
170 (cmd (concat company-clang-executable " " (mapconcat 'identity args " ")))
171 (pattern (format company-clang--completion-pattern ""))
172 (err (if (re-search-forward pattern nil t)
173 (buffer-substring-no-properties (point-min)
174 (1- (match-beginning 0)))
175 ;; Warn the user more aggressively if no match was found.
176 (message "clang failed with error %d:\n%s" res cmd)
179 (with-current-buffer buf
180 (let ((inhibit-read-only t))
182 (insert (current-time-string)
183 (format "\nclang failed with error %d:\n" res)
186 (setq buffer-read-only t)
187 (goto-char (point-min))))))
189 (defun company-clang--start-process (prefix callback &rest args)
190 (let ((objc (derived-mode-p 'objc-mode))
191 (buf (get-buffer-create "*clang-output*"))
192 ;; Looks unnecessary in Emacs 25.1 and later.
193 (process-adaptive-read-buffering nil))
194 (with-current-buffer buf (erase-buffer))
195 (if (get-buffer-process buf)
196 (funcall callback nil)
197 (let ((process (apply #'start-process "company-clang" buf
198 company-clang-executable args)))
199 (set-process-sentinel
201 (lambda (proc status)
202 (unless (string-match-p "hangup" status)
205 (let ((res (process-exit-status proc)))
206 (with-current-buffer buf
208 (company-clang--handle-error res args))
209 ;; Still try to get any useful input.
210 (company-clang--parse-output prefix objc)))))))
211 (unless (company-clang--auto-save-p)
212 (send-region process (point-min) (point-max))
213 (send-string process "\n")
214 (process-send-eof process))))))
216 (defsubst company-clang--build-location (pos)
220 (if (company-clang--auto-save-p) buffer-file-name "-")
223 (encode-coding-region
224 (line-beginning-position)
229 (defsubst company-clang--build-complete-args (pos)
230 (append '("-fsyntax-only" "-Xclang" "-code-completion-macros")
231 (unless (company-clang--auto-save-p)
232 (list "-x" (company-clang--lang-option)))
233 company-clang-arguments
234 (when (stringp company-clang--prefix)
235 (list "-include" (expand-file-name company-clang--prefix)))
236 (list "-Xclang" (format "-code-completion-at=%s"
237 (company-clang--build-location pos)))
238 (list (if (company-clang--auto-save-p) buffer-file-name "-"))))
240 (defun company-clang--candidates (prefix callback)
241 (and (company-clang--auto-save-p)
244 (when (null company-clang--prefix)
245 (company-clang-set-prefix (or (funcall company-clang-prefix-guesser)
247 (apply 'company-clang--start-process
250 (company-clang--build-complete-args (- (point) (length prefix)))))
252 (defun company-clang--prefix ()
253 (if company-clang-begin-after-member-access
254 (company-grab-symbol-cons "\\.\\|->\\|::" 2)
255 (company-grab-symbol)))
257 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
259 (defconst company-clang-required-version 1.1)
261 (defvar company-clang--version nil)
263 (defun company-clang--auto-save-p ()
264 (< company-clang--version 2.9))
266 (defsubst company-clang-version ()
267 "Return the version of `company-clang-executable'."
269 (call-process company-clang-executable nil t nil "--version")
270 (goto-char (point-min))
271 (if (re-search-forward "clang\\(?: version \\|-\\)\\([0-9.]+\\)" nil t)
272 (let ((ver (string-to-number (match-string-no-properties 1))))
278 (defun company-clang-objc-templatify (selector)
279 (let* ((end (point-marker))
280 (beg (- (point) (length selector) 1))
281 (templ (company-template-declare-template beg end))
286 (while (search-forward ":" end t)
287 (when (looking-at "([^)]*) ?")
288 (delete-region (match-beginning 0) (match-end 0)))
289 (company-template-add-field templ (point) (format "arg%d" cnt))
294 (company-template-move-to-first templ)))
296 (defun company-clang (command &optional arg &rest ignored)
297 "`company-mode' completion back-end for Clang.
298 Clang is a parser for C and ObjC. Clang version 1.1 or newer is required.
300 Additional command line arguments can be specified in
301 `company-clang-arguments'. Prefix files (-include ...) can be selected
302 with `company-clang-set-prefix' or automatically through a custom
303 `company-clang-prefix-guesser'.
305 With Clang versions before 2.9, we have to save the buffer before
306 performing completion. With Clang 2.9 and later, buffer contents are
307 passed via standard input."
308 (interactive (list 'interactive))
310 (interactive (company-begin-backend 'company-clang))
311 (init (when (memq major-mode company-clang-modes)
312 (unless company-clang-executable
313 (error "Company found no clang executable"))
314 (setq company-clang--version (company-clang-version))
315 (when (< company-clang--version company-clang-required-version)
316 (error "Company requires clang version 1.1"))))
317 (prefix (and (memq major-mode company-clang-modes)
319 company-clang-executable
320 (not (company-in-string-or-comment))
321 (or (company-clang--prefix) 'stop)))
322 (candidates (cons :async
323 (lambda (cb) (company-clang--candidates arg cb))))
324 (meta (company-clang--meta arg))
325 (annotation (company-clang--annotation arg))
326 (post-completion (let ((anno (company-clang--annotation arg)))
327 (when (and company-clang-insert-arguments anno)
329 (if (string-match "\\`:[^:]" anno)
330 (company-clang-objc-templatify anno)
331 (company-template-c-like-templatify
332 (concat arg anno))))))))
334 (provide 'company-clang)
335 ;;; company-clang.el ends here