--- /dev/null
+;;; company-abbrev.el --- company-mode completion backend for abbrev
+
+;; Copyright (C) 2009-2011, 2013-2015, 2021 Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+
+;;; Code:
+
+(require 'company)
+(require 'cl-lib)
+(require 'abbrev)
+
+(defun company-abbrev-insert (match)
+ "Replace MATCH with the expanded abbrev."
+ (expand-abbrev))
+
+;;;###autoload
+(defun company-abbrev (command &optional arg &rest ignored)
+ "`company-mode' completion backend for abbrev."
+ (interactive (list 'interactive))
+ (cl-case command
+ (interactive (company-begin-backend 'company-abbrev
+ 'company-abbrev-insert))
+ (prefix (company-grab-symbol))
+ (candidates (nconc
+ (delete "" (all-completions arg global-abbrev-table))
+ (delete "" (all-completions arg local-abbrev-table))))
+ (kind 'snippet)
+ (meta (abbrev-expansion arg))
+ (post-completion (expand-abbrev))))
+
+(provide 'company-abbrev)
+;;; company-abbrev.el ends here
--- /dev/null
+;;; company-autoloads.el --- automatically extracted autoloads -*- lexical-binding: t -*-
+;;
+;;; Code:
+
+(add-to-list 'load-path (directory-file-name
+ (or (file-name-directory #$) (car load-path))))
+
+\f
+;;;### (autoloads nil "company" "company.el" (0 0 0 0))
+;;; Generated autoloads from company.el
+
+(autoload 'company-mode "company" "\
+\"complete anything\"; is an in-buffer completion framework.
+Completion starts automatically, depending on the values
+`company-idle-delay' and `company-minimum-prefix-length'.
+
+This is a minor mode. If called interactively, toggle the
+`Company mode' mode. If the prefix argument is positive, enable
+the mode, and if it is zero or negative, disable the mode.
+
+If called from Lisp, toggle the mode if ARG is `toggle'. Enable
+the mode if ARG is nil, omitted, or is a positive number.
+Disable the mode if ARG is a negative number.
+
+To check whether the minor mode is enabled in the current buffer,
+evaluate `company-mode'.
+
+The mode's hook is called both when the mode is enabled and when
+it is disabled.
+
+Completion can be controlled with the commands:
+`company-complete-common', `company-complete-selection', `company-complete',
+`company-select-next', `company-select-previous'. If these commands are
+called before `company-idle-delay', completion will also start.
+
+Completions can be searched with `company-search-candidates' or
+`company-filter-candidates'. These can be used while completion is
+inactive, as well.
+
+The completion data is retrieved using `company-backends' and displayed
+using `company-frontends'. If you want to start a specific backend, call
+it interactively or use `company-begin-backend'.
+
+By default, the completions list is sorted alphabetically, unless the
+backend chooses otherwise, or `company-transformers' changes it later.
+
+regular keymap (`company-mode-map'):
+
+\\{company-mode-map}
+keymap during active completions (`company-active-map'):
+
+\\{company-active-map}
+
+\(fn &optional ARG)" t nil)
+
+(put 'global-company-mode 'globalized-minor-mode t)
+
+(defvar global-company-mode nil "\
+Non-nil if Global Company mode is enabled.
+See the `global-company-mode' command
+for a description of this minor mode.
+Setting this variable directly does not take effect;
+either customize it (see the info node `Easy Customization')
+or call the function `global-company-mode'.")
+
+(custom-autoload 'global-company-mode "company" nil)
+
+(autoload 'global-company-mode "company" "\
+Toggle Company mode in all buffers.
+With prefix ARG, enable Global Company mode if ARG is positive;
+otherwise, disable it.
+
+If called from Lisp, toggle the mode if ARG is `toggle'.
+Enable the mode if ARG is nil, omitted, or is a positive number.
+Disable the mode if ARG is a negative number.
+
+Company mode is enabled in all buffers where `company-mode-on' would
+do it.
+
+See `company-mode' for more information on Company mode.
+
+\(fn &optional ARG)" t nil)
+
+(autoload 'company-manual-begin "company" nil t nil)
+
+(autoload 'company-complete "company" "\
+Insert the common part of all candidates or the current selection.
+The first time this is called, the common part is inserted, the second
+time, or when the selection has been changed, the selected candidate is
+inserted." t nil)
+
+(register-definition-prefixes "company" '("company-"))
+
+;;;***
+\f
+;;;### (autoloads nil "company-abbrev" "company-abbrev.el" (0 0 0
+;;;;;; 0))
+;;; Generated autoloads from company-abbrev.el
+
+(autoload 'company-abbrev "company-abbrev" "\
+`company-mode' completion backend for abbrev.
+
+\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
+
+(register-definition-prefixes "company-abbrev" '("company-abbrev-insert"))
+
+;;;***
+\f
+;;;### (autoloads nil "company-bbdb" "company-bbdb.el" (0 0 0 0))
+;;; Generated autoloads from company-bbdb.el
+
+(autoload 'company-bbdb "company-bbdb" "\
+`company-mode' completion backend for BBDB.
+
+\(fn COMMAND &optional ARG &rest IGNORE)" t nil)
+
+(register-definition-prefixes "company-bbdb" '("company-bbdb-"))
+
+;;;***
+\f
+;;;### (autoloads nil "company-capf" "company-capf.el" (0 0 0 0))
+;;; Generated autoloads from company-capf.el
+
+(register-definition-prefixes "company-capf" '("company-"))
+
+;;;***
+\f
+;;;### (autoloads nil "company-clang" "company-clang.el" (0 0 0 0))
+;;; Generated autoloads from company-clang.el
+
+(register-definition-prefixes "company-clang" '("company-clang"))
+
+;;;***
+\f
+;;;### (autoloads nil "company-cmake" "company-cmake.el" (0 0 0 0))
+;;; Generated autoloads from company-cmake.el
+
+(register-definition-prefixes "company-cmake" '("company-cmake"))
+
+;;;***
+\f
+;;;### (autoloads nil "company-css" "company-css.el" (0 0 0 0))
+;;; Generated autoloads from company-css.el
+
+(autoload 'company-css "company-css" "\
+`company-mode' completion backend for `css-mode'.
+
+\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
+
+(register-definition-prefixes "company-css" '("company-css-"))
+
+;;;***
+\f
+;;;### (autoloads nil "company-dabbrev" "company-dabbrev.el" (0 0
+;;;;;; 0 0))
+;;; Generated autoloads from company-dabbrev.el
+
+(autoload 'company-dabbrev "company-dabbrev" "\
+dabbrev-like `company-mode' completion backend.
+
+\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
+
+(register-definition-prefixes "company-dabbrev" '("company-dabbrev-"))
+
+;;;***
+\f
+;;;### (autoloads nil "company-dabbrev-code" "company-dabbrev-code.el"
+;;;;;; (0 0 0 0))
+;;; Generated autoloads from company-dabbrev-code.el
+
+(autoload 'company-dabbrev-code "company-dabbrev-code" "\
+dabbrev-like `company-mode' backend for code.
+The backend looks for all symbols in the current buffer that aren't in
+comments or strings.
+
+\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
+
+(register-definition-prefixes "company-dabbrev-code" '("company-dabbrev-code-"))
+
+;;;***
+\f
+;;;### (autoloads nil "company-elisp" "company-elisp.el" (0 0 0 0))
+;;; Generated autoloads from company-elisp.el
+
+(autoload 'company-elisp "company-elisp" "\
+`company-mode' completion backend for Emacs Lisp.
+
+\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
+
+(register-definition-prefixes "company-elisp" '("company-elisp-"))
+
+;;;***
+\f
+;;;### (autoloads nil "company-etags" "company-etags.el" (0 0 0 0))
+;;; Generated autoloads from company-etags.el
+
+(autoload 'company-etags "company-etags" "\
+`company-mode' completion backend for etags.
+
+\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
+
+(register-definition-prefixes "company-etags" '("company-etags-"))
+
+;;;***
+\f
+;;;### (autoloads nil "company-files" "company-files.el" (0 0 0 0))
+;;; Generated autoloads from company-files.el
+
+(autoload 'company-files "company-files" "\
+`company-mode' completion backend existing file names.
+Completions works for proper absolute and relative files paths.
+File paths with spaces are only supported inside strings.
+
+\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
+
+(register-definition-prefixes "company-files" '("company-file"))
+
+;;;***
+\f
+;;;### (autoloads nil "company-gtags" "company-gtags.el" (0 0 0 0))
+;;; Generated autoloads from company-gtags.el
+
+(autoload 'company-gtags "company-gtags" "\
+`company-mode' completion backend for GNU Global.
+
+\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
+
+(register-definition-prefixes "company-gtags" '("company-gtags-"))
+
+;;;***
+\f
+;;;### (autoloads nil "company-ispell" "company-ispell.el" (0 0 0
+;;;;;; 0))
+;;; Generated autoloads from company-ispell.el
+
+(autoload 'company-ispell "company-ispell" "\
+`company-mode' completion backend using Ispell.
+
+\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
+
+(register-definition-prefixes "company-ispell" '("company-ispell-"))
+
+;;;***
+\f
+;;;### (autoloads nil "company-keywords" "company-keywords.el" (0
+;;;;;; 0 0 0))
+;;; Generated autoloads from company-keywords.el
+
+(autoload 'company-keywords "company-keywords" "\
+`company-mode' backend for programming language keywords.
+
+\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
+
+(register-definition-prefixes "company-keywords" '("company-keywords-"))
+
+;;;***
+\f
+;;;### (autoloads nil "company-nxml" "company-nxml.el" (0 0 0 0))
+;;; Generated autoloads from company-nxml.el
+
+(autoload 'company-nxml "company-nxml" "\
+`company-mode' completion backend for `nxml-mode'.
+
+\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
+
+(register-definition-prefixes "company-nxml" '("company-nxml-"))
+
+;;;***
+\f
+;;;### (autoloads nil "company-oddmuse" "company-oddmuse.el" (0 0
+;;;;;; 0 0))
+;;; Generated autoloads from company-oddmuse.el
+
+(autoload 'company-oddmuse "company-oddmuse" "\
+`company-mode' completion backend for `oddmuse-mode'.
+
+\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
+
+(register-definition-prefixes "company-oddmuse" '("company-oddmuse-"))
+
+;;;***
+\f
+;;;### (autoloads nil "company-semantic" "company-semantic.el" (0
+;;;;;; 0 0 0))
+;;; Generated autoloads from company-semantic.el
+
+(autoload 'company-semantic "company-semantic" "\
+`company-mode' completion backend using CEDET Semantic.
+
+\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
+
+(register-definition-prefixes "company-semantic" '("company-semantic-"))
+
+;;;***
+\f
+;;;### (autoloads nil "company-template" "company-template.el" (0
+;;;;;; 0 0 0))
+;;; Generated autoloads from company-template.el
+
+(register-definition-prefixes "company-template" '("company-template-"))
+
+;;;***
+\f
+;;;### (autoloads nil "company-tempo" "company-tempo.el" (0 0 0 0))
+;;; Generated autoloads from company-tempo.el
+
+(autoload 'company-tempo "company-tempo" "\
+`company-mode' completion backend for tempo.
+
+\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
+
+(register-definition-prefixes "company-tempo" '("company-tempo-"))
+
+;;;***
+\f
+;;;### (autoloads nil "company-tng" "company-tng.el" (0 0 0 0))
+;;; Generated autoloads from company-tng.el
+
+(autoload 'company-tng-frontend "company-tng" "\
+When the user changes the selection at least once, this
+frontend will display the candidate in the buffer as if it's
+already there and any key outside of `company-active-map' will
+confirm the selection and finish the completion.
+
+\(fn COMMAND)" nil nil)
+
+(define-obsolete-function-alias 'company-tng-configure-default 'company-tng-mode "0.9.14" "\
+Applies the default configuration to enable company-tng.")
+
+(defvar company-tng-mode nil "\
+Non-nil if Company-Tng mode is enabled.
+See the `company-tng-mode' command
+for a description of this minor mode.
+Setting this variable directly does not take effect;
+either customize it (see the info node `Easy Customization')
+or call the function `company-tng-mode'.")
+
+(custom-autoload 'company-tng-mode "company-tng" nil)
+
+(autoload 'company-tng-mode "company-tng" "\
+This minor mode enables `company-tng-frontend'.
+
+This is a minor mode. If called interactively, toggle the
+`Company-Tng mode' mode. If the prefix argument is positive,
+enable the mode, and if it is zero or negative, disable the mode.
+
+If called from Lisp, toggle the mode if ARG is `toggle'. Enable
+the mode if ARG is nil, omitted, or is a positive number.
+Disable the mode if ARG is a negative number.
+
+To check whether the minor mode is enabled in the current buffer,
+evaluate `(default-value \\='company-tng-mode)'.
+
+The mode's hook is called both when the mode is enabled and when
+it is disabled.
+
+\(fn &optional ARG)" t nil)
+
+(register-definition-prefixes "company-tng" '("company-tng-"))
+
+;;;***
+\f
+;;;### (autoloads nil "company-yasnippet" "company-yasnippet.el"
+;;;;;; (0 0 0 0))
+;;; Generated autoloads from company-yasnippet.el
+
+(autoload 'company-yasnippet "company-yasnippet" "\
+`company-mode' backend for `yasnippet'.
+
+This backend should be used with care, because as long as there are
+snippets defined for the current major mode, this backend will always
+shadow backends that come after it. Recommended usages:
+
+* In a buffer-local value of `company-backends', grouped with a backend or
+ several that provide actual text completions.
+
+ (add-hook \\='js-mode-hook
+ (lambda ()
+ (set (make-local-variable \\='company-backends)
+ \\='((company-dabbrev-code company-yasnippet)))))
+
+* After keyword `:with', grouped with other backends.
+
+ (push \\='(company-semantic :with company-yasnippet) company-backends)
+
+* Not in `company-backends', just bound to a key.
+
+ (global-set-key (kbd \"C-c y\") \\='company-yasnippet)
+
+\(fn COMMAND &optional ARG &rest IGNORE)" t nil)
+
+(register-definition-prefixes "company-yasnippet" '("company-yasnippet-"))
+
+;;;***
+\f
+;;;### (autoloads nil nil ("company-pkg.el") (0 0 0 0))
+
+;;;***
+\f
+;; Local Variables:
+;; version-control: never
+;; no-byte-compile: t
+;; no-update-autoloads: t
+;; coding: utf-8
+;; End:
+;;; company-autoloads.el ends here
--- /dev/null
+;;; company-bbdb.el --- company-mode completion backend for BBDB in message-mode
+
+;; Copyright (C) 2013-2016, 2020 Free Software Foundation, Inc.
+
+;; Author: Jan Tatarik <jan.tatarikNOSPAMgmail.com>
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+
+(require 'company)
+(require 'cl-lib)
+
+(declare-function bbdb-record-get-field "bbdb")
+(declare-function bbdb-records "bbdb")
+(declare-function bbdb-dwim-mail "bbdb-com")
+(declare-function bbdb-search "bbdb-com")
+
+(defgroup company-bbdb nil
+ "Completion backend for BBDB."
+ :group 'company)
+
+(defcustom company-bbdb-modes '(message-mode)
+ "Major modes in which `company-bbdb' may complete."
+ :type '(repeat (symbol :tag "Major mode"))
+ :package-version '(company . "0.8.8"))
+
+(defun company-bbdb--candidates (arg)
+ (cl-mapcan (lambda (record)
+ (mapcar (lambda (mail) (bbdb-dwim-mail record mail))
+ (bbdb-record-get-field record 'mail)))
+ (eval '(bbdb-search (bbdb-records) arg nil arg))))
+
+;;;###autoload
+(defun company-bbdb (command &optional arg &rest ignore)
+ "`company-mode' completion backend for BBDB."
+ (interactive (list 'interactive))
+ (cl-case command
+ (interactive (company-begin-backend 'company-bbdb))
+ (prefix (and (memq major-mode company-bbdb-modes)
+ (featurep 'bbdb-com)
+ (let ((case-fold-search t))
+ (looking-back
+ "^\\([^ :]*-\\)?\\(To\\|B?Cc\\|From\\):.*? *\\([^,;]*\\)"
+ (line-beginning-position)))
+ (match-string-no-properties 3)))
+ (candidates (company-bbdb--candidates arg))
+ (sorted t)
+ (no-cache t)))
+
+(provide 'company-bbdb)
+;;; company-bbdb.el ends here
--- /dev/null
+;;; company-capf.el --- company-mode completion-at-point-functions backend -*- lexical-binding: t -*-
+
+;; Copyright (C) 2013-2021 Free Software Foundation, Inc.
+
+;; Author: Stefan Monnier <monnierNOSPAMiro.umontreal.ca>
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+;; The CAPF back-end provides a bridge to the standard
+;; completion-at-point-functions facility, and thus can support any major mode
+;; that defines a proper completion function, including emacs-lisp-mode,
+;; css-mode and nxml-mode.
+
+;;; Code:
+
+(require 'company)
+(require 'cl-lib)
+
+;; Amortizes several calls to a c-a-p-f from the same position.
+(defvar company--capf-cache nil)
+
+;; FIXME: Provide a way to save this info once in Company itself
+;; (https://github.com/company-mode/company-mode/pull/845).
+(defvar-local company-capf--current-completion-data nil
+ "Value last returned by `company-capf' when called with `candidates'.
+For most properties/actions, this is just what we need: the exact values
+that accompanied the completion table that's currently is use.
+
+`company-capf', however, could be called at some different positions during
+a completion session (most importantly, by `company-sort-by-occurrence'),
+so we can't just use the preceding variable instead.")
+
+(defun company--capf-data ()
+ (let ((cache company--capf-cache))
+ (if (and (equal (current-buffer) (car cache))
+ (equal (point) (car (setq cache (cdr cache))))
+ (equal (buffer-chars-modified-tick) (car (setq cache (cdr cache)))))
+ (cadr cache)
+ (let ((data (company--capf-data-real)))
+ (setq company--capf-cache
+ (list (current-buffer) (point) (buffer-chars-modified-tick) data))
+ data))))
+
+(defun company--contains (elt lst)
+ (when-let ((cur (car lst)))
+ (cond
+ ((symbolp cur)
+ (or (eq elt cur)
+ (company--contains elt (cdr lst))))
+ ((listp cur)
+ (or (company--contains elt cur)
+ (company--contains elt (cdr lst)))))))
+
+(defun company--capf-data-real ()
+ (cl-letf* (((default-value 'completion-at-point-functions)
+ (if (company--contains 'company-etags company-backends)
+ ;; Ignore tags-completion-at-point-function because it subverts
+ ;; company-etags in the default value of company-backends, where
+ ;; the latter comes later.
+ (remove 'tags-completion-at-point-function
+ (default-value 'completion-at-point-functions))
+ (default-value 'completion-at-point-functions)))
+ (completion-at-point-functions (company--capf-workaround))
+ (data (run-hook-wrapped 'completion-at-point-functions
+ ;; Ignore misbehaving functions.
+ #'company--capf-wrapper 'optimist)))
+ (when (and (consp (cdr data)) (integer-or-marker-p (nth 1 data))) data)))
+
+(defun company--capf-wrapper (fun which)
+ (let ((buffer-read-only t)
+ (inhibit-read-only nil)
+ (completion-in-region-function
+ (lambda (beg end coll pred)
+ (throw 'company--illegal-completion-in-region
+ (list fun beg end coll :predicate pred)))))
+ (catch 'company--illegal-completion-in-region
+ (condition-case nil
+ (completion--capf-wrapper fun which)
+ (buffer-read-only nil)))))
+
+(declare-function python-shell-get-process "python")
+
+(defun company--capf-workaround ()
+ ;; For http://debbugs.gnu.org/cgi/bugreport.cgi?bug=18067
+ (if (or (not (listp completion-at-point-functions))
+ (not (memq 'python-completion-complete-at-point completion-at-point-functions))
+ (python-shell-get-process))
+ completion-at-point-functions
+ (remq 'python-completion-complete-at-point completion-at-point-functions)))
+
+(defun company-capf--save-current-data (data)
+ (setq company-capf--current-completion-data data)
+ (add-hook 'company-after-completion-hook
+ #'company-capf--clear-current-data nil t))
+
+(defun company-capf--clear-current-data (_ignored)
+ (setq company-capf--current-completion-data nil))
+
+(defvar-local company-capf--sorted nil)
+
+(defun company-capf (command &optional arg &rest _args)
+ "`company-mode' backend using `completion-at-point-functions'."
+ (interactive (list 'interactive))
+ (pcase command
+ (`interactive (company-begin-backend 'company-capf))
+ (`prefix
+ (let ((res (company--capf-data)))
+ (when res
+ (let ((length (plist-get (nthcdr 4 res) :company-prefix-length))
+ (prefix (buffer-substring-no-properties (nth 1 res) (point))))
+ (cond
+ ((> (nth 2 res) (point)) 'stop)
+ (length (cons prefix length))
+ (t prefix))))))
+ (`candidates
+ (company-capf--candidates arg))
+ (`sorted
+ company-capf--sorted)
+ (`match
+ ;; Ask the for the `:company-match' function. If that doesn't help,
+ ;; fallback to sniffing for face changes to get a suitable value.
+ (let ((f (plist-get (nthcdr 4 company-capf--current-completion-data)
+ :company-match)))
+ (if f (funcall f arg)
+ (let* ((match-start nil) (pos -1)
+ (prop-value nil) (faces nil)
+ (has-face-p nil) chunks
+ (limit (length arg)))
+ (while (< pos limit)
+ (setq pos
+ (if (< pos 0) 0 (next-property-change pos arg limit)))
+ (setq prop-value (or
+ (get-text-property pos 'face arg)
+ (get-text-property pos 'font-lock-face arg))
+ faces (if (listp prop-value) prop-value (list prop-value))
+ has-face-p (memq 'completions-common-part faces))
+ (cond ((and (not match-start) has-face-p)
+ (setq match-start pos))
+ ((and match-start (not has-face-p))
+ (push (cons match-start pos) chunks)
+ (setq match-start nil))))
+ (nreverse chunks)))))
+ (`duplicates t)
+ (`no-cache t) ;Not much can be done here, as long as we handle
+ ;non-prefix matches.
+ (`meta
+ (let ((f (plist-get (nthcdr 4 company-capf--current-completion-data)
+ :company-docsig)))
+ (when f (funcall f arg))))
+ (`doc-buffer
+ (let ((f (plist-get (nthcdr 4 company-capf--current-completion-data)
+ :company-doc-buffer)))
+ (when f (funcall f arg))))
+ (`location
+ (let ((f (plist-get (nthcdr 4 company-capf--current-completion-data)
+ :company-location)))
+ (when f (funcall f arg))))
+ (`annotation
+ (company-capf--annotation arg))
+ (`kind
+ (let ((f (plist-get (nthcdr 4 company-capf--current-completion-data)
+ :company-kind)))
+ (when f (funcall f arg))))
+ (`deprecated
+ (let ((f (plist-get (nthcdr 4 company-capf--current-completion-data)
+ :company-deprecated)))
+ (when f (funcall f arg))))
+ (`require-match
+ (plist-get (nthcdr 4 (company--capf-data)) :company-require-match))
+ (`init nil) ;Don't bother: plenty of other ways to initialize the code.
+ (`post-completion
+ (company--capf-post-completion arg))
+ ))
+
+(defun company-capf--annotation (arg)
+ (let* ((f (or (plist-get (nthcdr 4 company-capf--current-completion-data)
+ :annotation-function)
+ ;; FIXME: Add a test.
+ (cdr (assq 'annotation-function
+ (completion-metadata
+ (buffer-substring (nth 1 company-capf--current-completion-data)
+ (nth 2 company-capf--current-completion-data))
+ (nth 3 company-capf--current-completion-data)
+ (plist-get (nthcdr 4 company-capf--current-completion-data)
+ :predicate))))))
+ (annotation (when f (funcall f arg))))
+ (if (and company-format-margin-function
+ (equal annotation " <f>") ; elisp-completion-at-point, pre-icons
+ (plist-get (nthcdr 4 company-capf--current-completion-data)
+ :company-kind))
+ nil
+ annotation)))
+
+(defun company-capf--candidates (input)
+ (let ((res (company--capf-data)))
+ (company-capf--save-current-data res)
+ (when res
+ (let* ((table (nth 3 res))
+ (pred (plist-get (nthcdr 4 res) :predicate))
+ (meta (completion-metadata
+ (buffer-substring (nth 1 res) (nth 2 res))
+ table pred))
+ (candidates (completion-all-completions input table pred
+ (length input)
+ meta))
+ (sortfun (cdr (assq 'display-sort-function meta)))
+ (last (last candidates))
+ (base-size (and (numberp (cdr last)) (cdr last))))
+ (when base-size
+ (setcdr last nil))
+ (setq company-capf--sorted (functionp sortfun))
+ (when sortfun
+ (setq candidates (funcall sortfun candidates)))
+ (if (not (zerop (or base-size 0)))
+ (let ((before (substring input 0 base-size)))
+ (mapcar (lambda (candidate)
+ (concat before candidate))
+ candidates))
+ candidates)))))
+
+(defun company--capf-post-completion (arg)
+ (let* ((res company-capf--current-completion-data)
+ (exit-function (plist-get (nthcdr 4 res) :exit-function))
+ (table (nth 3 res)))
+ (if exit-function
+ ;; We can more or less know when the user is done with completion,
+ ;; so we do something different than `completion--done'.
+ (funcall exit-function arg
+ ;; FIXME: Should probably use an additional heuristic:
+ ;; completion-at-point doesn't know when the user picked a
+ ;; particular candidate explicitly (it only checks whether
+ ;; further completions exist). Whereas company user can press
+ ;; RET (or use implicit completion with company-tng).
+ (if (= (car (completion-boundaries arg table nil ""))
+ (length arg))
+ 'sole
+ 'finished)))))
+
+(provide 'company-capf)
+
+;;; company-capf.el ends here
--- /dev/null
+;;; company-clang.el --- company-mode completion backend for Clang -*- lexical-binding: t -*-
+
+;; Copyright (C) 2009-2011, 2013-2023 Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+
+;;; Code:
+
+(require 'company)
+(require 'company-template)
+(require 'cl-lib)
+
+(defgroup company-clang nil
+ "Completion backend for Clang."
+ :group 'company)
+
+(defcustom company-clang-executable
+ (executable-find "clang")
+ "Location of clang executable."
+ :type 'file)
+
+(defcustom company-clang-begin-after-member-access t
+ "When non-nil, start automatic completion after member access operators.
+
+Automatic completion starts whenever the current symbol is preceded by
+\".\", \"->\" or \"::\", ignoring `company-minimum-prefix-length'.
+
+If `company-begin-commands' is a list, it should include `c-electric-lt-gt'
+and `c-electric-colon', for automatic completion right after \">\" and
+\":\"."
+ :type 'boolean)
+
+(defcustom company-clang-use-compile-flags-txt nil
+ "When non-nil, use flags from compile_flags.txt if present.
+
+The lines from that files will be appended to `company-clang-arguments'.
+
+And if such file is found, Clang is called from the directory containing
+it. That allows the flags use relative file names within the project."
+ :type 'boolean
+ :safe 'booleanp)
+
+(defcustom company-clang-arguments nil
+ "A list of additional arguments to pass to clang when completing.
+Prefix files (-include ...) can be selected with `company-clang-set-prefix'
+or automatically through a custom `company-clang-prefix-guesser'."
+ :type '(repeat (string :tag "Argument")))
+
+(defcustom company-clang-prefix-guesser 'company-clang-guess-prefix
+ "A function to determine the prefix file for the current buffer."
+ :type '(function :tag "Guesser function" nil))
+
+(defvar company-clang-modes '(c-mode c++-mode objc-mode)
+ "Major modes which clang may complete.")
+
+(defcustom company-clang-insert-arguments t
+ "When non-nil, insert function arguments as a template after completion."
+ :type 'boolean
+ :package-version '(company . "0.8.0"))
+
+;; prefix ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defvar company-clang--prefix nil)
+
+(defsubst company-clang--guess-pch-file (file)
+ (let ((dir (directory-file-name (file-name-directory file))))
+ (when (equal (file-name-nondirectory dir) "Classes")
+ (setq dir (file-name-directory dir)))
+ (car (directory-files dir t "\\([^.]h\\|[^h]\\).pch\\'" t))))
+
+(defsubst company-clang--file-substring (file beg end)
+ (with-temp-buffer
+ (insert-file-contents-literally file nil beg end)
+ (buffer-string)))
+
+(defun company-clang-guess-prefix ()
+ "Try to guess the prefix file for the current buffer."
+ ;; Prefixes seem to be called .pch. Pre-compiled headers do, too.
+ ;; So we look at the magic number to rule them out.
+ (let* ((file (company-clang--guess-pch-file buffer-file-name))
+ (magic-number (and file (company-clang--file-substring file 0 4))))
+ (unless (member magic-number '("CPCH" "gpch"))
+ file)))
+
+(defun company-clang-set-prefix (&optional prefix)
+ "Use PREFIX as a prefix (-include ...) file for clang completion."
+ (interactive (let ((def (funcall company-clang-prefix-guesser)))
+ (unless (stringp def)
+ (setq def default-directory))
+ (list (read-file-name "Prefix file: "
+ (when def (file-name-directory def))
+ def t (when def (file-name-nondirectory def))))))
+ ;; TODO: pre-compile?
+ (setq company-clang--prefix (and (stringp prefix)
+ (file-regular-p prefix)
+ prefix)))
+
+;; Clean-up on exit.
+(add-hook 'kill-emacs-hook 'company-clang-set-prefix)
+
+;; parsing ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Do we ever see OVERLOAD (or OVERRIDE)?
+(defconst company-clang--completion-pattern
+ "^COMPLETION: \\_<\\(%s[a-zA-Z0-9_:]*\\|Pattern\\)\\(?:\\(?: (InBase)\\)? : \\(.*\\)$\\)?$")
+
+(defconst company-clang--error-buffer-name "*clang-error*")
+
+(defun company-clang--lang-option ()
+ (if (eq major-mode 'objc-mode)
+ (if (string= "m" (file-name-extension buffer-file-name))
+ "objective-c" "objective-c++")
+ (substring (symbol-name major-mode) 0 -5)))
+
+(defun company-clang--parse-output (prefix _objc)
+ (goto-char (point-min))
+ (let ((pattern (format company-clang--completion-pattern
+ (regexp-quote prefix)))
+ (case-fold-search nil)
+ (results (make-hash-table :test 'equal :size (/ (point-max) 100)))
+ lines)
+ (while (re-search-forward pattern nil t)
+ (let ((match (match-string-no-properties 1))
+ (meta (match-string-no-properties 2)))
+ (when (equal match "Pattern")
+ (setq match (company-clang--pattern-to-match meta)))
+ (when (string-match ":" match)
+ (setq match (substring match 0 (match-beginning 0))))
+ ;; Avoiding duplicates:
+ ;; https://github.com/company-mode/company-mode/issues/841
+ (cond
+ ;; Either meta != completion (not a macro)
+ ((not (equal match meta))
+ (puthash match meta results))
+ ;; Or it's the first time we see this completion
+ ((eq (gethash match results 'none) 'none)
+ (puthash match nil results)))))
+ (maphash
+ (lambda (match meta)
+ (when meta
+ (put-text-property 0 1 'meta (company-clang--strip-formatting meta) match))
+ (push match lines))
+ results)
+ lines))
+
+(defun company-clang--pattern-to-match (pat)
+ (let ((start 0)
+ (end nil))
+ (when (string-match "#]" pat)
+ (setq start (match-end 0)))
+ (when (string-match "[ \(]<#" pat start)
+ (setq end (match-beginning 0)))
+ (substring pat start end)))
+
+(defun company-clang--meta (candidate)
+ (get-text-property 0 'meta candidate))
+
+(defun company-clang--annotation (candidate)
+ (let ((ann (company-clang--annotation-1 candidate)))
+ (if (not (and ann (string-prefix-p "(*)" ann)))
+ ann
+ (with-temp-buffer
+ (insert ann)
+ (search-backward ")")
+ (let ((pt (1+ (point))))
+ (re-search-forward ".\\_>" nil t)
+ (delete-region pt (point)))
+ (buffer-string)))))
+
+;; TODO: Parse the original formatting here, rather than guess.
+;; Strip it every time in the `meta' handler instead.
+(defun company-clang--annotation-1 (candidate)
+ (let ((meta (company-clang--meta candidate)))
+ (cond
+ ((null meta) nil)
+ ((string-match "[^:]:[^:]" meta)
+ (substring meta (1+ (match-beginning 0))))
+ ((string-match "(anonymous)" meta) nil)
+ ((string-match "\\((.*)[ a-z]*\\'\\)" meta)
+ (let ((paren (match-beginning 1)))
+ (if (not (eq (aref meta (1- paren)) ?>))
+ (match-string 1 meta)
+ (with-temp-buffer
+ (insert meta)
+ (goto-char paren)
+ (substring meta (1- (search-backward "<"))))))))))
+
+(defun company-clang--strip-formatting (text)
+ (replace-regexp-in-string
+ "#]" " "
+ (replace-regexp-in-string "[<{[]#\\|#[>}]" "" text t)
+ t))
+
+(defun company-clang--handle-error (res args)
+ (goto-char (point-min))
+ (let* ((buf (get-buffer-create company-clang--error-buffer-name))
+ (cmd (concat company-clang-executable " " (mapconcat 'identity args " ")))
+ (pattern (format company-clang--completion-pattern ""))
+ (message-truncate-lines t)
+ (err (if (and (re-search-forward pattern nil t)
+ ;; Something in the Windows build?
+ ;; Looks like Clang doesn't always include the error text
+ ;; before completions (even if exited with error).
+ (> (match-beginning 0) (point-min)))
+ (buffer-substring-no-properties (point-min)
+ (1- (match-beginning 0)))
+ ;; Warn the user more aggressively if no match was found.
+ (message "clang failed with error %d: %s" res cmd)
+ (buffer-string))))
+
+ (with-current-buffer buf
+ (let ((inhibit-read-only t))
+ (erase-buffer)
+ (insert (current-time-string)
+ (format "\nclang failed with error %d:\n" res)
+ cmd "\n\n")
+ (insert err)
+ (setq buffer-read-only t)
+ (goto-char (point-min))))))
+
+(defun company-clang--start-process (prefix callback &rest args)
+ (let* ((objc (derived-mode-p 'objc-mode))
+ (buf (get-buffer-create "*clang-output*"))
+ ;; Looks unnecessary in Emacs 25.1 and later.
+ ;; (Inconclusive, needs more testing):
+ ;; https://github.com/company-mode/company-mode/pull/288#issuecomment-72491808
+ (process-adaptive-read-buffering nil)
+ (existing-process (get-buffer-process buf)))
+ (when existing-process
+ (kill-process existing-process))
+ (with-current-buffer buf
+ (erase-buffer)
+ (setq buffer-undo-list t))
+ (let* ((process-connection-type nil)
+ (process (apply #'start-file-process "company-clang" buf
+ company-clang-executable args)))
+ (set-process-sentinel
+ process
+ (lambda (proc status)
+ (unless (string-match-p "hangup\\|killed" status)
+ (funcall
+ callback
+ (let ((res (process-exit-status proc)))
+ (with-current-buffer buf
+ (unless (eq 0 res)
+ (company-clang--handle-error res args))
+ ;; Still try to get any useful input.
+ (company-clang--parse-output prefix objc)))))))
+ (unless (company-clang--auto-save-p)
+ (send-region process (point-min) (point-max))
+ (send-string process "\n")
+ (process-send-eof process)))))
+
+(defsubst company-clang--build-location (pos)
+ (save-excursion
+ (goto-char pos)
+ (format "%s:%d:%d"
+ (if (company-clang--auto-save-p) buffer-file-name "-")
+ (line-number-at-pos)
+ (1+ (length
+ (encode-coding-region
+ (line-beginning-position)
+ (point)
+ 'utf-8
+ t))))))
+
+(defsubst company-clang--build-complete-args (pos)
+ (append '("-fsyntax-only" "-Xclang" "-code-completion-macros")
+ (unless (company-clang--auto-save-p)
+ (list "-x" (company-clang--lang-option)))
+ (company-clang--arguments)
+ (when (stringp company-clang--prefix)
+ (list "-include" (expand-file-name company-clang--prefix)))
+ (list "-Xclang" (format "-code-completion-at=%s"
+ (company-clang--build-location pos)))
+ (list (if (company-clang--auto-save-p) buffer-file-name "-"))))
+
+(defun company-clang--arguments ()
+ (let ((fname "compile_flags.txt")
+ (args company-clang-arguments)
+ current-dir-rel)
+ (when company-clang-use-compile-flags-txt
+ (let ((dir (locate-dominating-file default-directory fname)))
+ (when dir
+ (setq current-dir-rel (file-relative-name default-directory dir))
+ (setq default-directory dir)
+ (with-temp-buffer
+ (insert-file-contents fname)
+ (setq args
+ (append
+ args
+ (split-string (buffer-substring-no-properties
+ (point-min) (point-max))
+ "[\n\r]+"
+ t
+ "[ \t]+"))))
+ (unless (equal current-dir-rel "./")
+ (push (format "-I%s" current-dir-rel) args)))))
+ args))
+
+(defun company-clang--candidates (prefix callback)
+ (and (company-clang--auto-save-p)
+ (buffer-modified-p)
+ (basic-save-buffer))
+ (when (null company-clang--prefix)
+ (company-clang-set-prefix (or (funcall company-clang-prefix-guesser)
+ 'none)))
+ (let ((default-directory default-directory))
+ (apply 'company-clang--start-process
+ prefix
+ callback
+ (company-clang--build-complete-args
+ (if (company-clang--check-version 4.0 9.0)
+ (point)
+ (- (point) (length prefix)))))))
+
+(defun company-clang--prefix ()
+ (if company-clang-begin-after-member-access
+ (company-grab-symbol-cons "\\.\\|->\\|::" 2)
+ (company-grab-symbol)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defconst company-clang-required-version 1.1)
+
+(defvar company-clang--version nil)
+
+(defun company-clang--auto-save-p ()
+ (not
+ (company-clang--check-version 2.9 3.1)))
+
+(defun company-clang--check-version (min apple-min)
+ (pcase-exhaustive company-clang--version
+ (`(apple . ,ver) (>= ver apple-min))
+ (`(normal . ,ver) (>= ver min))))
+
+(defsubst company-clang-version ()
+ "Return the version of `company-clang-executable'."
+ (with-temp-buffer
+ (call-process company-clang-executable nil t nil "--version")
+ (goto-char (point-min))
+ (if (re-search-forward
+ "\\(clang\\|Apple LLVM\\|bcc32x\\|bcc64\\) version \\([0-9.]+\\)" nil t)
+ (cons
+ (if (equal (match-string-no-properties 1) "Apple LLVM")
+ 'apple
+ 'normal)
+ (string-to-number (match-string-no-properties 2)))
+ 0)))
+
+(defun company-clang (command &optional arg &rest _ignored)
+ "`company-mode' completion backend for Clang.
+Clang is a parser for C and ObjC. Clang version 1.1 or newer is required.
+
+Additional command line arguments can be specified in
+`company-clang-arguments'. Prefix files (-include ...) can be selected
+with `company-clang-set-prefix' or automatically through a custom
+`company-clang-prefix-guesser'.
+
+With Clang versions before 2.9, we have to save the buffer before
+performing completion. With Clang 2.9 and later, buffer contents are
+passed via standard input."
+ (interactive (list 'interactive))
+ (cl-case command
+ (interactive (company-begin-backend 'company-clang))
+ (init (when (memq major-mode company-clang-modes)
+ (unless company-clang-executable
+ (error "Company found no clang executable"))
+ (setq company-clang--version (company-clang-version))
+ (unless (company-clang--check-version
+ company-clang-required-version
+ company-clang-required-version)
+ (error "Company requires clang version %s"
+ company-clang-required-version))))
+ (prefix (and (memq major-mode company-clang-modes)
+ buffer-file-name
+ company-clang-executable
+ (not (company-in-string-or-comment))
+ (or (company-clang--prefix) 'stop)))
+ (candidates (cons :async
+ (lambda (cb) (company-clang--candidates arg cb))))
+ (meta (company-clang--meta arg))
+ (kind (company-clang--kind arg))
+ (annotation (company-clang--annotation arg))
+ (post-completion (let ((anno (company-clang--annotation arg)))
+ (when (and company-clang-insert-arguments anno)
+ (insert anno)
+ (if (string-match "\\`:[^:]" anno)
+ (company-template-objc-templatify anno)
+ (company-template-c-like-templatify
+ (concat arg anno))))))))
+
+(defun company-clang--kind (arg)
+ ;; XXX: Not very precise.
+ ;; E.g. it will say that an arg-less ObjC method is a variable (perhaps we
+ ;; could look around for brackets, etc, if there any actual users who's
+ ;; bothered by it).
+ ;; And we can't distinguish between local vars and struct fields.
+ ;; Or between keywords and macros.
+ (let ((meta (company-clang--meta arg)))
+ (cond
+ ((null meta) 'keyword)
+ ((string-match "(" meta)
+ (if (string-match-p (format "\\`%s *\\'" (regexp-quote arg))
+ (substring meta 0 (match-beginning 0)))
+ 'keyword ; Also macro, actually (no return type).
+ 'function))
+ (t 'variable))))
+
+(provide 'company-clang)
+;;; company-clang.el ends here
--- /dev/null
+;;; company-cmake.el --- company-mode completion backend for CMake
+
+;; Copyright (C) 2013-2015, 2017-2018, 2020 Free Software Foundation, Inc.
+
+;; Author: Chen Bin <chenbin DOT sh AT gmail>
+;; Version: 0.2
+
+;; This program is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+;;; Commentary:
+;;
+;; company-cmake offers completions for module names, variable names and
+;; commands used by CMake. And their descriptions.
+
+;;; Code:
+
+(require 'company)
+(require 'cl-lib)
+
+(defgroup company-cmake nil
+ "Completion backend for CMake."
+ :group 'company)
+
+(defcustom company-cmake-executable
+ (executable-find "cmake")
+ "Location of cmake executable."
+ :type 'file)
+
+(defvar company-cmake-executable-arguments
+ '("--help-command-list"
+ "--help-module-list"
+ "--help-property-list"
+ "--help-variable-list")
+ "The arguments we pass to cmake, separately.
+They affect which types of symbols we get completion candidates for.")
+
+(defvar company-cmake--completion-pattern
+ "^\\(%s[a-zA-Z0-9_<>]%s\\)$"
+ "Regexp to match the candidates.")
+
+(defvar company-cmake-modes '(cmake-mode)
+ "Major modes in which cmake may complete.")
+
+(defvar company-cmake--candidates-cache nil
+ "Cache for the raw candidates.")
+
+(defvar company-cmake--meta-command-cache nil
+ "Cache for command arguments to retrieve descriptions for the candidates.")
+
+(defun company-cmake--replace-tags (rlt)
+ (setq rlt (replace-regexp-in-string
+ "\\(.*?\\(IS_GNU\\)?\\)<LANG>\\(.*\\)"
+ (lambda (_match)
+ (mapconcat 'identity
+ (if (match-beginning 2)
+ '("\\1CXX\\3" "\\1C\\3" "\\1G77\\3")
+ '("\\1CXX\\3" "\\1C\\3" "\\1Fortran\\3"))
+ "\n"))
+ rlt t))
+ (setq rlt (replace-regexp-in-string
+ "\\(.*\\)<CONFIG>\\(.*\\)"
+ (mapconcat 'identity '("\\1DEBUG\\2" "\\1RELEASE\\2"
+ "\\1RELWITHDEBINFO\\2" "\\1MINSIZEREL\\2")
+ "\n")
+ rlt))
+ rlt)
+
+(defun company-cmake--fill-candidates-cache (arg)
+ "Fill candidates cache if needed."
+ (let (rlt)
+ (unless company-cmake--candidates-cache
+ (setq company-cmake--candidates-cache (make-hash-table :test 'equal)))
+
+ ;; If hash is empty, fill it.
+ (unless (gethash arg company-cmake--candidates-cache)
+ (with-temp-buffer
+ (let ((res (call-process company-cmake-executable nil t nil arg)))
+ (unless (zerop res)
+ (message "cmake executable exited with error=%d" res)))
+ (setq rlt (buffer-string)))
+ (setq rlt (company-cmake--replace-tags rlt))
+ (puthash arg rlt company-cmake--candidates-cache))
+ ))
+
+(defun company-cmake--parse (prefix content cmd)
+ (let ((start 0)
+ (pattern (format company-cmake--completion-pattern
+ (regexp-quote prefix)
+ (if (zerop (length prefix)) "+" "*")))
+ (lines (split-string content "\n"))
+ match
+ rlt)
+ (dolist (line lines)
+ (when (string-match pattern line)
+ (let ((match (match-string 1 line)))
+ (when match
+ (puthash match cmd company-cmake--meta-command-cache)
+ (push match rlt)))))
+ rlt))
+
+(defun company-cmake--candidates (prefix)
+ (let (results
+ cmd-opts
+ str)
+
+ (unless company-cmake--meta-command-cache
+ (setq company-cmake--meta-command-cache (make-hash-table :test 'equal)))
+
+ (dolist (arg company-cmake-executable-arguments)
+ (company-cmake--fill-candidates-cache arg)
+ (setq cmd-opts (replace-regexp-in-string "-list$" "" arg) )
+
+ (setq str (gethash arg company-cmake--candidates-cache))
+ (when str
+ (setq results (nconc results
+ (company-cmake--parse prefix str cmd-opts)))))
+ results))
+
+(defun company-cmake--unexpand-candidate (candidate)
+ (cond
+ ((string-match "^CMAKE_\\(C\\|CXX\\|Fortran\\)\\(_.*\\)$" candidate)
+ (setq candidate (concat "CMAKE_<LANG>" (match-string 2 candidate))))
+
+ ;; C flags
+ ((string-match "^\\(.*_\\)IS_GNU\\(C\\|CXX\\|G77\\)$" candidate)
+ (setq candidate (concat (match-string 1 candidate) "IS_GNU<LANG>")))
+
+ ;; C flags
+ ((string-match "^\\(.*_\\)OVERRIDE_\\(C\\|CXX\\|Fortran\\)$" candidate)
+ (setq candidate (concat (match-string 1 candidate) "OVERRIDE_<LANG>")))
+
+ ((string-match "^\\(.*\\)\\(_DEBUG\\|_RELEASE\\|_RELWITHDEBINFO\\|_MINSIZEREL\\)\\(.*\\)$" candidate)
+ (setq candidate (concat (match-string 1 candidate)
+ "_<CONFIG>"
+ (match-string 3 candidate)))))
+ candidate)
+
+(defun company-cmake--meta (candidate)
+ (let ((cmd-opts (gethash candidate company-cmake--meta-command-cache))
+ result)
+ (setq candidate (company-cmake--unexpand-candidate candidate))
+
+ ;; Don't cache the documentation of every candidate (command)
+ ;; Cache in this case will cost too much memory.
+ (with-temp-buffer
+ (call-process company-cmake-executable nil t nil cmd-opts candidate)
+ ;; Go to the third line, trim it and return the result.
+ ;; Tested with cmake 2.8.9.
+ (goto-char (point-min))
+ (forward-line 2)
+ (setq result (buffer-substring-no-properties (line-beginning-position)
+ (line-end-position)))
+ (setq result (replace-regexp-in-string "^[ \t\n\r]+" "" result))
+ result)))
+
+(defun company-cmake--doc-buffer (candidate)
+ (let ((cmd-opts (gethash candidate company-cmake--meta-command-cache)))
+
+ (setq candidate (company-cmake--unexpand-candidate candidate))
+ (with-temp-buffer
+ (call-process company-cmake-executable nil t nil cmd-opts candidate)
+ ;; Go to the third line, trim it and return the doc buffer.
+ ;; Tested with cmake 2.8.9.
+ (goto-char (point-min))
+ (forward-line 2)
+ (company-doc-buffer
+ (buffer-substring-no-properties (line-beginning-position)
+ (point-max))))))
+
+(defun company-cmake-prefix-dollar-brace-p ()
+ "Test if the current symbol follows ${."
+ (save-excursion
+ (skip-syntax-backward "w_")
+ (and (eq (char-before (point)) ?\{)
+ (eq (char-before (1- (point))) ?$))))
+
+(defun company-cmake (command &optional arg &rest ignored)
+ "`company-mode' completion backend for CMake.
+CMake is a cross-platform, open-source make system."
+ (interactive (list 'interactive))
+ (cl-case command
+ (interactive (company-begin-backend 'company-cmake))
+ (init (when (memq major-mode company-cmake-modes)
+ (unless company-cmake-executable
+ (error "Company found no cmake executable"))))
+ (prefix (and (memq major-mode company-cmake-modes)
+ (or (not (company-in-string-or-comment))
+ (company-cmake-prefix-dollar-brace-p))
+ (company-grab-symbol)))
+ (candidates (company-cmake--candidates arg))
+ (meta (company-cmake--meta arg))
+ (doc-buffer (company-cmake--doc-buffer arg))
+ ))
+
+(provide 'company-cmake)
+;;; company-cmake.el ends here
--- /dev/null
+;;; company-css.el --- company-mode completion backend for css-mode -*- lexical-binding: t -*-
+
+;; Copyright (C) 2009-2011, 2013-2015, 2018 Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+
+;;; Commentary:
+;;
+;; In Emacs >= 26, company-capf is used instead.
+
+;;; Code:
+
+(require 'company)
+(require 'cl-lib)
+
+(declare-function web-mode-language-at-pos "web-mode" (&optional pos))
+
+(defconst company-css-property-alist
+ ;; see http://www.w3.org/TR/CSS21/propidx.html
+ '(("azimuth" angle "left-side" "far-left" "left" "center-left" "center"
+ "center-right" "right" "far-right" "right-side" "behind" "leftwards"
+ "rightwards")
+ ("background" background-color background-image background-repeat
+ background-attachment background-position
+ background-clip background-origin background-size)
+ ("background-attachment" "scroll" "fixed")
+ ("background-color" color "transparent")
+ ("background-image" uri "none")
+ ("background-position" percentage length "left" "center" "right" percentage
+ length "top" "center" "bottom" "left" "center" "right" "top" "center"
+ "bottom")
+ ("background-repeat" "repeat" "repeat-x" "repeat-y" "no-repeat")
+ ("border" border-width border-style border-color)
+ ("border-bottom" border)
+ ("border-bottom-color" border-color)
+ ("border-bottom-style" border-style)
+ ("border-bottom-width" border-width)
+ ("border-collapse" "collapse" "separate")
+ ("border-color" color "transparent")
+ ("border-left" border)
+ ("border-left-color" border-color)
+ ("border-left-style" border-style)
+ ("border-left-width" border-width)
+ ("border-right" border)
+ ("border-right-color" border-color)
+ ("border-right-style" border-style)
+ ("border-right-width" border-width)
+ ("border-spacing" length length)
+ ("border-style" border-style)
+ ("border-top" border)
+ ("border-top-color" border-color)
+ ("border-top-style" border-style)
+ ("border-top-width" border-width)
+ ("border-width" border-width)
+ ("bottom" length percentage "auto")
+ ("caption-side" "top" "bottom")
+ ("clear" "none" "left" "right" "both")
+ ("clip" shape "auto")
+ ("color" color)
+ ("content" "normal" "none" string uri counter "attr()" "open-quote"
+ "close-quote" "no-open-quote" "no-close-quote")
+ ("counter-increment" identifier integer "none")
+ ("counter-reset" identifier integer "none")
+ ("cue" cue-before cue-after)
+ ("cue-after" uri "none")
+ ("cue-before" uri "none")
+ ("cursor" uri "*" "auto" "crosshair" "default" "pointer" "move" "e-resize"
+ "ne-resize" "nw-resize" "n-resize" "se-resize" "sw-resize" "s-resize"
+ "w-resize" "text" "wait" "help" "progress")
+ ("direction" "ltr" "rtl")
+ ("display" "inline" "block" "list-item" "run-in" "inline-block" "table"
+ "inline-table" "table-row-group" "table-header-group" "table-footer-group"
+ "table-row" "table-column-group" "table-column" "table-cell"
+ "table-caption" "none")
+ ("elevation" angle "below" "level" "above" "higher" "lower")
+ ("empty-cells" "show" "hide")
+ ("float" "left" "right" "none")
+ ("font" font-style font-weight font-size "/" line-height
+ font-family "caption" "icon" "menu" "message-box" "small-caption"
+ "status-bar" "normal" "small-caps"
+ ;; CSS3
+ font-stretch)
+ ("font-family" family-name generic-family)
+ ("font-size" absolute-size relative-size length percentage)
+ ("font-style" "normal" "italic" "oblique")
+ ("font-weight" "normal" "bold" "bolder" "lighter" "100" "200" "300" "400"
+ "500" "600" "700" "800" "900")
+ ("height" length percentage "auto")
+ ("left" length percentage "auto")
+ ("letter-spacing" "normal" length)
+ ("line-height" "normal" number length percentage)
+ ("list-style" list-style-type list-style-position list-style-image)
+ ("list-style-image" uri "none")
+ ("list-style-position" "inside" "outside")
+ ("list-style-type" "disc" "circle" "square" "decimal" "decimal-leading-zero"
+ "lower-roman" "upper-roman" "lower-greek" "lower-latin" "upper-latin"
+ "armenian" "georgian" "lower-alpha" "upper-alpha" "none")
+ ("margin" margin-width)
+ ("margin-bottom" margin-width)
+ ("margin-left" margin-width)
+ ("margin-right" margin-width)
+ ("margin-top" margin-width)
+ ("max-height" length percentage "none")
+ ("max-width" length percentage "none")
+ ("min-height" length percentage)
+ ("min-width" length percentage)
+ ("orphans" integer)
+ ("outline" outline-color outline-style outline-width)
+ ("outline-color" color "invert")
+ ("outline-style" border-style)
+ ("outline-width" border-width)
+ ("overflow" "visible" "hidden" "scroll" "auto"
+ ;; CSS3:
+ "no-display" "no-content")
+ ("padding" padding-width)
+ ("padding-bottom" padding-width)
+ ("padding-left" padding-width)
+ ("padding-right" padding-width)
+ ("padding-top" padding-width)
+ ("page-break-after" "auto" "always" "avoid" "left" "right")
+ ("page-break-before" "auto" "always" "avoid" "left" "right")
+ ("page-break-inside" "avoid" "auto")
+ ("pause" time percentage)
+ ("pause-after" time percentage)
+ ("pause-before" time percentage)
+ ("pitch" frequency "x-low" "low" "medium" "high" "x-high")
+ ("pitch-range" number)
+ ("play-during" uri "mix" "repeat" "auto" "none")
+ ("position" "static" "relative" "absolute" "fixed")
+ ("quotes" string string "none")
+ ("richness" number)
+ ("right" length percentage "auto")
+ ("speak" "normal" "none" "spell-out")
+ ("speak-header" "once" "always")
+ ("speak-numeral" "digits" "continuous")
+ ("speak-punctuation" "code" "none")
+ ("speech-rate" number "x-slow" "slow" "medium" "fast" "x-fast" "faster"
+ "slower")
+ ("stress" number)
+ ("table-layout" "auto" "fixed")
+ ("text-align" "left" "right" "center" "justify")
+ ("text-indent" length percentage)
+ ("text-transform" "capitalize" "uppercase" "lowercase" "none")
+ ("top" length percentage "auto")
+ ("unicode-bidi" "normal" "embed" "bidi-override")
+ ("vertical-align" "baseline" "sub" "super" "top" "text-top" "middle"
+ "bottom" "text-bottom" percentage length)
+ ("visibility" "visible" "hidden" "collapse")
+ ("voice-family" specific-voice generic-voice "*" specific-voice
+ generic-voice)
+ ("volume" number percentage "silent" "x-soft" "soft" "medium" "loud"
+ "x-loud")
+ ("white-space" "normal" "pre" "nowrap" "pre-wrap" "pre-line")
+ ("widows" integer)
+ ("width" length percentage "auto")
+ ("word-spacing" "normal" length)
+ ("z-index" "auto" integer)
+ ;; CSS3
+ ("align-content" align-stretch "space-between" "space-around")
+ ("align-items" align-stretch "baseline")
+ ("align-self" align-items "auto")
+ ("animation" animation-name animation-duration animation-timing-function
+ animation-delay animation-iteration-count animation-direction
+ animation-fill-mode)
+ ("animation-delay" time)
+ ("animation-direction" "normal" "reverse" "alternate" "alternate-reverse")
+ ("animation-duration" time)
+ ("animation-fill-mode" "none" "forwards" "backwards" "both")
+ ("animation-iteration-count" integer "infinite")
+ ("animation-name" "none")
+ ("animation-play-state" "paused" "running")
+ ("animation-timing-function" transition-timing-function
+ "step-start" "step-end" "steps(,)")
+ ("backface-visibility" "visible" "hidden")
+ ("background-clip" background-origin)
+ ("background-origin" "border-box" "padding-box" "content-box")
+ ("background-size" length percentage "auto" "cover" "contain")
+ ("border-image" border-image-outset border-image-repeat border-image-source
+ border-image-slice border-image-width)
+ ("border-image-outset" length)
+ ("border-image-repeat" "stretch" "repeat" "round" "space")
+ ("border-image-source" uri "none")
+ ("border-image-slice" length)
+ ("border-image-width" length percentage)
+ ("border-radius" length)
+ ("border-top-left-radius" length)
+ ("border-top-right-radius" length)
+ ("border-bottom-left-radius" length)
+ ("border-bottom-right-radius" length)
+ ("box-decoration-break" "slice" "clone")
+ ("box-shadow" length color)
+ ("box-sizing" "content-box" "border-box")
+ ("break-after" "auto" "always" "avoid" "left" "right" "page" "column"
+ "avoid-page" "avoid-column")
+ ("break-before" break-after)
+ ("break-inside" "avoid" "auto")
+ ("columns" column-width column-count)
+ ("column-count" integer)
+ ("column-fill" "auto" "balance")
+ ("column-gap" length "normal")
+ ("column-rule" column-rule-width column-rule-style column-rule-color)
+ ("column-rule-color" color)
+ ("column-rule-style" border-style)
+ ("column-rule-width" border-width)
+ ("column-span" "all" "none")
+ ("column-width" length "auto")
+ ("filter" url "blur()" "brightness()" "contrast()" "drop-shadow()"
+ "grayscale()" "hue-rotate()" "invert()" "opacity()" "saturate()" "sepia()")
+ ("flex" flex-grow flex-shrink flex-basis)
+ ("flex-basis" percentage length "auto")
+ ("flex-direction" "row" "row-reverse" "column" "column-reverse")
+ ("flex-flow" flex-direction flex-wrap)
+ ("flex-grow" number)
+ ("flex-shrink" number)
+ ("flex-wrap" "nowrap" "wrap" "wrap-reverse")
+ ("font-feature-setting" normal string number)
+ ("font-kerning" "auto" "normal" "none")
+ ("font-language-override" "normal" string)
+ ("font-size-adjust" "none" number)
+ ("font-stretch" "normal" "ultra-condensed" "extra-condensed" "condensed"
+ "semi-condensed" "semi-expanded" "expanded" "extra-expanded" "ultra-expanded")
+ ("font-synthesis" "none" "weight" "style")
+ ("font-variant" font-variant-alternates font-variant-caps
+ font-variant-east-asian font-variant-ligatures font-variant-numeric
+ font-variant-position)
+ ("font-variant-alternates" "normal" "historical-forms" "stylistic()"
+ "styleset()" "character-variant()" "swash()" "ornaments()" "annotation()")
+ ("font-variant-caps" "normal" "small-caps" "all-small-caps" "petite-caps"
+ "all-petite-caps" "unicase" "titling-caps")
+ ("font-variant-east-asian" "jis78" "jis83" "jis90" "jis04" "simplified"
+ "traditional" "full-width" "proportional-width" "ruby")
+ ("font-variant-ligatures" "normal" "none" "common-ligatures"
+ "no-common-ligatures" "discretionary-ligatures" "no-discretionary-ligatures"
+ "historical-ligatures" "no-historical-ligatures" "contextual" "no-contextual")
+ ("font-variant-numeric" "normal" "ordinal" "slashed-zero"
+ "lining-nums" "oldstyle-nums" "proportional-nums" "tabular-nums"
+ "diagonal-fractions" "stacked-fractions")
+ ("font-variant-position" "normal" "sub" "super")
+ ("hyphens" "none" "manual" "auto")
+ ("justify-content" align-common "space-between" "space-around")
+ ("line-break" "auto" "loose" "normal" "strict")
+ ("marquee-direction" "forward" "reverse")
+ ("marquee-play-count" integer "infinite")
+ ("marquee-speed" "slow" "normal" "fast")
+ ("marquee-style" "scroll" "slide" "alternate")
+ ("opacity" number)
+ ("order" number)
+ ("outline-offset" length)
+ ("overflow-x" overflow)
+ ("overflow-y" overflow)
+ ("overflow-style" "auto" "marquee-line" "marquee-block")
+ ("overflow-wrap" "normal" "break-word")
+ ("perspective" "none" length)
+ ("perspective-origin" percentage length "left" "center" "right" "top" "bottom")
+ ("resize" "none" "both" "horizontal" "vertical")
+ ("tab-size" integer length)
+ ("text-align-last" "auto" "start" "end" "left" "right" "center" "justify")
+ ("text-decoration" text-decoration-color text-decoration-line text-decoration-style)
+ ("text-decoration-color" color)
+ ("text-decoration-line" "none" "underline" "overline" "line-through" "blink")
+ ("text-decoration-style" "solid" "double" "dotted" "dashed" "wavy")
+ ("text-overflow" "clip" "ellipsis")
+ ("text-shadow" color length)
+ ("text-underline-position" "auto" "under" "left" "right")
+ ("transform" "matrix(,,,,,)" "translate(,)" "translateX()" "translateY()"
+ "scale()" "scaleX()" "scaleY()" "rotate()" "skewX()" "skewY()" "none")
+ ("transform-origin" perspective-origin)
+ ("transform-style" "flat" "preserve-3d")
+ ("transition" transition-property transition-duration
+ transition-timing-function transition-delay)
+ ("transition-delay" time)
+ ("transition-duration" time)
+ ("transition-timing-function"
+ "ease" "linear" "ease-in" "ease-out" "ease-in-out" "cubic-bezier(,,,)")
+ ("transition-property" "none" "all" identifier)
+ ("word-wrap" overflow-wrap)
+ ("word-break" "normal" "break-all" "keep-all"))
+ "A list of CSS properties and their possible values.")
+
+(defconst company-css-value-classes
+ '((absolute-size "xx-small" "x-small" "small" "medium" "large" "x-large"
+ "xx-large")
+ (align-common "flex-start" "flex-end" "center")
+ (align-stretch align-common "stretch")
+ (border-style "none" "hidden" "dotted" "dashed" "solid" "double" "groove"
+ "ridge" "inset" "outset")
+ (border-width "thick" "medium" "thin")
+ (color "aqua" "black" "blue" "fuchsia" "gray" "green" "lime" "maroon" "navy"
+ "olive" "orange" "purple" "red" "silver" "teal" "white" "yellow")
+ (counter "counter(,)")
+ (family-name "Courier" "Helvetica" "Times")
+ (generic-family "serif" "sans-serif" "cursive" "fantasy" "monospace")
+ (generic-voice "male" "female" "child")
+ (margin-width "auto") ;; length percentage
+ (relative-size "larger" "smaller")
+ (shape "rect(,,,)")
+ (uri "url()"))
+ "A list of CSS property value classes and their contents.")
+;; missing, because not completable
+;; <angle><frequency><identifier><integer><length><number><padding-width>
+;; <percentage><specific-voice><string><time><uri>
+
+(defconst company-css-html-tags
+ '("a" "abbr" "acronym" "address" "applet" "area" "b" "base" "basefont" "bdo"
+ "big" "blockquote" "body" "br" "button" "caption" "center" "cite" "code"
+ "col" "colgroup" "dd" "del" "dfn" "dir" "div" "dl" "dt" "em" "fieldset"
+ "font" "form" "frame" "frameset" "h1" "h2" "h3" "h4" "h5" "h6" "head" "hr"
+ "html" "i" "iframe" "img" "input" "ins" "isindex" "kbd" "label" "legend"
+ "li" "link" "map" "menu" "meta" "noframes" "noscript" "object" "ol"
+ "optgroup" "option" "p" "param" "pre" "q" "s" "samp" "script" "select"
+ "small" "span" "strike" "strong" "style" "sub" "sup" "table" "tbody" "td"
+ "textarea" "tfoot" "th" "thead" "title" "tr" "tt" "u" "ul" "var"
+ ;; HTML5
+ "section" "article" "aside" "header" "footer" "nav" "figure" "figcaption"
+ "time" "mark" "main")
+ "A list of HTML tags for use in CSS completion.")
+
+(defconst company-css-pseudo-classes
+ '("active" "after" "before" "first" "first-child" "first-letter" "first-line"
+ "focus" "hover" "lang" "left" "link" "right" "visited")
+ "Identifiers for CSS pseudo-elements and pseudo-classes.")
+
+(defconst company-css-property-cache (make-hash-table :size 115 :test 'equal))
+
+(defun company-css-property-values (attribute)
+ "Access the `company-css-property-alist' cached and flattened."
+ (or (gethash attribute company-css-property-cache)
+ (let (results)
+ (dolist (value (cdr (assoc attribute company-css-property-alist)))
+ (if (symbolp value)
+ (dolist (child (or (cdr (assoc value company-css-value-classes))
+ (company-css-property-values
+ (symbol-name value))))
+ (push child results))
+ (push value results)))
+ (setq results (sort results 'string<))
+ (puthash attribute
+ (if (fboundp 'delete-consecutive-dups)
+ (delete-consecutive-dups results)
+ (delete-dups results))
+ company-css-property-cache)
+ results)))
+
+;;; bracket detection
+
+(defconst company-css-braces-syntax-table
+ (let ((table (make-syntax-table)))
+ (setf (aref table ?{) '(4 . 125))
+ (setf (aref table ?}) '(5 . 123))
+ table)
+ "A syntax table giving { and } paren syntax.")
+
+(defun company-css-inside-braces-p ()
+ "Return non-nil, if point is within matched { and }."
+ (ignore-errors
+ (with-syntax-table company-css-braces-syntax-table
+ (let ((parse-sexp-ignore-comments t))
+ (scan-lists (point) -1 1)))))
+
+;;; tags
+(defconst company-css-tag-regexp
+ (concat "\\(?:\\`\\|}\\)[[:space:]]*"
+ ;; multiple
+ "\\(?:"
+ ;; previous tags:
+ "\\(?:#\\|\\_<[[:alpha:]]\\)[[:alnum:]-#]*\\(?:\\[[^]]*\\]\\)?"
+ ;; space or selectors
+ "\\(?:[[:space:]]+\\|[[:space:]]*[+,>][[:space:]]*\\)"
+ "\\)*"
+ "\\(\\(?:#\\|\\_<[[:alpha:]]\\)\\(?:[[:alnum:]-#]*\\_>\\)?\\_>\\|\\)"
+ "\\=")
+ "A regular expression matching CSS tags.")
+
+;;; pseudo id
+(defconst company-css-pseudo-regexp
+ (concat "\\(?:\\`\\|}\\)[[:space:]]*"
+ ;; multiple
+ "\\(?:"
+ ;; previous tags:
+ "\\(?:#\\|\\_<[[:alpha:]]\\)[[:alnum:]-#]*\\(?:\\[[^]]*\\]\\)?"
+ ;; space or delimiters
+ "\\(?:[[:space:]]+\\|[[:space:]]*[+,>][[:space:]]*\\)"
+ "\\)*"
+ "\\(?:\\(?:\\#\\|\\_<[[:alpha:]]\\)[[:alnum:]-#]*\\):"
+ "\\([[:alpha:]-]+\\_>\\|\\)\\_>\\=")
+ "A regular expression matching CSS pseudo classes.")
+
+;;; properties
+
+(defun company-css-grab-property ()
+ "Return the CSS property before point, if any.
+Returns \"\" if no property found, but feasible at this position."
+ (when (company-css-inside-braces-p)
+ (company-grab-symbol)))
+
+;;; values
+(defconst company-css-property-value-regexp
+ "\\_<\\([[:alpha:]-]+\\):\\(?:[^{};]*[[:space:]]+\\)?\\([^{};]*\\_>\\|\\)\\="
+ "A regular expression matching CSS tags.")
+
+;;;###autoload
+(defun company-css (command &optional arg &rest _ignored)
+ "`company-mode' completion backend for `css-mode'."
+ (interactive (list 'interactive))
+ (cl-case command
+ (interactive (company-begin-backend 'company-css))
+ (prefix (and (or (derived-mode-p 'css-mode)
+ (and (derived-mode-p 'web-mode)
+ (string= (web-mode-language-at-pos) "css")))
+ (or (company-grab company-css-tag-regexp 1)
+ (company-grab company-css-pseudo-regexp 1)
+ (company-grab company-css-property-value-regexp 2
+ (line-beginning-position))
+ (company-css-grab-property))))
+ (candidates
+ (cond
+ ((company-grab company-css-tag-regexp 1)
+ (all-completions arg company-css-html-tags))
+ ((company-grab company-css-pseudo-regexp 1)
+ (all-completions arg company-css-pseudo-classes))
+ ((company-grab company-css-property-value-regexp 2
+ (line-beginning-position))
+ (all-completions arg
+ (company-css-property-values
+ (company-grab company-css-property-value-regexp 1))))
+ ((company-css-grab-property)
+ (all-completions arg company-css-property-alist))))
+ (sorted t)))
+
+(provide 'company-css)
+;;; company-css.el ends here
--- /dev/null
+;;; company-dabbrev-code.el --- dabbrev-like company-mode backend for code -*- lexical-binding: t -*-
+
+;; Copyright (C) 2009-2011, 2013-2016, 2021 Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+
+;;; Code:
+
+(require 'company)
+(require 'company-dabbrev)
+(require 'cl-lib)
+
+(defgroup company-dabbrev-code nil
+ "dabbrev-like completion backend for code."
+ :group 'company)
+
+(defcustom company-dabbrev-code-modes
+ '(prog-mode
+ batch-file-mode csharp-mode css-mode erlang-mode haskell-mode jde-mode
+ lua-mode python-mode)
+ "Modes that use `company-dabbrev-code'.
+In all these modes (and their derivatives) `company-dabbrev-code' will
+complete only symbols, not text in comments or strings. In other modes
+`company-dabbrev-code' will pass control to other backends
+\(e.g. `company-dabbrev'\). Value t means complete in all modes."
+ :type '(choice (repeat :tag "Some modes" (symbol :tag "Major mode"))
+ (const :tag "All modes" t)))
+
+(defcustom company-dabbrev-code-other-buffers t
+ "Determines whether `company-dabbrev-code' should search other buffers.
+If `all', search all other buffers, except the ignored ones. If t, search
+buffers with the same major mode. If `code', search all buffers with major
+modes in `company-dabbrev-code-modes', or derived from one of them. See
+also `company-dabbrev-code-time-limit'."
+ :type '(choice (const :tag "Off" nil)
+ (const :tag "Same major mode" t)
+ (const :tag "Code major modes" code)
+ (const :tag "All" all)))
+
+(defcustom company-dabbrev-code-time-limit .1
+ "Determines how long `company-dabbrev-code' should look for matches."
+ :type '(choice (const :tag "Off" nil)
+ (number :tag "Seconds")))
+
+(defcustom company-dabbrev-code-everywhere nil
+ "Non-nil to offer completions in comments and strings."
+ :type 'boolean)
+
+(defcustom company-dabbrev-code-ignore-case nil
+ "Non-nil to ignore case when collecting completion candidates."
+ :type 'boolean)
+
+(defun company-dabbrev-code--make-regexp (prefix)
+ (concat "\\_<" (if (equal prefix "")
+ "\\([a-zA-Z]\\|\\s_\\)"
+ (regexp-quote prefix))
+ "\\(\\sw\\|\\s_\\)*\\_>"))
+
+;;;###autoload
+(defun company-dabbrev-code (command &optional arg &rest _ignored)
+ "dabbrev-like `company-mode' backend for code.
+The backend looks for all symbols in the current buffer that aren't in
+comments or strings."
+ (interactive (list 'interactive))
+ (cl-case command
+ (interactive (company-begin-backend 'company-dabbrev-code))
+ (prefix (and (or (eq t company-dabbrev-code-modes)
+ (apply #'derived-mode-p company-dabbrev-code-modes))
+ (or company-dabbrev-code-everywhere
+ (not (company-in-string-or-comment)))
+ (or (company-grab-symbol) 'stop)))
+ (candidates (let ((case-fold-search company-dabbrev-code-ignore-case))
+ (company-dabbrev--search
+ (company-dabbrev-code--make-regexp arg)
+ company-dabbrev-code-time-limit
+ (pcase company-dabbrev-code-other-buffers
+ (`t (list major-mode))
+ (`code company-dabbrev-code-modes)
+ (`all `all))
+ (not company-dabbrev-code-everywhere))))
+ (kind 'text)
+ (ignore-case company-dabbrev-code-ignore-case)
+ (duplicates t)))
+
+(provide 'company-dabbrev-code)
+;;; company-dabbrev-code.el ends here
--- /dev/null
+;;; company-dabbrev.el --- dabbrev-like company-mode completion backend -*- lexical-binding: t -*-
+
+;; Copyright (C) 2009-2011, 2013-2018, 2021 Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+
+;;; Code:
+
+(require 'company)
+(require 'cl-lib)
+
+(defgroup company-dabbrev nil
+ "dabbrev-like completion backend."
+ :group 'company)
+
+(defcustom company-dabbrev-other-buffers 'all
+ "Determines whether `company-dabbrev' should search other buffers.
+If `all', search all other buffers, except the ignored ones. If t, search
+buffers with the same major mode. See also `company-dabbrev-time-limit'."
+ :type '(choice (const :tag "Off" nil)
+ (const :tag "Same major mode" t)
+ (const :tag "All" all)))
+
+(defcustom company-dabbrev-ignore-buffers "\\`[ *]"
+ "Regexp matching the names of buffers to ignore.
+Or a function that returns non-nil for such buffers."
+ :type '(choice (regexp :tag "Regexp")
+ (function :tag "Predicate"))
+ :package-version '(company . "0.9.0"))
+
+(defcustom company-dabbrev-time-limit .1
+ "Determines how many seconds `company-dabbrev' should look for matches."
+ :type '(choice (const :tag "Off" nil)
+ (number :tag "Seconds")))
+
+(defcustom company-dabbrev-char-regexp "\\sw"
+ "A regular expression matching the characters `company-dabbrev' looks for."
+ :type 'regexp)
+
+(defcustom company-dabbrev-ignore-case 'keep-prefix
+ "Non-nil to ignore case when collecting completion candidates.
+When it's `keep-prefix', the text before point will remain unchanged after
+candidate is inserted, even some of its characters have different case."
+ :type '(choice
+ (const :tag "Don't ignore case" nil)
+ (const :tag "Ignore case" t)
+ (const :tag "Keep case before point" keep-prefix)))
+
+(defcustom company-dabbrev-downcase 'case-replace
+ "Whether to downcase the returned candidates.
+
+The value of nil means keep them as-is.
+`case-replace' means use the value of `case-replace'.
+Any other value means downcase.
+
+If you set this value to nil, you may also want to set
+`company-dabbrev-ignore-case' to any value other than `keep-prefix'."
+ :type '(choice
+ (const :tag "Keep as-is" nil)
+ (const :tag "Downcase" t)
+ (const :tag "Use case-replace" case-replace)))
+
+(defcustom company-dabbrev-minimum-length 4
+ "The minimum length for the completion candidate to be included.
+This variable affects both `company-dabbrev' and `company-dabbrev-code'."
+ :type 'integer
+ :package-version '(company . "0.8.3"))
+
+(defcustom company-dabbrev-ignore-invisible nil
+ "Non-nil to skip invisible text."
+ :type 'boolean
+ :package-version '(company . "0.9.0"))
+
+(defmacro company-dabbrev--time-limit-while (test start limit freq &rest body)
+ (declare (indent 3) (debug t))
+ `(let ((company-time-limit-while-counter 0))
+ (catch 'done
+ (while ,test
+ ,@body
+ (and ,limit
+ (= (cl-incf company-time-limit-while-counter) ,freq)
+ (setq company-time-limit-while-counter 0)
+ (> (float-time (time-since ,start)) ,limit)
+ (throw 'done 'company-time-out))))))
+
+(defun company-dabbrev--make-regexp ()
+ (concat "\\(?:" company-dabbrev-char-regexp "\\)+"))
+
+(defun company-dabbrev--search-buffer (regexp pos symbols start limit
+ ignore-comments)
+ (save-excursion
+ (cl-labels ((maybe-collect-match
+ ()
+ (let ((match (match-string-no-properties 0)))
+ (when (and (>= (length match) company-dabbrev-minimum-length)
+ (not (and company-dabbrev-ignore-invisible
+ (invisible-p (match-beginning 0)))))
+ (push match symbols)))))
+ (goto-char (if pos (1- pos) (point-min)))
+ ;; Search before pos.
+ (let ((tmp-end (point)))
+ (company-dabbrev--time-limit-while (and (not (input-pending-p))
+ (> tmp-end (point-min)))
+ start limit 1
+ (ignore-errors
+ (forward-char -10000))
+ (forward-line 0)
+ (save-excursion
+ ;; Before, we used backward search, but it matches non-greedily, and
+ ;; that forced us to use the "beginning/end of word" anchors in
+ ;; `company-dabbrev--make-regexp'. It's also about 2x slower.
+ (while (and (not (input-pending-p))
+ (re-search-forward regexp tmp-end t))
+ (if (and ignore-comments (save-match-data (company-in-string-or-comment)))
+ (re-search-forward "\\s>\\|\\s!\\|\\s\"" tmp-end t)
+ (maybe-collect-match))))
+ (setq tmp-end (point))))
+ (goto-char (or pos (point-min)))
+ ;; Search after pos.
+ (company-dabbrev--time-limit-while (and (not (input-pending-p))
+ (re-search-forward regexp nil t))
+ start limit 25
+ (if (and ignore-comments (save-match-data (company-in-string-or-comment)))
+ (re-search-forward "\\s>\\|\\s!\\|\\s\"" nil t)
+ (maybe-collect-match)))
+ symbols)))
+
+(defun company-dabbrev--search (regexp &optional limit other-buffer-modes
+ ignore-comments)
+ (let* ((start (current-time))
+ (symbols (company-dabbrev--search-buffer regexp (point) nil start limit
+ ignore-comments)))
+ (when other-buffer-modes
+ (cl-dolist (buffer (delq (current-buffer) (buffer-list)))
+ (unless (if (stringp company-dabbrev-ignore-buffers)
+ (string-match-p company-dabbrev-ignore-buffers
+ (buffer-name buffer))
+ (funcall company-dabbrev-ignore-buffers buffer))
+ (with-current-buffer buffer
+ (when (or (eq other-buffer-modes 'all)
+ (apply #'derived-mode-p other-buffer-modes))
+ (setq symbols
+ (company-dabbrev--search-buffer regexp nil symbols start
+ limit ignore-comments)))))
+ (and limit
+ (> (float-time (time-since start)) limit)
+ (cl-return))))
+ symbols))
+
+(defun company-dabbrev--prefix ()
+ ;; Not in the middle of a word.
+ (unless (looking-at company-dabbrev-char-regexp)
+ ;; Emacs can't do greedy backward-search.
+ (company-grab-line (format "\\(?:^\\| \\)[^ ]*?\\(\\(?:%s\\)*\\)"
+ company-dabbrev-char-regexp)
+ 1)))
+
+(defun company-dabbrev--filter (prefix candidates)
+ (let ((completion-ignore-case company-dabbrev-ignore-case))
+ (all-completions prefix candidates)))
+
+;;;###autoload
+(defun company-dabbrev (command &optional arg &rest _ignored)
+ "dabbrev-like `company-mode' completion backend."
+ (interactive (list 'interactive))
+ (cl-case command
+ (interactive (company-begin-backend 'company-dabbrev))
+ (prefix (company-dabbrev--prefix))
+ (candidates
+ (let* ((case-fold-search company-dabbrev-ignore-case)
+ (words (company-dabbrev--search (company-dabbrev--make-regexp)
+ company-dabbrev-time-limit
+ (pcase company-dabbrev-other-buffers
+ (`t (list major-mode))
+ (`all `all))))
+ (downcase-p (if (eq company-dabbrev-downcase 'case-replace)
+ case-replace
+ company-dabbrev-downcase)))
+ (setq words (company-dabbrev--filter arg words))
+ (if downcase-p
+ (mapcar 'downcase words)
+ words)))
+ (kind 'text)
+ (ignore-case company-dabbrev-ignore-case)
+ (duplicates t)))
+
+(provide 'company-dabbrev)
+;;; company-dabbrev.el ends here
--- /dev/null
+;;; company-elisp.el --- company-mode completion backend for Emacs Lisp -*- lexical-binding: t -*-
+
+;; Copyright (C) 2009-2015, 2017, 2020 Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+;; In newer versions of Emacs, company-capf is used instead.
+
+;;; Code:
+
+(require 'company)
+(require 'cl-lib)
+(require 'help-mode)
+(require 'find-func)
+
+(defgroup company-elisp nil
+ "Completion backend for Emacs Lisp."
+ :group 'company)
+
+(defcustom company-elisp-detect-function-context t
+ "If enabled, offer Lisp functions only in appropriate contexts.
+Functions are offered for completion only after \\=' and \(."
+ :type '(choice (const :tag "Off" nil)
+ (const :tag "On" t)))
+
+(defcustom company-elisp-show-locals-first t
+ "If enabled, locally bound variables and functions are displayed
+first in the candidates list."
+ :type '(choice (const :tag "Off" nil)
+ (const :tag "On" t)))
+
+(defun company-elisp--prefix ()
+ (let ((prefix (company-grab-symbol)))
+ (if prefix
+ (when (if (company-in-string-or-comment)
+ (= (char-before (- (point) (length prefix))) ?`)
+ (company-elisp--should-complete))
+ prefix)
+ 'stop)))
+
+(defun company-elisp--predicate (symbol)
+ (or (boundp symbol)
+ (fboundp symbol)
+ (facep symbol)
+ (featurep symbol)))
+
+(defun company-elisp--fns-regexp (&rest names)
+ (concat "\\_<\\(?:cl-\\)?" (regexp-opt names) "\\*?\\_>"))
+
+(defvar company-elisp-parse-limit 30)
+(defvar company-elisp-parse-depth 100)
+
+(defvar company-elisp-defun-names '("defun" "defmacro" "defsubst"))
+
+(defvar company-elisp-var-binding-regexp
+ (apply #'company-elisp--fns-regexp "let" "lambda" "lexical-let"
+ company-elisp-defun-names)
+ "Regular expression matching head of a multiple variable bindings form.")
+
+(defvar company-elisp-var-binding-regexp-1
+ (company-elisp--fns-regexp "dolist" "dotimes")
+ "Regular expression matching head of a form with one variable binding.")
+
+(defvar company-elisp-fun-binding-regexp
+ (company-elisp--fns-regexp "flet" "labels")
+ "Regular expression matching head of a function bindings form.")
+
+(defvar company-elisp-defuns-regexp
+ (concat "([ \t\n]*"
+ (apply #'company-elisp--fns-regexp company-elisp-defun-names)))
+
+(defun company-elisp--should-complete ()
+ (let ((start (point))
+ (depth (car (syntax-ppss))))
+ (not
+ (when (> depth 0)
+ (save-excursion
+ (up-list (- depth))
+ (when (looking-at company-elisp-defuns-regexp)
+ (forward-char)
+ (forward-sexp 1)
+ (unless (= (point) start)
+ (condition-case nil
+ (let ((args-end (scan-sexps (point) 2)))
+ (or (null args-end)
+ (> args-end start)))
+ (scan-error
+ t)))))))))
+
+(defun company-elisp--locals (prefix functions-p)
+ (let ((regexp (concat "[ \t\n]*\\(\\_<" (regexp-quote prefix)
+ "\\(?:\\sw\\|\\s_\\)*\\_>\\)"))
+ (pos (point))
+ res)
+ (condition-case nil
+ (save-excursion
+ (dotimes (_ company-elisp-parse-depth)
+ (up-list -1)
+ (save-excursion
+ (when (eq (char-after) ?\()
+ (forward-char 1)
+ (when (ignore-errors
+ (save-excursion (forward-list)
+ (<= (point) pos)))
+ (skip-chars-forward " \t\n")
+ (cond
+ ((looking-at (if functions-p
+ company-elisp-fun-binding-regexp
+ company-elisp-var-binding-regexp))
+ (down-list 1)
+ (condition-case nil
+ (dotimes (_ company-elisp-parse-limit)
+ (save-excursion
+ (when (looking-at "[ \t\n]*(")
+ (down-list 1))
+ (when (looking-at regexp)
+ (cl-pushnew (match-string-no-properties 1) res)))
+ (forward-sexp))
+ (scan-error nil)))
+ ((unless functions-p
+ (looking-at company-elisp-var-binding-regexp-1))
+ (down-list 1)
+ (when (looking-at regexp)
+ (cl-pushnew (match-string-no-properties 1) res)))))))))
+ (scan-error nil))
+ res))
+
+(defun company-elisp-candidates (prefix)
+ (let* ((predicate (company-elisp--candidates-predicate prefix))
+ (locals (company-elisp--locals prefix (eq predicate 'fboundp)))
+ (globals (company-elisp--globals prefix predicate))
+ (locals (cl-loop for local in locals
+ when (not (member local globals))
+ collect local)))
+ (if company-elisp-show-locals-first
+ (append (sort locals 'string<)
+ (sort globals 'string<))
+ (append locals globals))))
+
+(defun company-elisp--globals (prefix predicate)
+ (all-completions prefix obarray predicate))
+
+(defun company-elisp--candidates-predicate (prefix)
+ (let* ((completion-ignore-case nil)
+ (beg (- (point) (length prefix)))
+ (before (char-before beg)))
+ (if (and company-elisp-detect-function-context
+ (not (memq before '(?' ?`))))
+ (if (and (eq before ?\()
+ (not
+ (save-excursion
+ (ignore-errors
+ (goto-char (1- beg))
+ (or (company-elisp--before-binding-varlist-p)
+ (progn
+ (up-list -1)
+ (company-elisp--before-binding-varlist-p)))))))
+ 'fboundp
+ 'boundp)
+ 'company-elisp--predicate)))
+
+(defun company-elisp--before-binding-varlist-p ()
+ (save-excursion
+ (and (prog1 (search-backward "(")
+ (forward-char 1))
+ (looking-at company-elisp-var-binding-regexp))))
+
+(defun company-elisp--doc (symbol)
+ (let* ((symbol (intern symbol))
+ (doc (if (fboundp symbol)
+ (documentation symbol t)
+ (documentation-property symbol 'variable-documentation t))))
+ (and (stringp doc)
+ (string-match ".*$" doc)
+ (match-string 0 doc))))
+
+;;;###autoload
+(defun company-elisp (command &optional arg &rest _ignored)
+ "`company-mode' completion backend for Emacs Lisp."
+ (interactive (list 'interactive))
+ (cl-case command
+ (interactive (company-begin-backend 'company-elisp))
+ (prefix (and (derived-mode-p 'emacs-lisp-mode 'inferior-emacs-lisp-mode)
+ (company-elisp--prefix)))
+ (candidates (company-elisp-candidates arg))
+ (sorted company-elisp-show-locals-first)
+ (meta (company-elisp--doc arg))
+ (doc-buffer (let ((symbol (intern arg)))
+ (save-window-excursion
+ (ignore-errors
+ (cond
+ ((fboundp symbol) (describe-function symbol))
+ ((boundp symbol) (describe-variable symbol))
+ ((featurep symbol) (describe-package symbol))
+ ((facep symbol) (describe-face symbol))
+ (t (signal 'user-error nil)))
+ (help-buffer)))))
+ (location (let ((sym (intern arg)))
+ (cond
+ ((fboundp sym) (find-definition-noselect sym nil))
+ ((boundp sym) (find-definition-noselect sym 'defvar))
+ ((featurep sym) (cons (find-file-noselect (find-library-name
+ (symbol-name sym)))
+ 0))
+ ((facep sym) (find-definition-noselect sym 'defface)))))))
+
+(provide 'company-elisp)
+;;; company-elisp.el ends here
--- /dev/null
+;;; company-etags.el --- company-mode completion backend for etags
+
+;; Copyright (C) 2009-2011, 2013-2015, 2018-2019 Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+
+;;; Code:
+
+(require 'company)
+(require 'cl-lib)
+(require 'etags)
+
+(defgroup company-etags nil
+ "Completion backend for etags."
+ :group 'company)
+
+(defcustom company-etags-use-main-table-list t
+ "Always search `tags-table-list' if set.
+If this is disabled, `company-etags' will try to find the one table for each
+buffer automatically."
+ :type '(choice (const :tag "off" nil)
+ (const :tag "on" t)))
+
+(defcustom company-etags-ignore-case nil
+ "Non-nil to ignore case in completion candidates."
+ :type 'boolean
+ :package-version '(company . "0.7.3"))
+
+(defcustom company-etags-everywhere nil
+ "Non-nil to offer completions in comments and strings.
+Set it to t or to a list of major modes."
+ :type '(choice (const :tag "Off" nil)
+ (const :tag "Any supported mode" t)
+ (repeat :tag "Some major modes"
+ (symbol :tag "Major mode")))
+ :package-version '(company . "0.9.0"))
+
+(defvar company-etags-modes '(prog-mode c-mode objc-mode c++-mode java-mode
+ jde-mode pascal-mode perl-mode python-mode))
+
+(defvar-local company-etags-buffer-table 'unknown)
+
+(defun company-etags-find-table ()
+ (let ((file (expand-file-name
+ "TAGS"
+ (locate-dominating-file (or buffer-file-name
+ default-directory)
+ "TAGS"))))
+ (when (and file (file-regular-p file))
+ (list file))))
+
+(defun company-etags-buffer-table ()
+ (or (and company-etags-use-main-table-list tags-table-list)
+ (if (eq company-etags-buffer-table 'unknown)
+ (setq company-etags-buffer-table (company-etags-find-table))
+ company-etags-buffer-table)))
+
+(defun company-etags--candidates (prefix)
+ (let ((tags-table-list (company-etags-buffer-table))
+ (tags-file-name tags-file-name)
+ (completion-ignore-case company-etags-ignore-case))
+ (and (or tags-file-name tags-table-list)
+ (fboundp 'tags-completion-table)
+ (save-excursion
+ (visit-tags-table-buffer)
+ (all-completions prefix (tags-completion-table))))))
+
+;;;###autoload
+(defun company-etags (command &optional arg &rest ignored)
+ "`company-mode' completion backend for etags."
+ (interactive (list 'interactive))
+ (cl-case command
+ (interactive (company-begin-backend 'company-etags))
+ (prefix (and (apply #'derived-mode-p company-etags-modes)
+ (or (eq t company-etags-everywhere)
+ (apply #'derived-mode-p company-etags-everywhere)
+ (not (company-in-string-or-comment)))
+ (company-etags-buffer-table)
+ (or (company-grab-symbol) 'stop)))
+ (candidates (company-etags--candidates arg))
+ (location (let ((tags-table-list (company-etags-buffer-table)))
+ (when (fboundp 'find-tag-noselect)
+ (save-excursion
+ (let ((buffer (find-tag-noselect arg)))
+ (cons buffer (with-current-buffer buffer (point))))))))
+ (ignore-case company-etags-ignore-case)))
+
+(provide 'company-etags)
+;;; company-etags.el ends here
--- /dev/null
+;;; company-files.el --- company-mode completion backend for file names
+
+;; Copyright (C) 2009-2011, 2013-2021 Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+
+;;; Code:
+
+(require 'company)
+(require 'cl-lib)
+
+(defgroup company-files nil
+ "Completion backend for file names."
+ :group 'company)
+
+(defcustom company-files-exclusions nil
+ "A list of file name extensions and directory names to ignore.
+The values should use the same format as `completion-ignored-extensions'."
+ :type '(repeat (string :tag "File extension or directory name"))
+ :package-version '(company . "0.9.1"))
+
+(defcustom company-files-chop-trailing-slash t
+ "Non-nil to remove the trailing slash after inserting directory name.
+
+This way it's easy to continue completion by typing `/' again.
+
+Set this to nil to disable that behavior."
+ :type 'boolean)
+
+(defun company-files--directory-files (dir prefix)
+ ;; Don't use directory-files. It produces directories without trailing /.
+ (condition-case err
+ (let ((comp (sort (file-name-all-completions prefix dir)
+ (lambda (s1 s2) (string-lessp (downcase s1) (downcase s2))))))
+ (when company-files-exclusions
+ (setq comp (company-files--exclusions-filtered comp)))
+ (if (equal prefix "")
+ (delete "../" (delete "./" comp))
+ comp))
+ (file-error nil)))
+
+(defun company-files--exclusions-filtered (completions)
+ (let* ((dir-exclusions (cl-remove-if-not #'company-files--trailing-slash-p
+ company-files-exclusions))
+ (file-exclusions (cl-set-difference company-files-exclusions
+ dir-exclusions)))
+ (cl-loop for c in completions
+ unless (if (company-files--trailing-slash-p c)
+ (member c dir-exclusions)
+ (cl-find-if (lambda (exclusion)
+ (string-suffix-p exclusion c))
+ file-exclusions))
+ collect c)))
+
+(defvar company-files--regexps
+ (let* ((root (if (eq system-type 'windows-nt)
+ "[a-zA-Z]:/"
+ "/"))
+ (begin (concat "\\(?:\\.\\{1,2\\}/\\|~/\\|" root "\\)")))
+ (list (concat "\"\\(" begin "[^\"\n]*\\)")
+ (concat "\'\\(" begin "[^\'\n]*\\)")
+ (concat "\\(?:[ \t=\[]\\|^\\)\\(" begin "[^ \t\n]*\\)"))))
+
+(defun company-files--grab-existing-name ()
+ ;; Grab the file name.
+ ;; When surrounded with quotes, it can include spaces.
+ (let (file dir)
+ (and (cl-dolist (regexp company-files--regexps)
+ (when (setq file (company-grab-line regexp 1))
+ (cl-return file)))
+ (company-files--connected-p file)
+ (setq dir (file-name-directory file))
+ (not (string-match "//" dir))
+ (file-exists-p dir)
+ file)))
+
+(defun company-files--connected-p (file)
+ (or (not (file-remote-p file))
+ (file-remote-p file nil t)))
+
+(defun company-files--trailing-slash-p (file)
+ ;; `file-directory-p' is very expensive on remotes. We are relying on
+ ;; `file-name-all-completions' returning directories with trailing / instead.
+ (let ((len (length file)))
+ (and (> len 0) (eq (aref file (1- len)) ?/))))
+
+(defvar company-files--completion-cache nil)
+
+(defun company-files--complete (prefix)
+ (let* ((dir (file-name-directory prefix))
+ (file (file-name-nondirectory prefix))
+ (key (list file
+ (expand-file-name dir)
+ (nth 5 (file-attributes dir))))
+ (completion-ignore-case read-file-name-completion-ignore-case))
+ (unless (company-file--keys-match-p key (car company-files--completion-cache))
+ (let* ((candidates (mapcar (lambda (f) (concat dir f))
+ (company-files--directory-files dir file)))
+ (directories (unless (file-remote-p dir)
+ (cl-remove-if-not (lambda (f)
+ (and (company-files--trailing-slash-p f)
+ (not (file-remote-p f))
+ (company-files--connected-p f)))
+ candidates)))
+ (children (and directories
+ (cl-mapcan (lambda (d)
+ (mapcar (lambda (c) (concat d c))
+ (company-files--directory-files d "")))
+ directories))))
+ (setq company-files--completion-cache
+ (cons key (append candidates children)))))
+ (all-completions prefix
+ (cdr company-files--completion-cache))))
+
+(defun company-file--keys-match-p (new old)
+ (and (equal (cdr old) (cdr new))
+ (string-prefix-p (car old) (car new))))
+
+(defun company-files--post-completion (arg)
+ (when (and company-files-chop-trailing-slash
+ (company-files--trailing-slash-p arg))
+ (delete-char -1)))
+
+;;;###autoload
+(defun company-files (command &optional arg &rest ignored)
+ "`company-mode' completion backend existing file names.
+Completions works for proper absolute and relative files paths.
+File paths with spaces are only supported inside strings."
+ (interactive (list 'interactive))
+ (cl-case command
+ (interactive (company-begin-backend 'company-files))
+ (prefix (company-files--grab-existing-name))
+ (candidates (company-files--complete arg))
+ (location (cons (dired-noselect
+ (file-name-directory (directory-file-name arg))) 1))
+ (post-completion (company-files--post-completion arg))
+ (kind (if (string-suffix-p "/" arg) 'folder 'file))
+ (sorted t)
+ (no-cache t)))
+
+(provide 'company-files)
+;;; company-files.el ends here
--- /dev/null
+;;; company-gtags.el --- company-mode completion backend for GNU Global
+
+;; Copyright (C) 2009-2011, 2013-2021 Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+
+;;; Code:
+
+(require 'company)
+(require 'company-template)
+(require 'cl-lib)
+
+(defgroup company-gtags nil
+ "Completion backend for GNU Global."
+ :group 'company)
+
+(define-obsolete-variable-alias
+ 'company-gtags-gnu-global-program-name
+ 'company-gtags-executable "earlier")
+
+(defcustom company-gtags-executable
+ (executable-find "global")
+ "Location of GNU global executable."
+ :type 'string)
+
+(defcustom company-gtags-insert-arguments t
+ "When non-nil, insert function arguments as a template after completion."
+ :type 'boolean
+ :package-version '(company . "0.8.1"))
+
+(defvar-local company-gtags--tags-available-p 'unknown)
+(defvar-local company-gtags--executable 'unknown)
+
+(defcustom company-gtags-modes '(prog-mode jde-mode)
+ "Modes that use `company-gtags'.
+In all these modes (and their derivatives) `company-gtags' will perform
+completion."
+ :type '(repeat (symbol :tag "Major mode"))
+ :package-version '(company . "0.8.4"))
+
+(defun company-gtags--tags-available-p ()
+ (if (eq company-gtags--tags-available-p 'unknown)
+ (setq company-gtags--tags-available-p
+ (locate-dominating-file buffer-file-name "GTAGS"))
+ company-gtags--tags-available-p))
+
+;; Avoid byte-compilation warnings on Emacs < 27.
+(declare-function with-connection-local-variables "files-x")
+(declare-function connection-local-set-profile-variables "files-x")
+(declare-function connection-local-set-profiles "files-x")
+
+(defun company-gtags--executable ()
+ (cond
+ ((not (eq company-gtags--executable 'unknown)) ;; the value is already cached
+ company-gtags--executable)
+ ((and (version<= "27" emacs-version) ;; can search remotely to set
+ (file-remote-p default-directory))
+
+ (with-connection-local-variables
+ (if (boundp 'company-gtags--executable-connection)
+ (setq-local company-gtags--executable ;; use if defined as connection-local
+ company-gtags--executable-connection)
+
+ ;; Else search and set as connection local for next uses.
+ (setq-local company-gtags--executable
+ (with-no-warnings (executable-find "global" t)))
+ (let* ((host (file-remote-p default-directory 'host))
+ (symvars (intern (concat host "-vars")))) ;; profile name
+
+ (connection-local-set-profile-variables
+ symvars
+ `((company-gtags--executable-connection . ,company-gtags--executable)))
+
+ (connection-local-set-profiles `(:machine ,host) symvars))
+ company-gtags--executable)))
+ (t ;; use default value (searched locally)
+ company-gtags-executable)))
+
+(defun company-gtags--fetch-tags (prefix)
+ (with-temp-buffer
+ (let (tags)
+ ;; For some reason Global v 6.6.3 is prone to returning exit status 1
+ ;; even on successful searches when '-T' is used.
+ (when (/= 3 (process-file (company-gtags--executable) nil
+ ;; "-T" goes through all the tag files listed in GTAGSLIBPATH
+ (list (current-buffer) nil) nil "-xGqT" (concat "^" prefix)))
+ (goto-char (point-min))
+ (cl-loop while
+ (re-search-forward (concat
+ "^"
+ "\\([^ ]*\\)" ;; completion
+ "[ \t]+\\([[:digit:]]+\\)" ;; linum
+ "[ \t]+\\([^ \t]+\\)" ;; file
+ "[ \t]+\\(.*\\)" ;; definition
+ "$"
+ ) nil t)
+ collect
+ (propertize (match-string 1)
+ 'meta (match-string 4)
+ 'location (cons (expand-file-name (match-string 3))
+ (string-to-number (match-string 2)))
+ ))))))
+
+(defun company-gtags--annotation (arg)
+ (let ((meta (get-text-property 0 'meta arg)))
+ (when (string-match (concat (regexp-quote arg) " *(") meta)
+ (with-temp-buffer
+ (let ((start (match-end 0)))
+ (insert meta)
+ (goto-char start)
+ (condition-case nil
+ (forward-sexp)
+ (scan-error
+ (goto-char (point-max))))
+ (buffer-substring-no-properties
+ start (point)))))))
+
+;;;###autoload
+(defun company-gtags (command &optional arg &rest ignored)
+ "`company-mode' completion backend for GNU Global."
+ (interactive (list 'interactive))
+ (cl-case command
+ (interactive (company-begin-backend 'company-gtags))
+ (prefix (and (company-gtags--executable)
+ buffer-file-name
+ (apply #'derived-mode-p company-gtags-modes)
+ (not (company-in-string-or-comment))
+ (company-gtags--tags-available-p)
+ (or (company-grab-symbol) 'stop)))
+ (candidates (company-gtags--fetch-tags arg))
+ (sorted t)
+ (duplicates t)
+ (annotation (company-gtags--annotation arg))
+ (meta (get-text-property 0 'meta arg))
+ (location (get-text-property 0 'location arg))
+ (post-completion (let ((anno (company-gtags--annotation arg)))
+ (when (and company-gtags-insert-arguments anno)
+ (insert anno)
+ (company-template-c-like-templatify anno))))))
+
+(provide 'company-gtags)
+;;; company-gtags.el ends here
--- /dev/null
+;;; company-ispell.el --- company-mode completion backend using Ispell
+
+;; Copyright (C) 2009-2011, 2013-2016, 2018, 2021 Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+
+;;; Code:
+
+(require 'company)
+(require 'cl-lib)
+(require 'ispell)
+
+(defgroup company-ispell nil
+ "Completion backend using Ispell."
+ :group 'company)
+
+(defcustom company-ispell-dictionary nil
+ "Dictionary to use for `company-ispell'.
+If nil, use `ispell-complete-word-dict'."
+ :type '(choice (const :tag "default (nil)" nil)
+ (file :tag "dictionary" t)))
+
+(defvar company-ispell-available 'unknown)
+
+(defalias 'company-ispell--lookup-words
+ (if (fboundp 'ispell-lookup-words)
+ 'ispell-lookup-words
+ 'lookup-words))
+
+(defun company-ispell-available ()
+ (when (eq company-ispell-available 'unknown)
+ (condition-case err
+ (progn
+ (company-ispell--lookup-words "WHATEVER")
+ (setq company-ispell-available t))
+ (error
+ (message "Company-Ispell: %s" (error-message-string err))
+ (setq company-ispell-available nil))))
+ company-ispell-available)
+
+;;;###autoload
+(defun company-ispell (command &optional arg &rest ignored)
+ "`company-mode' completion backend using Ispell."
+ (interactive (list 'interactive))
+ (cl-case command
+ (interactive (company-begin-backend 'company-ispell))
+ (prefix (when (company-ispell-available)
+ (company-grab-word)))
+ (candidates
+ (let ((words (company-ispell--lookup-words
+ arg
+ (or company-ispell-dictionary ispell-complete-word-dict)))
+ (completion-ignore-case t))
+ (if (string= arg "")
+ ;; Small optimization.
+ words
+ ;; Work around issue #284.
+ (all-completions arg words))))
+ (kind 'text)
+ (sorted t)
+ (ignore-case 'keep-prefix)))
+
+(provide 'company-ispell)
+;;; company-ispell.el ends here
--- /dev/null
+;;; company-keywords.el --- A company backend for programming language keywords
+
+;; Copyright (C) 2009-2011, 2013-2018, 2020-2021 Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+
+;;; Code:
+
+(require 'company)
+(require 'cl-lib)
+(eval-when-compile (require 'make-mode))
+
+(defgroup company-keywords nil
+ "Completion backend for keywords."
+ :group 'company)
+
+(defcustom company-keywords-ignore-case nil
+ "Non-nil to ignore case in completion candidates."
+ :type 'boolean)
+
+(defun company-keywords-upper-lower (&rest lst)
+ ;; Upcase order is different for _.
+ (nconc (sort (mapcar 'upcase lst) 'string<) lst))
+
+(defvar company-keywords-alist
+ ;; Please contribute corrections or additions.
+ `((c++-mode
+ ;; from https://en.cppreference.com/w/cpp/keyword
+ "alignas" "alignof" "and" "and_eq" "asm" "atomic_cancel" "atomic_commit"
+ "atomic_noexcept" "auto" "bitand" "bitor" "bool" "break" "case" "catch"
+ "char" "char16_t" "char32_t" "char8_t" "class" "co_await" "co_return"
+ "co_yield" "compl" "concept" "const" "const_cast" "consteval" "constexpr"
+ "constinit" "continue" "decltype" "default" "delete" "do" "double"
+ "dynamic_cast" "else" "enum" "explicit" "export" "extern" "false" "final"
+ "float" "for" "friend" "goto" "if" "import" "inline" "int" "long" "module"
+ "mutable" "namespace" "new" "noexcept" "not" "not_eq" "nullptr" "operator"
+ "or" "or_eq" "override" "private" "protected" "public" "reflexpr" "register"
+ "reinterpret_cast" "requires" "return" "short" "signed" "sizeof" "static"
+ "static_assert" "static_cast" "struct" "switch" "synchronized" "template"
+ "this" "thread_local" "throw" "true" "try" "typedef" "typeid" "typename"
+ "union" "unsigned" "using" "virtual" "void" "volatile" "wchar_t" "while"
+ "xor" "xor_eq")
+ (c-mode
+ ;; from https://en.cppreference.com/w/c/keyword
+ "_Alignas" "_Alignof" "_Atomic" "_Bool" "_Complex"
+ "_Decimal128" "_Decimal32" "_Decimal64" "_Generic" "_Imaginary"
+ "_Noreturn" "_Static_assert" "_Thread_local" "__asm__" "asm"
+ "auto" "break" "case" "char" "const" "continue" "default" "do"
+ "double" "else" "enum" "extern" "float" "for" "goto" "if" "inline"
+ "int" "long" "register" "restrict" "return" "short" "signed" "sizeof"
+ "static" "struct" "switch" "typedef" "union" "unsigned" "void" "volatile"
+ "while")
+ (crystal-mode
+ ;; from https://github.com/crystal-lang/crystal-book/issues/124#issuecomment-1008311227
+ "abstract" "alias" "annotation" "as" "as?" "asm" "begin" "break" "case" "class"
+ "def" "do" "else" "elsif" "end" "ensure" "enum" "extend" "false" "for" "fun"
+ "if" "in" "include" "instance_sizeof" "is_a?" "lib" "macro" "module" "next"
+ "nil" "nil?" "of" "offsetof" "out" "pointerof" "private" "protected" "require"
+ "rescue" "responds_to?" "return" "select" "self" "sizeof" "struct" "super"
+ "then" "true" "type" "typeof" "uninitialized" "union" "unless" "until" "verbatim"
+ "when" "while" "with" "yield")
+ (csharp-mode
+ "abstract" "add" "alias" "as" "base" "bool" "break" "byte" "case"
+ "catch" "char" "checked" "class" "const" "continue" "decimal" "default"
+ "delegate" "do" "double" "else" "enum" "event" "explicit" "extern"
+ "false" "finally" "fixed" "float" "for" "foreach" "get" "global" "goto"
+ "if" "implicit" "in" "int" "interface" "internal" "is" "lock" "long"
+ "namespace" "new" "null" "object" "operator" "out" "override" "params"
+ "partial" "private" "protected" "public" "readonly" "ref" "remove"
+ "return" "sbyte" "sealed" "set" "short" "sizeof" "stackalloc" "static"
+ "string" "struct" "switch" "this" "throw" "true" "try" "typeof" "uint"
+ "ulong" "unchecked" "unsafe" "ushort" "using" "value" "var" "virtual"
+ "void" "volatile" "where" "while" "yield")
+ (d-mode
+ ;; from http://www.digitalmars.com/d/2.0/lex.html
+ "abstract" "alias" "align" "asm"
+ "assert" "auto" "body" "bool" "break" "byte" "case" "cast" "catch"
+ "cdouble" "cent" "cfloat" "char" "class" "const" "continue" "creal"
+ "dchar" "debug" "default" "delegate" "delete" "deprecated" "do"
+ "double" "else" "enum" "export" "extern" "false" "final" "finally"
+ "float" "for" "foreach" "foreach_reverse" "function" "goto" "idouble"
+ "if" "ifloat" "import" "in" "inout" "int" "interface" "invariant"
+ "ireal" "is" "lazy" "long" "macro" "mixin" "module" "new" "nothrow"
+ "null" "out" "override" "package" "pragma" "private" "protected"
+ "public" "pure" "real" "ref" "return" "scope" "short" "static" "struct"
+ "super" "switch" "synchronized" "template" "this" "throw" "true" "try"
+ "typedef" "typeid" "typeof" "ubyte" "ucent" "uint" "ulong" "union"
+ "unittest" "ushort" "version" "void" "volatile" "wchar" "while" "with")
+ (elixir-mode
+ ;; from https://hexdocs.pm/elixir/Kernel.html
+ "__CALLER__" "__DIR__" "__ENV__" "__MODULE__" "__STACKTRACE__"
+ "__aliases__" "__block__" "abs" "alias" "alias!" "and" "apply"
+ "binary_part" "binary_slice" "binding" "bit_size" "byte_size" "case" "ceil"
+ "cond" "dbg" "def" "defdelegate" "defexception" "defguard" "defguardp"
+ "defimpl" "defmacro" "defmacrop" "defmodule" "defoverridable" "defp"
+ "defprotocol" "defstruct" "destructure" "div" "elem" "exit" "floor" "fn"
+ "for" "function_exported?" "get_and_update_in" "get_in" "hd" "if" "import"
+ "in" "inspect" "is_atom" "is_binary" "is_bitstring" "is_boolean"
+ "is_exception" "is_float" "is_function" "is_integer" "is_list" "is_map"
+ "is_map_key" "is_nil" "is_number" "is_pid" "is_port" "is_reference"
+ "is_struct" "is_tuple" "length" "macro_exported?" "make_ref" "map_size"
+ "match?" "max" "min" "node" "not" "or" "pop_in" "put_elem" "put_in" "quote"
+ "raise" "receive" "rem" "require" "reraise" "round" "self" "send" "spawn"
+ "spawn_link" "spawn_monitor" "struct" "struct!" "super" "tap" "then"
+ "throw" "tl" "to_charlist" "to_string" "trunc" "try" "tuple_size" "unless"
+ "unquote" "unquote_splicing" "update_in" "use" "var!" "with")
+ (erlang-mode
+ ;; from https://www.erlang.org/docs/20/reference_manual/introduction.html#id63536
+ "after" "and" "andalso" "band" "begin" "bnot" "bor" "bsl" "bsr" "bxor"
+ "case" "catch" "cond" "div" "end" "fun" "if" "let" "not" "of" "or" "orelse"
+ "receive" "rem" "try" "when" "xor")
+ (f90-mode .
+ ;; from f90.el
+ ;; ".AND." ".GE." ".GT." ".LT." ".LE." ".NE." ".OR." ".TRUE." ".FALSE."
+ ,(company-keywords-upper-lower
+ "abs" "abstract" "achar" "acos" "adjustl" "adjustr" "aimag" "aint"
+ "align" "all" "all_prefix" "all_scatter" "all_suffix" "allocatable"
+ "allocate" "allocated" "and" "anint" "any" "any_prefix" "any_scatter"
+ "any_suffix" "asin" "assign" "assignment" "associate" "associated"
+ "asynchronous" "atan" "atan2" "backspace" "bind" "bit_size" "block"
+ "btest" "c_alert" "c_associated" "c_backspace" "c_bool"
+ "c_carriage_return" "c_char" "c_double" "c_double_complex" "c_f_pointer"
+ "c_f_procpointer" "c_float" "c_float_complex" "c_form_feed" "c_funloc"
+ "c_funptr" "c_horizontal_tab" "c_int" "c_int16_t" "c_int32_t" "c_int64_t"
+ "c_int8_t" "c_int_fast16_t" "c_int_fast32_t" "c_int_fast64_t"
+ "c_int_fast8_t" "c_int_least16_t" "c_int_least32_t" "c_int_least64_t"
+ "c_int_least8_t" "c_intmax_t" "c_intptr_t" "c_loc" "c_long"
+ "c_long_double" "c_long_double_complex" "c_long_long" "c_new_line"
+ "c_null_char" "c_null_funptr" "c_null_ptr" "c_ptr" "c_short"
+ "c_signed_char" "c_size_t" "c_vertical_tab" "call" "case" "ceiling"
+ "char" "character" "character_storage_size" "class" "close" "cmplx"
+ "command_argument_count" "common" "complex" "conjg" "contains" "continue"
+ "copy_prefix" "copy_scatter" "copy_suffix" "cos" "cosh" "count"
+ "count_prefix" "count_scatter" "count_suffix" "cpu_time" "cshift"
+ "cycle" "cyclic" "data" "date_and_time" "dble" "deallocate" "deferred"
+ "digits" "dim" "dimension" "distribute" "do" "dot_product" "double"
+ "dprod" "dynamic" "elemental" "else" "elseif" "elsewhere" "end" "enddo"
+ "endfile" "endif" "entry" "enum" "enumerator" "eoshift" "epsilon" "eq"
+ "equivalence" "eqv" "error_unit" "exit" "exp" "exponent" "extends"
+ "extends_type_of" "external" "extrinsic" "false" "file_storage_size"
+ "final" "floor" "flush" "forall" "format" "fraction" "function" "ge"
+ "generic" "get_command" "get_command_argument" "get_environment_variable"
+ "goto" "grade_down" "grade_up" "gt" "hpf_alignment" "hpf_distribution"
+ "hpf_template" "huge" "iachar" "iall" "iall_prefix" "iall_scatter"
+ "iall_suffix" "iand" "iany" "iany_prefix" "iany_scatter" "iany_suffix"
+ "ibclr" "ibits" "ibset" "ichar" "ieee_arithmetic" "ieee_exceptions"
+ "ieee_features" "ieee_get_underflow_mode" "ieee_set_underflow_mode"
+ "ieee_support_underflow_control" "ieor" "if" "ilen" "implicit"
+ "import" "include" "independent" "index" "inherit" "input_unit"
+ "inquire" "int" "integer" "intent" "interface" "intrinsic" "ior"
+ "iostat_end" "iostat_eor" "iparity" "iparity_prefix" "iparity_scatter"
+ "iparity_suffix" "ishft" "ishftc" "iso_c_binding" "iso_fortran_env"
+ "kind" "lbound" "le" "leadz" "len" "len_trim" "lge" "lgt" "lle" "llt"
+ "log" "log10" "logical" "lt" "matmul" "max" "maxexponent" "maxloc"
+ "maxval" "maxval_prefix" "maxval_scatter" "maxval_suffix" "merge"
+ "min" "minexponent" "minloc" "minval" "minval_prefix" "minval_scatter"
+ "minval_suffix" "mod" "module" "modulo" "move_alloc" "mvbits" "namelist"
+ "ne" "nearest" "neqv" "new" "new_line" "nint" "non_intrinsic"
+ "non_overridable" "none" "nopass" "not" "null" "nullify"
+ "number_of_processors" "numeric_storage_size" "only" "onto" "open"
+ "operator" "optional" "or" "output_unit" "pack" "parameter" "parity"
+ "parity_prefix" "parity_scatter" "parity_suffix" "pass" "pause"
+ "pointer" "popcnt" "poppar" "precision" "present" "print" "private"
+ "procedure" "processors" "processors_shape" "product" "product_prefix"
+ "product_scatter" "product_suffix" "program" "protected" "public"
+ "pure" "radix" "random_number" "random_seed" "range" "read" "real"
+ "realign" "recursive" "redistribute" "repeat" "reshape" "result"
+ "return" "rewind" "rrspacing" "same_type_as" "save" "scale" "scan"
+ "select" "selected_char_kind" "selected_int_kind" "selected_real_kind"
+ "sequence" "set_exponent" "shape" "sign" "sin" "sinh" "size" "spacing"
+ "spread" "sqrt" "stop" "subroutine" "sum" "sum_prefix" "sum_scatter"
+ "sum_suffix" "system_clock" "tan" "tanh" "target" "template" "then"
+ "tiny" "transfer" "transpose" "trim" "true" "type" "ubound" "unpack"
+ "use" "value" "verify" "volatile" "wait" "where" "while" "with" "write"))
+ (go-mode
+ ;; 1. Keywords ref: https://golang.org/ref/spec#Keywords
+ ;; 2. Builtin functions and types ref: https://golang.org/pkg/builtin/
+ "append" "bool" "break" "byte" "cap" "case" "chan" "close" "complex" "complex128"
+ "complex64" "const" "continue" "copy" "default" "defer" "delete" "else" "error"
+ "fallthrough" "false" "float32" "float64" "for" "func" "go" "goto" "if" "imag"
+ "import" "int" "int16" "int32" "int64" "int8" "interface" "len" "make"
+ "map" "new" "nil" "package" "panic" "print" "println" "range" "real" "recover"
+ "return" "rune" "select" "string" "struct" "switch" "true" "type" "uint" "uint16"
+ "uint32" "uint64" "uint8" "uintptr" "var")
+ (java-mode
+ "abstract" "assert" "boolean" "break" "byte" "case" "catch" "char" "class"
+ "continue" "default" "do" "double" "else" "enum" "extends" "final"
+ "finally" "float" "for" "if" "implements" "import" "instanceof" "int"
+ "interface" "long" "native" "new" "package" "private" "protected" "public"
+ "return" "short" "static" "strictfp" "super" "switch" "synchronized"
+ "this" "throw" "throws" "transient" "try" "void" "volatile" "while")
+ (javascript-mode
+ ;; https://tc39.github.io/ecma262/ + async, static and undefined
+ "async" "await" "break" "case" "catch" "class" "const" "continue"
+ "debugger" "default" "delete" "do" "else" "enum" "export" "extends" "false"
+ "finally" "for" "function" "if" "import" "in" "instanceof" "let" "new"
+ "null" "return" "static" "super" "switch" "this" "throw" "true" "try"
+ "typeof" "undefined" "var" "void" "while" "with" "yield")
+ (kotlin-mode
+ "abstract" "annotation" "as" "break" "by" "catch" "class" "companion"
+ "const" "constructor" "continue" "data" "do" "else" "enum" "false" "final"
+ "finally" "for" "fun" "if" "import" "in" "init" "inner" "interface"
+ "internal" "is" "lateinit" "nested" "null" "object" "open" "out" "override"
+ "package" "private" "protected" "public" "return" "super" "this" "throw"
+ "trait" "true" "try" "typealias" "val" "var" "when" "while")
+ (lua-mode
+ ;; https://www.lua.org/manual/5.3/manual.html
+ "and" "break" "do" "else" "elseif" "end" "false" "for" "function" "goto" "if"
+ "in" "local" "nil" "not" "or" "repeat" "return" "then" "true" "until" "while")
+ (nim-mode
+ ;; https://nim-lang.org/docs/manual.html#lexical-analysis-identifiers-amp-keywords
+ "addr" "and" "as" "asm" "bind" "block" "break" "case" "cast" "concept" "const" "continue"
+ "converter" "defer" "discard" "distinct" "div" "do" "elif" "else" "end" "enum" "except"
+ "export" "finally" "for" "from" "func" "if" "import" "in" "include" "interface" "is" "isnot"
+ "iterator" "let" "macro" "method" "mixin" "mod" "nil" "not" "notin" "object" "of" "or" "out"
+ "proc" "ptr" "raise" "ref" "return" "shl" "shr" "static" "template" "try" "tuple" "type"
+ "using" "var" "when" "while" "xor" "yield")
+ (objc-mode
+ "@catch" "@class" "@encode" "@end" "@finally" "@implementation"
+ "@interface" "@private" "@protected" "@protocol" "@public"
+ "@selector" "@synchronized" "@throw" "@try" "alloc" "autorelease"
+ "bycopy" "byref" "in" "inout" "oneway" "out" "release" "retain")
+ (perl-mode
+ ;; from cperl.el
+ "AUTOLOAD" "BEGIN" "CHECK" "CORE" "DESTROY" "END" "INIT" "__END__"
+ "__FILE__" "__LINE__" "abs" "accept" "alarm" "and" "atan2" "bind"
+ "binmode" "bless" "caller" "chdir" "chmod" "chomp" "chop" "chown" "chr"
+ "chroot" "close" "closedir" "cmp" "connect" "continue" "cos"
+ "crypt" "dbmclose" "dbmopen" "defined" "delete" "die" "do" "dump" "each"
+ "else" "elsif" "endgrent" "endhostent" "endnetent" "endprotoent"
+ "endpwent" "endservent" "eof" "eq" "eval" "exec" "exists" "exit" "exp"
+ "fcntl" "fileno" "flock" "for" "foreach" "fork" "format" "formline"
+ "ge" "getc" "getgrent" "getgrgid" "getgrnam" "gethostbyaddr"
+ "gethostbyname" "gethostent" "getlogin" "getnetbyaddr" "getnetbyname"
+ "getnetent" "getpeername" "getpgrp" "getppid" "getpriority"
+ "getprotobyname" "getprotobynumber" "getprotoent" "getpwent" "getpwnam"
+ "getpwuid" "getservbyname" "getservbyport" "getservent" "getsockname"
+ "getsockopt" "glob" "gmtime" "goto" "grep" "gt" "hex" "if" "index" "int"
+ "ioctl" "join" "keys" "kill" "last" "lc" "lcfirst" "le" "length"
+ "link" "listen" "local" "localtime" "lock" "log" "lstat" "lt" "map"
+ "mkdir" "msgctl" "msgget" "msgrcv" "msgsnd" "my" "ne" "next" "no"
+ "not" "oct" "open" "opendir" "or" "ord" "our" "pack" "package" "pipe"
+ "pop" "pos" "print" "printf" "push" "q" "qq" "quotemeta" "qw" "qx"
+ "rand" "read" "readdir" "readline" "readlink" "readpipe" "recv" "redo"
+ "ref" "rename" "require" "reset" "return" "reverse" "rewinddir" "rindex"
+ "rmdir" "scalar" "seek" "seekdir" "select" "semctl" "semget" "semop"
+ "send" "setgrent" "sethostent" "setnetent" "setpgrp" "setpriority"
+ "setprotoent" "setpwent" "setservent" "setsockopt" "shift" "shmctl"
+ "shmget" "shmread" "shmwrite" "shutdown" "sin" "sleep" "socket"
+ "socketpair" "sort" "splice" "split" "sprintf" "sqrt" "srand" "stat"
+ "study" "sub" "substr" "symlink" "syscall" "sysopen" "sysread" "system"
+ "syswrite" "tell" "telldir" "tie" "time" "times" "tr" "truncate" "uc"
+ "ucfirst" "umask" "undef" "unless" "unlink" "unpack" "unshift" "untie"
+ "until" "use" "utime" "values" "vec" "wait" "waitpid"
+ "wantarray" "warn" "while" "write" "x" "xor" "y")
+ (php-mode ;; https://www.php.net/manual/reserved.php
+ "Closure" "Error" "Exception" "Generator" "Throwable"
+ "__CLASS__" "__DIR__" "__FILE__" "__FUNCTION__" "__LINE__" "__METHOD__"
+ "__NAMESPACE__" "__TRAIT__"
+ "abstract" "and" "array" "as" "bool" "break" "callable" "case" "catch"
+ "class" "clone" "const" "continue" "declare" "default" "die" "do" "echo"
+ "else" "elseif" "empty" "enddeclare" "endfor" "endforeach" "endif"
+ "endswitch" "endwhile" "enum" "eval" "exit" "extends" "false" "final" "finally"
+ "float" "fn" "for" "foreach" "function" "global" "goto" "if"
+ "implements" "include" "include_once" "instanceof" "insteadof" "interface"
+ "isset" "iterable" "list" "match" "namespace" "new" "null" "object" "or"
+ "print" "private" "protected" "public" "readonly" "require" "require_once"
+ "return" "self" "static" "string" "switch" "this" "throw" "trait" "true"
+ "try" "unset" "use" "var" "void" "while" "xor" "yield" "yield from")
+ (purescript-mode ;; purescript-font-lock.el
+ "ado" "case" "class" "data" "default" "deriving" "do" "else" "if" "import"
+ "in" "infix" "infixl" "infixr" "instance" "let" "module" "newtype" "of"
+ "then" "type" "where")
+ (python-mode
+ ;; https://docs.python.org/3/reference/lexical_analysis.html#keywords
+ "False" "None" "True" "and" "as" "assert" "break" "class" "continue" "def"
+ "del" "elif" "else" "except" "exec" "finally" "for" "from" "global" "if"
+ "import" "in" "is" "lambda" "nonlocal" "not" "or" "pass" "print" "raise"
+ "return" "try" "while" "with" "yield")
+ (ruby-mode
+ "BEGIN" "END" "alias" "and" "begin" "break" "case" "class" "def" "defined?"
+ "do" "else" "elsif" "end" "ensure" "false" "for" "if" "in" "module"
+ "next" "nil" "not" "or" "redo" "rescue" "retry" "return" "self" "super"
+ "then" "true" "undef" "unless" "until" "when" "while" "yield")
+ ;; From https://doc.rust-lang.org/grammar.html#keywords
+ ;; but excluding unused reserved words: https://www.reddit.com/r/rust/comments/34fq0k/is_there_a_good_list_of_rusts_keywords/cqucvnj
+ (rust-mode
+ "Self"
+ "as" "box" "break" "const" "continue" "crate" "else" "enum" "extern"
+ "false" "fn" "for" "if" "impl" "in" "let" "loop" "macro" "match" "mod"
+ "move" "mut" "pub" "ref" "return" "self" "static" "struct" "super"
+ "trait" "true" "type" "unsafe" "use" "where" "while")
+ ; Extract from R7RS-small Tex: https://small.r7rs.org/
+ (scheme-mode
+ "abs" "acos" "angle" "append" "apply" "asin" "assoc" "assq" "assv"
+ "atan" "binary-port?" "body" "boolean=?" "boolean?" "bytevector"
+ "bytevector-append" "bytevector-copy" "bytevector-copy!"
+ "bytevector-length" "bytevector-u8-ref" "bytevector-u8-set!"
+ "bytevector?" "caaaar" "caaadr" "caaar" "caadar" "caaddr" "caadr"
+ "caar" "cadaar" "cadadr" "cadar" "caddar" "cadddr" "caddr" "cadr"
+ "call-with-port" "call-with-values" "car" "car-internal" "cdaaar"
+ "cdaadr" "cdaar" "cdadar" "cdaddr" "cdadr" "cdar" "cddaar" "cddadr"
+ "cddar" "cdddar" "cddddr" "cdddr" "cddr" "cdr" "ceiling"
+ "char->integer" "char-alphabetic?" "char-ci<=?" "char-ci<?"
+ "char-ci=?" "char-ci>=?" "char-ci>?" "char-downcase" "char-foldcase"
+ "char-lower-case?" "char-numeric?" "char-ready?" "char-upcase"
+ "char-upper-case?" "char-whitespace?" "char<=?" "char<?" "char=?"
+ "char>=?" "char>?" "char?" "close-input-port" "close-output-port"
+ "close-port" "command-line" "complex?" "cons" "cos"
+ "current-error-port" "current-input-port" "current-jiffy"
+ "current-output-port" "current-second" "delete-file" "denominator"
+ "digit-value" "display" "dynamic-wind" "emergency-exit" "environment"
+ "eof-object" "eof-object?" "eq?" "equal?" "eqv?" "error"
+ "error-object-irritants" "error-object-message" "error-object?" "eval"
+ "even?" "exact" "exact-integer-sqrt" "exact-integer?" "exact?" "exit"
+ "exp" "expt" "features" "file-error?" "file-exists?" "finite?" "floor"
+ "floor-quotient" "floor-remainder" "floor/" "flush-output-port" "gcd"
+ "get-environment-variable" "get-environment-variables"
+ "get-output-bytevector" "get-output-string" "imag-part" "inexact"
+ "inexact?" "infinite?" "input-port-open?" "input-port?"
+ "integer->char" "integer?" "interaction-environment"
+ "jiffies-per-second" "lcm" "length" "list" "list->string"
+ "list->vector" "list-copy" "list-ref" "list-set!" "list-tail" "list?"
+ "load" "log" "magnitude" "make-bytevector" "make-list"
+ "make-parameter" "make-polar" "make-promise" "make-rectangular"
+ "make-string" "make-vector" "max" "member" "memq" "memv" "min"
+ "modulo" "nan?" "negative?" "newline" "nil" "not" "null-environment"
+ "null?" "number->string" "number?" "numerator" "odd?"
+ "open-binary-input-file" "open-binary-output-file"
+ "open-input-bytevector" "open-input-file" "open-input-string"
+ "open-output-bytevector" "open-output-file" "open-output-string"
+ "output-port-open?" "output-port?" "pair?" "peek-char" "peek-u8"
+ "port?" "positive?" "procedure?" "promise?" "quasiquote" "quote"
+ "quotient" "raise" "raise-continuable" "rational?" "rationalize"
+ "read" "read-bytevector" "read-bytevector!" "read-char" "read-error?"
+ "read-line" "read-string" "read-u8" "real-part" "real?" "remainder"
+ "reverse" "round" "scheme-report-environment" "set!" "set-car!"
+ "set-cdr!" "setcar" "sin" "sqrt" "square" "string" "string->list"
+ "string->number" "string->symbol" "string->utf" "string->vector"
+ "string-append" "string-ci<=?" "string-ci<?" "string-ci=?"
+ "string-ci>=?" "string-ci>?" "string-copy" "string-copy!"
+ "string-downcase" "string-fill!" "string-foldcase" "string-for-each"
+ "string-length" "string-map" "string-ref" "string-set!"
+ "string-upcase" "string<=?" "string<?" "string=?" "string>=?"
+ "string>?" "string?" "substring" "symbol->string" "symbol=?" "symbol?"
+ "tan" "textual-port?" "truncate" "truncate-quotient"
+ "truncate-remainder" "truncate/" "u8-ready?" "unquote"
+ "unquote-splicing" "utf->string" "values" "vector" "vector->list"
+ "vector->string" "vector-append" "vector-copy" "vector-copy!"
+ "vector-fill!" "vector-for-each" "vector-length" "vector-map"
+ "vector-ref" "vector-set!" "vector?" "with-exception-handler"
+ "with-input-from-file" "with-output-to-file" "write"
+ "write-bytevector" "write-char" "write-shared" "write-simple"
+ "write-string" "write-u8" "zero?")
+ (scala-mode
+ "abstract" "case" "catch" "class" "def" "do" "else" "extends" "false"
+ "final" "finally" "for" "forSome" "if" "implicit" "import" "lazy" "match"
+ "new" "null" "object" "override" "package" "private" "protected"
+ "return" "sealed" "super" "this" "throw" "trait" "true" "try" "type" "val"
+ "var" "while" "with" "yield")
+ (swift-mode
+ "Protocol" "Self" "Type" "and" "as" "assignment" "associatedtype"
+ "associativity" "available" "break" "case" "catch" "class" "column" "continue"
+ "convenience" "default" "defer" "deinit" "didSet" "do" "dynamic" "dynamicType"
+ "else" "elseif" "endif" "enum" "extension" "fallthrough" "false" "file"
+ "fileprivate" "final" "for" "func" "function" "get" "guard" "higherThan" "if"
+ "import" "in" "indirect" "infix" "init" "inout" "internal" "is" "lazy" "left"
+ "let" "line" "lowerThan" "mutating" "nil" "none" "nonmutating" "open"
+ "operator" "optional" "override" "postfix" "precedence" "precedencegroup"
+ "prefix" "private" "protocol" "public" "repeat" "required" "rethrows" "return"
+ "right" "selector" "self" "set" "static" "struct" "subscript" "super" "switch"
+ "throw" "throws" "true" "try" "typealias" "unowned" "var" "weak" "where"
+ "while" "willSet")
+ (julia-mode
+ "abstract" "break" "case" "catch" "const" "continue" "do" "else" "elseif"
+ "end" "eval" "export" "false" "finally" "for" "function" "global" "if"
+ "ifelse" "immutable" "import" "importall" "in" "let" "macro" "module"
+ "otherwise" "quote" "return" "switch" "throw" "true" "try" "type"
+ "typealias" "using" "while"
+ )
+ ;; From https://github.com/apache/thrift/blob/master/contrib/thrift.el
+ (thrift-mode
+ "binary" "bool" "byte" "const" "double" "enum" "exception" "extends"
+ "i16" "i32" "i64" "include" "list" "map" "oneway" "optional" "required"
+ "service" "set" "string" "struct" "throws" "typedef" "void"
+ )
+ ;; aliases
+ (js2-mode . javascript-mode)
+ (js2-jsx-mode . javascript-mode)
+ (espresso-mode . javascript-mode)
+ (js-mode . javascript-mode)
+ (js-jsx-mode . javascript-mode)
+ (rjsx-mode . javascript-mode)
+ (cperl-mode . perl-mode)
+ (jde-mode . java-mode)
+ (ess-julia-mode . julia-mode)
+ (phps-mode . php-mode)
+ (enh-ruby-mode . ruby-mode))
+ "Alist mapping major-modes to sorted keywords for `company-keywords'.")
+
+(with-eval-after-load 'make-mode
+ (mapc
+ (lambda (mode-stmnts)
+ (setf (alist-get (car mode-stmnts) company-keywords-alist)
+ (cl-remove-duplicates
+ (sort (append makefile-special-targets-list
+ (cl-mapcan #'identity
+ (mapcar
+ #'split-string
+ (cl-remove-if-not
+ #'stringp
+ (symbol-value (cdr mode-stmnts))))))
+ #'string<)
+ :test #'string=)))
+ '((makefile-automake-mode . makefile-automake-statements)
+ (makefile-gmake-mode . makefile-gmake-statements)
+ (makefile-makepp-mode . makefile-makepp-statements)
+ (makefile-bsdmake-mode . makefile-bsdmake-statements)
+ (makefile-imake-mode . makefile-statements)
+ (makefile-mode . makefile-statements))))
+
+;;;###autoload
+(defun company-keywords (command &optional arg &rest ignored)
+ "`company-mode' backend for programming language keywords."
+ (interactive (list 'interactive))
+ (cl-case command
+ (interactive (company-begin-backend 'company-keywords))
+ (prefix (and (assq major-mode company-keywords-alist)
+ (not (company-in-string-or-comment))
+ (or (company-grab-symbol) 'stop)))
+ (candidates
+ (let ((completion-ignore-case company-keywords-ignore-case)
+ (symbols (cdr (assq major-mode company-keywords-alist))))
+ (all-completions arg (if (consp symbols)
+ symbols
+ (cdr (assq symbols company-keywords-alist))))))
+ (kind 'keyword)
+ (sorted t)
+ (ignore-case company-keywords-ignore-case)))
+
+(provide 'company-keywords)
+;;; company-keywords.el ends here
--- /dev/null
+;;; company-nxml.el --- company-mode completion backend for nxml-mode
+
+;; Copyright (C) 2009-2011, 2013-2015, 2017-2018 Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+;; In Emacs >= 26, company-capf is used instead.
+
+;;; Code:
+
+(require 'company)
+(require 'cl-lib)
+
+(defvar rng-open-elements)
+(defvar rng-validate-mode)
+(defvar rng-in-attribute-regex)
+(defvar rng-in-attribute-value-regex)
+(declare-function rng-set-state-after "rng-nxml")
+(declare-function rng-match-possible-start-tag-names "rng-match")
+(declare-function rng-adjust-state-for-attribute "rng-nxml")
+(declare-function rng-match-possible-attribute-names "rng-match")
+(declare-function rng-adjust-state-for-attribute-value "rng-nxml")
+(declare-function rng-match-possible-value-strings "rng-match")
+
+(defconst company-nxml-token-regexp
+ "\\(?:[_[:alpha:]][-._[:alnum:]]*\\_>\\)")
+
+(defvar company-nxml-in-attribute-value-regexp
+ (replace-regexp-in-string "w" company-nxml-token-regexp
+ "<w\\(?::w\\)?\
+\\(?:[ \t\r\n]+w\\(?::w\\)?[ \t\r\n]*=\
+\[ \t\r\n]*\\(?:\"[^\"]*\"\\|'[^']*'\\)\\)*\
+\[ \t\r\n]+\\(w\\(:w\\)?\\)[ \t\r\n]*=[ \t\r\n]*\
+\\(\"\\([^\"]*\\>\\)\\|'\\([^']*\\>\\)\\)\\="
+ t t))
+
+(defvar company-nxml-in-tag-name-regexp
+ (replace-regexp-in-string "w" company-nxml-token-regexp
+ "<\\(/?w\\(?::w?\\)?\\)?\\=" t t))
+
+(defun company-nxml-all-completions (prefix alist)
+ (let ((candidates (mapcar 'cdr alist))
+ (case-fold-search nil)
+ filtered)
+ (when (cdar rng-open-elements)
+ (push (concat "/" (cdar rng-open-elements)) candidates))
+ (setq candidates (sort (all-completions prefix candidates) 'string<))
+ (while candidates
+ (unless (equal (car candidates) (car filtered))
+ (push (car candidates) filtered))
+ (pop candidates))
+ (nreverse filtered)))
+
+(defmacro company-nxml-prepared (&rest body)
+ (declare (indent 0) (debug t))
+ `(let ((lt-pos (save-excursion (search-backward "<" nil t)))
+ xmltok-dtd)
+ (when (and lt-pos (= (rng-set-state-after lt-pos) lt-pos))
+ ,@body)))
+
+(defun company-nxml-tag (command &optional arg &rest ignored)
+ (cl-case command
+ (prefix (and (derived-mode-p 'nxml-mode)
+ rng-validate-mode
+ (company-grab company-nxml-in-tag-name-regexp 1)))
+ (candidates (company-nxml-prepared
+ (company-nxml-all-completions
+ arg (rng-match-possible-start-tag-names))))
+ (sorted t)))
+
+(defun company-nxml-attribute (command &optional arg &rest ignored)
+ (cl-case command
+ (prefix (and (derived-mode-p 'nxml-mode)
+ rng-validate-mode
+ (memq (char-after) '(?\ ?\t ?\n)) ;; outside word
+ (company-grab rng-in-attribute-regex 1)))
+ (candidates (company-nxml-prepared
+ (and (rng-adjust-state-for-attribute
+ lt-pos (- (point) (length arg)))
+ (company-nxml-all-completions
+ arg (rng-match-possible-attribute-names)))))
+ (sorted t)))
+
+(defun company-nxml-attribute-value (command &optional arg &rest ignored)
+ (cl-case command
+ (prefix (and (derived-mode-p 'nxml-mode)
+ rng-validate-mode
+ (and (memq (char-after) '(?' ?\" ?\ ?\t ?\n)) ;; outside word
+ (looking-back company-nxml-in-attribute-value-regexp nil)
+ (or (match-string-no-properties 4)
+ (match-string-no-properties 5)
+ ""))))
+ (candidates (company-nxml-prepared
+ (let (attr-start attr-end colon)
+ (and (looking-back rng-in-attribute-value-regex lt-pos)
+ (setq colon (match-beginning 2)
+ attr-start (match-beginning 1)
+ attr-end (match-end 1))
+ (rng-adjust-state-for-attribute lt-pos attr-start)
+ (rng-adjust-state-for-attribute-value
+ attr-start colon attr-end)
+ (all-completions
+ arg (rng-match-possible-value-strings))))))))
+
+;;;###autoload
+(defun company-nxml (command &optional arg &rest ignored)
+ "`company-mode' completion backend for `nxml-mode'."
+ (interactive (list 'interactive))
+ (cl-case command
+ (interactive (company-begin-backend 'company-nxml))
+ (prefix (or (company-nxml-tag 'prefix)
+ (company-nxml-attribute 'prefix)
+ (company-nxml-attribute-value 'prefix)))
+ (candidates (cond
+ ((company-nxml-tag 'prefix)
+ (company-nxml-tag 'candidates arg))
+ ((company-nxml-attribute 'prefix)
+ (company-nxml-attribute 'candidates arg))
+ ((company-nxml-attribute-value 'prefix)
+ (sort (company-nxml-attribute-value 'candidates arg)
+ 'string<))))
+ (sorted t)))
+
+(provide 'company-nxml)
+;;; company-nxml.el ends here
--- /dev/null
+;;; company-oddmuse.el --- company-mode completion backend for oddmuse-mode
+
+;; Copyright (C) 2009-2011, 2013-2016, 2022 Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+
+;;; Code:
+
+(require 'company)
+(require 'cl-lib)
+(eval-when-compile (require 'yaoddmuse nil t))
+(eval-when-compile (require 'oddmuse nil t))
+
+(defvar company-oddmuse-link-regexp
+ "\\(\\<[A-Z][[:alnum:]]*\\>\\)\\|\\[\\[\\([[:alnum:]]+\\>\\|\\)")
+
+(defun company-oddmuse-get-page-table ()
+ (cl-case major-mode
+ (yaoddmuse-mode (with-no-warnings
+ (yaoddmuse-get-pagename-table yaoddmuse-wikiname)))
+ (oddmuse-mode (with-no-warnings
+ (oddmuse-make-completion-table oddmuse-wiki)))))
+
+;;;###autoload
+(defun company-oddmuse (command &optional arg &rest ignored)
+ "`company-mode' completion backend for `oddmuse-mode'."
+ (interactive (list 'interactive))
+ (cl-case command
+ (interactive (company-begin-backend 'company-oddmuse))
+ (prefix (let ((case-fold-search nil))
+ (and (memq major-mode '(oddmuse-mode yaoddmuse-mode))
+ (looking-back company-oddmuse-link-regexp (line-beginning-position))
+ (or (match-string 1)
+ (match-string 2)))))
+ (candidates (all-completions arg (company-oddmuse-get-page-table)))))
+
+(provide 'company-oddmuse)
+;;; company-oddmuse.el ends here
--- /dev/null
+(define-package "company" "20230416.2034" "Modular text completion framework"
+ '((emacs "25.1"))
+ :commit "8a78f320019574bc35b5727f95b052b27918da20" :authors
+ '(("Nikolaj Schumacher"))
+ :maintainers
+ '(("Dmitry Gutov" . "dgutovNOSPAMyandex.ru"))
+ :maintainer
+ '("Dmitry Gutov" . "dgutovNOSPAMyandex.ru")
+ :keywords
+ '("abbrev" "convenience" "matching")
+ :url "http://company-mode.github.io/")
+;; Local Variables:
+;; no-byte-compile: t
+;; End:
--- /dev/null
+;;; company-semantic.el --- company-mode completion backend using Semantic
+
+;; Copyright (C) 2009-2011, 2013-2018 Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+
+;;; Code:
+
+(require 'company)
+(require 'company-template)
+(require 'cl-lib)
+
+(defvar semantic-idle-summary-function)
+(declare-function semantic-documentation-for-tag "semantic/doc" )
+(declare-function semantic-analyze-current-context "semantic/analyze")
+(declare-function semantic-analyze-possible-completions "semantic/complete")
+(declare-function semantic-analyze-find-tags-by-prefix "semantic/analyze/fcn")
+(declare-function semantic-tag-class "semantic/tag")
+(declare-function semantic-tag-name "semantic/tag")
+(declare-function semantic-tag-start "semantic/tag")
+(declare-function semantic-tag-buffer "semantic/tag")
+(declare-function semantic-active-p "semantic")
+(declare-function semantic-format-tag-prototype "semantic/format")
+
+(defgroup company-semantic nil
+ "Completion backend using Semantic."
+ :group 'company)
+
+(defcustom company-semantic-metadata-function 'company-semantic-summary-and-doc
+ "The function turning a semantic tag into doc information."
+ :type 'function)
+
+(defcustom company-semantic-begin-after-member-access t
+ "When non-nil, automatic completion will start whenever the current
+symbol is preceded by \".\", \"->\" or \"::\", ignoring
+`company-minimum-prefix-length'.
+
+If `company-begin-commands' is a list, it should include `c-electric-lt-gt'
+and `c-electric-colon', for automatic completion right after \">\" and
+\":\"."
+ :type 'boolean)
+
+(defcustom company-semantic-insert-arguments t
+ "When non-nil, insert function arguments as a template after completion."
+ :type 'boolean
+ :package-version '(company . "0.9.0"))
+
+(defvar company-semantic-modes '(c-mode c++-mode jde-mode java-mode))
+
+(defvar-local company-semantic--current-tags nil
+ "Tags for the current context.")
+
+(defun company-semantic-documentation-for-tag (tag)
+ (when (semantic-tag-buffer tag)
+ ;; When TAG's buffer is unknown, the function below raises an error.
+ (semantic-documentation-for-tag tag)))
+
+(defun company-semantic-doc-or-summary (tag)
+ (or (company-semantic-documentation-for-tag tag)
+ (and (require 'semantic-idle nil t)
+ (require 'semantic/idle nil t)
+ (funcall semantic-idle-summary-function tag nil t))))
+
+(defun company-semantic-summary-and-doc (tag)
+ (let ((doc (company-semantic-documentation-for-tag tag))
+ (summary (funcall semantic-idle-summary-function tag nil t)))
+ (and (stringp doc)
+ (string-match "\n*\\(.*\\)$" doc)
+ (setq doc (match-string 1 doc)))
+ (concat summary
+ (when doc
+ (if (< (+ (length doc) (length summary) 4) (window-width))
+ " -- "
+ "\n"))
+ doc)))
+
+(defun company-semantic-doc-buffer (tag)
+ (let ((doc (company-semantic-documentation-for-tag tag)))
+ (when doc
+ (company-doc-buffer
+ (concat (funcall semantic-idle-summary-function tag nil t)
+ "\n"
+ doc)))))
+
+(defsubst company-semantic-completions (prefix)
+ (ignore-errors
+ (let ((completion-ignore-case nil)
+ (context (semantic-analyze-current-context)))
+ (setq company-semantic--current-tags
+ (semantic-analyze-possible-completions context 'no-unique))
+ (all-completions prefix company-semantic--current-tags))))
+
+(defun company-semantic-completions-raw (prefix)
+ (setq company-semantic--current-tags nil)
+ (dolist (tag (semantic-analyze-find-tags-by-prefix prefix))
+ (unless (eq (semantic-tag-class tag) 'include)
+ (push tag company-semantic--current-tags)))
+ (delete "" (mapcar 'semantic-tag-name company-semantic--current-tags)))
+
+(defun company-semantic-annotation (argument tags)
+ (let* ((tag (assq argument tags))
+ (kind (when tag (elt tag 1))))
+ (cl-case kind
+ (function (let* ((prototype (semantic-format-tag-prototype tag nil nil))
+ (par-pos (string-match "(" prototype)))
+ (when par-pos (substring prototype par-pos)))))))
+
+(defun company-semantic--prefix ()
+ (if company-semantic-begin-after-member-access
+ (company-grab-symbol-cons "\\.\\|->\\|::" 2)
+ (company-grab-symbol)))
+
+;;;###autoload
+(defun company-semantic (command &optional arg &rest ignored)
+ "`company-mode' completion backend using CEDET Semantic."
+ (interactive (list 'interactive))
+ (cl-case command
+ (interactive (company-begin-backend 'company-semantic))
+ (prefix (and (featurep 'semantic)
+ (semantic-active-p)
+ (memq major-mode company-semantic-modes)
+ (not (company-in-string-or-comment))
+ (or (company-semantic--prefix) 'stop)))
+ (candidates (if (and (equal arg "")
+ (not (looking-back "->\\|\\.\\|::" (- (point) 2))))
+ (company-semantic-completions-raw arg)
+ (company-semantic-completions arg)))
+ (meta (funcall company-semantic-metadata-function
+ (assoc arg company-semantic--current-tags)))
+ (annotation (company-semantic-annotation arg
+ company-semantic--current-tags))
+ (doc-buffer (company-semantic-doc-buffer
+ (assoc arg company-semantic--current-tags)))
+ ;; Because "" is an empty context and doesn't return local variables.
+ (no-cache (equal arg ""))
+ (duplicates t)
+ (location (let ((tag (assoc arg company-semantic--current-tags)))
+ (when (buffer-live-p (semantic-tag-buffer tag))
+ (cons (semantic-tag-buffer tag)
+ (semantic-tag-start tag)))))
+ (post-completion (let ((anno (company-semantic-annotation
+ arg company-semantic--current-tags)))
+ (when (and company-semantic-insert-arguments anno)
+ (insert anno)
+ (company-template-c-like-templatify (concat arg anno)))
+ ))))
+
+(provide 'company-semantic)
+;;; company-semantic.el ends here
--- /dev/null
+;;; company-template.el --- utility library for template expansion
+
+;; Copyright (C) 2009-2010, 2013-2017, 2019 Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+
+;;; Code:
+
+(require 'cl-lib)
+
+(defface company-template-field
+ '((((background dark)) (:background "yellow" :foreground "black"))
+ (((background light)) (:background "orange" :foreground "black")))
+ "Face used for editable text in template fields."
+ :group 'company-faces)
+
+(defvar company-template-forward-field-item
+ '(menu-item "" company-template-forward-field
+ :filter company-template--keymap-filter))
+
+(defvar company-template-nav-map
+ (let ((keymap (make-sparse-keymap)))
+ (define-key keymap [tab] company-template-forward-field-item)
+ (define-key keymap (kbd "TAB") company-template-forward-field-item)
+ keymap))
+
+(defvar company-template-clear-field-item
+ '(menu-item "" company-template-clear-field
+ :filter company-template--keymap-filter))
+
+(defvar company-template-field-map
+ (let ((keymap (make-sparse-keymap)))
+ (set-keymap-parent keymap company-template-nav-map)
+ (define-key keymap (kbd "C-d") company-template-clear-field-item)
+ keymap))
+
+(defvar-local company-template--buffer-templates nil)
+
+;; interactive ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun company-template-templates-at (pos)
+ (let (os)
+ (dolist (o (overlays-at pos))
+ ;; FIXME: Always return the whole list of templates?
+ ;; We remove templates not at point after every command.
+ (when (memq o company-template--buffer-templates)
+ (push o os)))
+ os))
+
+(defun company-template-move-to-first (templ)
+ (interactive)
+ (goto-char (overlay-start templ))
+ (company-template-forward-field))
+
+(defun company-template-forward-field ()
+ (interactive)
+ (let ((start (point))
+ (next-field-start (company-template-find-next-field)))
+ (push-mark)
+ (goto-char next-field-start)
+ (company-template-remove-field (company-template-field-at start))))
+
+(defun company-template-clear-field ()
+ "Clear the field at point."
+ (interactive)
+ (let ((ovl (company-template-field-at (point))))
+ (when ovl
+ (company-template-remove-field ovl t)
+ (let ((after-clear-fn
+ (overlay-get ovl 'company-template-after-clear)))
+ (when (functionp after-clear-fn)
+ (funcall after-clear-fn))))))
+
+(defun company-template--keymap-filter (cmd)
+ (unless (run-hook-with-args-until-success 'yas-keymap-disable-hook)
+ cmd))
+
+(defun company-template--after-clear-c-like-field ()
+ "Function that can be called after deleting a field of a c-like template.
+For c-like templates it is set as `after-post-fn' property on fields in
+`company-template-add-field'. If there is a next field, delete everything
+from point to it. If there is no field after point, remove preceding comma
+if present."
+ (let* ((pos (point))
+ (next-field-start (company-template-find-next-field))
+ (last-field-p (not (company-template-field-at next-field-start))))
+ (cond ((and (not last-field-p)
+ (< pos next-field-start)
+ (string-match "^[ ]*,+[ ]*$" (buffer-substring-no-properties
+ pos next-field-start)))
+ (delete-region pos next-field-start))
+ ((and last-field-p
+ (looking-back ",+[ ]*" (line-beginning-position)))
+ (delete-region (match-beginning 0) pos)))))
+
+(defun company-template-find-next-field ()
+ (let* ((start (point))
+ (templates (company-template-templates-at start))
+ (minimum (apply 'max (mapcar 'overlay-end templates)))
+ (fields (cl-loop for templ in templates
+ append (overlay-get templ 'company-template-fields))))
+ (dolist (pos (mapcar 'overlay-start fields) minimum)
+ (and pos
+ (> pos start)
+ (< pos minimum)
+ (setq minimum pos)))))
+
+(defun company-template-field-at (&optional point)
+ (cl-loop for ovl in (overlays-at (or point (point)))
+ when (overlay-get ovl 'company-template-parent)
+ return ovl))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun company-template-declare-template (beg end)
+ (let ((ov (make-overlay beg end)))
+ ;; (overlay-put ov 'face 'highlight)
+ (overlay-put ov 'keymap company-template-nav-map)
+ (overlay-put ov 'priority 101)
+ (overlay-put ov 'evaporate t)
+ (push ov company-template--buffer-templates)
+ (add-hook 'post-command-hook 'company-template-post-command nil t)
+ ov))
+
+(defun company-template-remove-template (templ)
+ (mapc 'company-template-remove-field
+ (overlay-get templ 'company-template-fields))
+ (setq company-template--buffer-templates
+ (delq templ company-template--buffer-templates))
+ (delete-overlay templ))
+
+(defun company-template-add-field (templ beg end &optional display after-clear-fn)
+ "Add new field to template TEMPL spanning from BEG to END.
+When DISPLAY is non-nil, set the respective property on the overlay.
+Leave point at the end of the field.
+AFTER-CLEAR-FN is a function that can be used to apply custom behavior
+after deleting a field in `company-template-remove-field'."
+ (cl-assert templ)
+ (when (> end (overlay-end templ))
+ (move-overlay templ (overlay-start templ) end))
+ (let ((ov (make-overlay beg end))
+ (siblings (overlay-get templ 'company-template-fields)))
+ ;; (overlay-put ov 'evaporate t)
+ (overlay-put ov 'intangible t)
+ (overlay-put ov 'face 'company-template-field)
+ (when display
+ (overlay-put ov 'display display))
+ (overlay-put ov 'company-template-parent templ)
+ (overlay-put ov 'insert-in-front-hooks '(company-template-insert-hook))
+ (when after-clear-fn
+ (overlay-put ov 'company-template-after-clear after-clear-fn))
+ (overlay-put ov 'keymap company-template-field-map)
+ (overlay-put ov 'priority 101)
+ (push ov siblings)
+ (overlay-put templ 'company-template-fields siblings)))
+
+(defun company-template-remove-field (ovl &optional clear)
+ (when (overlayp ovl)
+ (when (overlay-buffer ovl)
+ (when clear
+ (delete-region (overlay-start ovl) (overlay-end ovl)))
+ (delete-overlay ovl))
+ (let* ((templ (overlay-get ovl 'company-template-parent))
+ (siblings (overlay-get templ 'company-template-fields)))
+ (setq siblings (delq ovl siblings))
+ (overlay-put templ 'company-template-fields siblings))))
+
+(defun company-template-clean-up (&optional pos)
+ "Clean up all templates that don't contain POS."
+ (let ((local-ovs (overlays-at (or pos (point)))))
+ (dolist (templ company-template--buffer-templates)
+ (unless (memq templ local-ovs)
+ (company-template-remove-template templ)))))
+
+;; hooks ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun company-template-insert-hook (ovl after-p &rest _ignore)
+ "Called when a snippet input prompt is modified."
+ (unless after-p
+ (company-template-remove-field ovl t)))
+
+(defun company-template-post-command ()
+ (company-template-clean-up)
+ (unless company-template--buffer-templates
+ (remove-hook 'post-command-hook 'company-template-post-command t)))
+
+;; common ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun company-template-c-like-templatify (call)
+ (let* ((end (point-marker))
+ (beg (- (point) (length call)))
+ (templ (company-template-declare-template beg end))
+ paren-open paren-close)
+ (with-syntax-table (make-syntax-table (syntax-table))
+ (modify-syntax-entry ?< "(")
+ (modify-syntax-entry ?> ")")
+ (when (search-backward ")" beg t)
+ (setq paren-close (point-marker))
+ (forward-char 1)
+ (delete-region (point) end)
+ (backward-sexp)
+ (forward-char 1)
+ (setq paren-open (point-marker)))
+ (when (search-backward ">" beg t)
+ (let ((angle-close (point-marker)))
+ (forward-char 1)
+ (backward-sexp)
+ (forward-char)
+ (company-template--c-like-args templ angle-close)))
+ (when (looking-back "\\((\\*)\\)(" (line-beginning-position))
+ (delete-region (match-beginning 1) (match-end 1)))
+ (when paren-open
+ (goto-char paren-open)
+ (company-template--c-like-args templ paren-close)))
+ (if (overlay-get templ 'company-template-fields)
+ (company-template-move-to-first templ)
+ (company-template-remove-template templ)
+ (goto-char end))))
+
+(defun company-template--c-like-args (templ end)
+ (let ((last-pos (point)))
+ (while (re-search-forward "\\([^,]+\\),?" end 'move)
+ (when (zerop (car (parse-partial-sexp last-pos (point))))
+ (company-template-add-field templ last-pos (match-end 1) nil
+ #'company-template--after-clear-c-like-field)
+ (skip-chars-forward " ")
+ (setq last-pos (point))))))
+
+;; objc ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun company-template-objc-templatify (selector)
+ (let* ((end (point-marker))
+ (beg (- (point) (length selector) 1))
+ (templ (company-template-declare-template beg end))
+ (cnt 0))
+ (save-excursion
+ (goto-char beg)
+ (catch 'stop
+ (while (search-forward ":" end t)
+ (if (looking-at "\\(([^)]*)\\) ?")
+ (company-template-add-field templ (point) (match-end 1))
+ ;; Not sure which conditions this case manifests under, but
+ ;; apparently it did before, when I wrote the first test for this
+ ;; function. FIXME: Revisit it.
+ (company-template-add-field templ (point)
+ (progn
+ (insert (format "arg%d" cnt))
+ (point)))
+ (when (< (point) end)
+ (insert " "))
+ (cl-incf cnt))
+ (when (>= (point) end)
+ (throw 'stop t)))))
+ (company-template-move-to-first templ)))
+
+(provide 'company-template)
+;;; company-template.el ends here
--- /dev/null
+;;; company-tempo.el --- company-mode completion backend for tempo
+
+;; Copyright (C) 2009-2011, 2013-2016 Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+
+;;; Code:
+
+(require 'company)
+(require 'cl-lib)
+(require 'tempo)
+
+(defgroup company-tempo nil
+ "Tempo completion backend."
+ :group 'company)
+
+(defcustom company-tempo-expand nil
+ "Whether to expand a tempo tag after completion."
+ :type '(choice (const :tag "Off" nil)
+ (const :tag "On" t)))
+
+(defsubst company-tempo-lookup (match)
+ (cdr (assoc match (tempo-build-collection))))
+
+(defun company-tempo-insert (match)
+ "Replace MATCH with the expanded tempo template."
+ (search-backward match)
+ (goto-char (match-beginning 0))
+ (replace-match "")
+ (call-interactively (company-tempo-lookup match)))
+
+(defsubst company-tempo-meta (match)
+ (let ((templ (company-tempo-lookup match))
+ doc)
+ (and templ
+ (setq doc (documentation templ t))
+ (car (split-string doc "\n" t)))))
+
+;;;###autoload
+(defun company-tempo (command &optional arg &rest ignored)
+ "`company-mode' completion backend for tempo."
+ (interactive (list 'interactive))
+ (cl-case command
+ (interactive (company-begin-backend 'company-tempo))
+ (prefix (or (car (tempo-find-match-string tempo-match-finder)) ""))
+ (candidates (all-completions arg (tempo-build-collection)))
+ (kind 'snippet)
+ (meta (company-tempo-meta arg))
+ (post-completion (when company-tempo-expand (company-tempo-insert arg)))
+ (sorted t)))
+
+(provide 'company-tempo)
+;;; company-tempo.el ends here
--- /dev/null
+;;; company-tng.el --- company-mode configuration for single-button interaction
+
+;; Copyright (C) 2017-2021 Free Software Foundation, Inc.
+
+;; Author: Nikita Leshenko
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+;; company-tng (Tab and Go) allows you to perform completion using just TAB.
+;; Pressing it will both select the next completion candidate in the list and
+;; insert it into the buffer (or make it look like it's inserted, in fact).
+;;
+;; It cycles the candidates like `yank-pop' or `dabbrev-expand' or Vim:
+;; Pressing TAB selects the first item in the completion menu and inserts it in
+;; the buffer. Pressing TAB again selects the second item and replaces the
+;; "inserted" item with the second one. This can continue as long as the user
+;; wishes to cycle through the menu. You can also press S-TAB to select the
+;; previous candidate, of course.
+;;
+;; The benefits are that you only have to use one shortcut key and there is no
+;; need to confirm the entry.
+;;
+;; Usage:
+;;
+;; Enable `company-tng-mode' with:
+;;
+;; (add-hook 'after-init-hook 'company-tng-mode)
+;;
+;; in your init script. It will set up the required frontend, as well as make a
+;; number of recommended configuration changes described below.
+;;
+;; To avoid these changes, if you want to tweak everything yourself, customize
+;;`company-tng-auto-configure' to nil.
+;;
+;; We recommend to bind TAB to `company-select-next', S-TAB to
+;; `company-select-previous', and unbind RET and other now-unnecessary
+;; keys from `company-active-map':
+;;
+;; (define-key company-active-map (kbd "TAB") 'company-select-next)
+;; (define-key company-active-map (kbd "<backtab>") 'company-select-previous)
+;; (define-key company-active-map (kbd "RET") nil)
+;;
+;; Note that it's not necessary to rebind keys to use this frontend,
+;; you can use the arrow keys or M-n/M-p to select and insert
+;; candidates. You also need to decide which keys to unbind, depending
+;; on whether you want them to do the Company action or the default
+;; Emacs action (for example C-s or C-w).
+;;
+;; We recommend to disable `company-require-match' to allow free typing at any
+;; point.
+;;
+;; By default, company-tng doesn't work well with backends that insert function
+;; arguments into the buffer and (optionally) expand them into a snippet
+;; (usually performed in `post-completion' using yasnippet or company-template).
+;; In company-tng, completion candidates
+;; are inserted into the buffer as the user selects them and the completion is
+;; finished implicitly when the user continues typing after selecting a
+;; candidate. Modifying the buffer (by expanding a snippet) when the user
+;; continues typing would be surprising and undesirable, since the candidate was
+;; already inserted into the buffer.
+;;
+;; For this reason `company-tng-mode' by default disables arguments insertion
+;; for a number of popular backends. If the backend you are using is not among
+;; them, you might have to configure it not to do that yourself.
+;;
+;; YASnippet and company-tng both use TAB, which causes conflicts. The
+;; recommended way to use YASnippet with company-tng is to choose a different
+;; key for expanding a snippet and moving to the next snippet field:
+;;
+;; (define-key yas-minor-mode-map "\C-j" 'yas-expand)
+;; (define-key yas-keymap "\C-j" 'yas-next-field-or-maybe-expand)
+;; (dolist (keymap (list yas-minor-mode-map yas-keymap))
+;; (define-key keymap (kbd "TAB") nil)
+;; (define-key keymap [(tab)] nil))
+
+;;; Code:
+
+(require 'company)
+(require 'cl-lib)
+
+(defvar-local company-tng--overlay nil)
+
+;;;###autoload
+(defun company-tng-frontend (command)
+ "When the user changes the selection at least once, this
+frontend will display the candidate in the buffer as if it's
+already there and any key outside of `company-active-map' will
+confirm the selection and finish the completion."
+ (cl-case command
+ (show
+ (let ((ov (make-overlay (point) (point))))
+ (setq company-tng--overlay ov)
+ (overlay-put ov 'priority 2)))
+ (update
+ (let* ((ov company-tng--overlay)
+ (selected (and company-selection
+ (nth company-selection company-candidates)))
+ (prefix (length company-prefix)))
+ (move-overlay ov (- (point) prefix) (point))
+ (overlay-put ov
+ (if (= prefix 0) 'after-string 'display)
+ selected)))
+ (hide
+ (when company-tng--overlay
+ (delete-overlay company-tng--overlay)
+ (kill-local-variable 'company-tng--overlay)))
+ (pre-command
+ (when (and company-selection
+ (not (company--company-command-p (this-command-keys))))
+ (company--unread-this-command-keys)
+ (setq this-command 'company-complete-selection)))))
+
+(defvar company-clang-insert-arguments)
+(defvar company-semantic-insert-arguments)
+(defvar company-rtags-insert-arguments)
+(defvar lsp-enable-snippet)
+
+(defgroup company-tng nil
+ "Company Tab and Go."
+ :group 'company)
+
+(defcustom company-tng-auto-configure t
+ "Automatically apply default configure when enable `company-tng-mode'."
+ :type 'boolean)
+
+;;;###autoload
+(define-obsolete-function-alias 'company-tng-configure-default 'company-tng-mode "0.9.14"
+ "Applies the default configuration to enable company-tng.")
+
+(declare-function eglot--snippet-expansion-fn "eglot")
+
+(defvar company-tng-map
+ (let ((keymap (make-sparse-keymap)))
+ (set-keymap-parent keymap company-active-map)
+ (define-key keymap [return] nil)
+ (define-key keymap (kbd "RET") nil)
+ (define-key keymap [tab] 'company-select-next)
+ (define-key keymap (kbd "TAB") 'company-select-next)
+ (define-key keymap [backtab] 'company-select-previous)
+ (define-key keymap (kbd "S-TAB") 'company-select-previous)
+ keymap))
+
+;;;###autoload
+(define-minor-mode company-tng-mode
+ "This minor mode enables `company-tng-frontend'."
+ :init-value nil
+ :global t
+ (cond
+ (company-tng-mode
+ (setq company-frontends
+ (add-to-list 'company-frontends 'company-tng-frontend))
+ (when company-tng-auto-configure
+ (setq company-frontends '(company-tng-frontend
+ company-pseudo-tooltip-frontend
+ company-echo-metadata-frontend))
+ (setq company-require-match nil
+ company-clang-insert-arguments nil
+ company-semantic-insert-arguments nil
+ company-rtags-insert-arguments nil
+ lsp-enable-snippet nil)
+ (advice-add #'eglot--snippet-expansion-fn :override #'ignore)
+ (setq company-active-map company-tng-map))
+ (setq company-selection-default nil))
+ (t
+ (setq company-frontends
+ '(company-pseudo-tooltip-unless-just-one-frontend
+ company-preview-if-just-one-frontend
+ company-echo-metadata-frontend))
+ (when company-tng-auto-configure
+ (setq company-require-match 'company-explicit-action-p
+ company-clang-insert-arguments t
+ company-semantic-insert-arguments t
+ company-rtags-insert-arguments t
+ lsp-enable-snippet t)
+ (advice-remove #'eglot--snippet-expansion-fn #'ignore)
+ (setq company-active-map (keymap-parent company-tng-map)))
+ (setq company-selection-default 0))))
+
+(provide 'company-tng)
+;;; company-tng.el ends here
--- /dev/null
+;;; company-yasnippet.el --- company-mode completion backend for Yasnippet
+
+;; Copyright (C) 2014-2015, 2020-2021 Free Software Foundation, Inc.
+
+;; Author: Dmitry Gutov
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+
+;;; Code:
+
+(require 'company)
+(require 'cl-lib)
+
+(declare-function yas--table-hash "yasnippet")
+(declare-function yas--get-snippet-tables "yasnippet")
+(declare-function yas-expand-snippet "yasnippet")
+(declare-function yas--template-content "yasnippet")
+(declare-function yas--template-expand-env "yasnippet")
+(declare-function yas--warning "yasnippet")
+(declare-function yas-minor-mode "yasnippet")
+(declare-function yas--require-template-specific-condition-p "yasnippet")
+(declare-function yas--template-can-expand-p "yasnippet")
+(declare-function yas--template-condition "yasnippet")
+
+(defvar company-yasnippet-annotation-fn
+ (lambda (name)
+ (concat
+ (unless company-tooltip-align-annotations " -> ")
+ name))
+ "Function to format completion annotation.
+It has to accept one argument: the snippet's name.")
+
+(defun company-yasnippet--key-prefixes ()
+ ;; Mostly copied from `yas--templates-for-key-at-point'.
+ (defvar yas-key-syntaxes)
+ (save-excursion
+ (let ((original (point))
+ (methods yas-key-syntaxes)
+ prefixes
+ method)
+ (while methods
+ (unless (eq method (car methods))
+ (goto-char original))
+ (setq method (car methods))
+ (cond ((stringp method)
+ (skip-syntax-backward method)
+ (setq methods (cdr methods)))
+ ((functionp method)
+ (unless (eq (funcall method original)
+ 'again)
+ (setq methods (cdr methods))))
+ (t
+ (setq methods (cdr methods))
+ (yas--warning "Invalid element `%s' in `yas-key-syntaxes'" method)))
+ (let ((prefix (buffer-substring-no-properties (point) original)))
+ (unless (equal prefix (car prefixes))
+ (push prefix prefixes))))
+ prefixes)))
+
+(defun company-yasnippet--candidates (prefix)
+ ;; Process the prefixes in reverse: unlike Yasnippet, we look for prefix
+ ;; matches, so the longest prefix with any matches should be the most useful.
+ (cl-loop with tables = (yas--get-snippet-tables)
+ for key-prefix in (company-yasnippet--key-prefixes)
+ ;; Only consider keys at least as long as the symbol at point.
+ when (>= (length key-prefix) (length prefix))
+ thereis (company-yasnippet--completions-for-prefix prefix
+ key-prefix
+ tables)))
+
+(defun company-yasnippet--completions-for-prefix (prefix key-prefix tables)
+ (cl-mapcan
+ (lambda (table)
+ (let ((keyhash (yas--table-hash table))
+ (requirement (yas--require-template-specific-condition-p))
+ res)
+ (when keyhash
+ (maphash
+ (lambda (key value)
+ (when (and (stringp key)
+ (string-prefix-p key-prefix key))
+ (maphash
+ (lambda (name template)
+ (when (yas--template-can-expand-p
+ (yas--template-condition template) requirement)
+ (push
+ (propertize key
+ 'yas-annotation name
+ 'yas-template template
+ 'yas-prefix-offset (- (length key-prefix)
+ (length prefix)))
+ res)))
+ value)))
+ keyhash))
+ res))
+ tables))
+
+(defun company-yasnippet--doc (arg)
+ (let ((template (get-text-property 0 'yas-template arg))
+ (mode major-mode)
+ (file-name (buffer-file-name)))
+ (defvar yas-prompt-functions)
+ (with-current-buffer (company-doc-buffer)
+ (let ((buffer-file-name file-name))
+ (yas-minor-mode 1)
+ (setq-local yas-prompt-functions '(yas-no-prompt))
+ (condition-case error
+ (yas-expand-snippet (yas--template-content template))
+ (error
+ (message "%s" (error-message-string error))))
+ (delay-mode-hooks
+ (let ((inhibit-message t))
+ (if (eq mode 'web-mode)
+ (progn
+ (setq mode 'html-mode)
+ (funcall mode))
+ (funcall mode)))
+ (ignore-errors (font-lock-ensure))))
+ (current-buffer))))
+
+;;;###autoload
+(defun company-yasnippet (command &optional arg &rest ignore)
+ "`company-mode' backend for `yasnippet'.
+
+This backend should be used with care, because as long as there are
+snippets defined for the current major mode, this backend will always
+shadow backends that come after it. Recommended usages:
+
+* In a buffer-local value of `company-backends', grouped with a backend or
+ several that provide actual text completions.
+
+ (add-hook \\='js-mode-hook
+ (lambda ()
+ (set (make-local-variable \\='company-backends)
+ \\='((company-dabbrev-code company-yasnippet)))))
+
+* After keyword `:with', grouped with other backends.
+
+ (push \\='(company-semantic :with company-yasnippet) company-backends)
+
+* Not in `company-backends', just bound to a key.
+
+ (global-set-key (kbd \"C-c y\") \\='company-yasnippet)
+"
+ (interactive (list 'interactive))
+ (cl-case command
+ (interactive (company-begin-backend 'company-yasnippet))
+ (prefix
+ ;; Should probably use `yas--current-key', but that's bound to be slower.
+ ;; How many trigger keys start with non-symbol characters anyway?
+ (and (bound-and-true-p yas-minor-mode)
+ (company-grab-symbol)))
+ (annotation
+ (funcall company-yasnippet-annotation-fn
+ (get-text-property 0 'yas-annotation arg)))
+ (candidates (company-yasnippet--candidates arg))
+ (doc-buffer (company-yasnippet--doc arg))
+ (no-cache t)
+ (kind 'snippet)
+ (post-completion
+ (let ((template (get-text-property 0 'yas-template arg))
+ (prefix-offset (get-text-property 0 'yas-prefix-offset arg)))
+ (yas-expand-snippet (yas--template-content template)
+ (- (point) (length arg) prefix-offset)
+ (point)
+ (yas--template-expand-env template))))))
+
+(provide 'company-yasnippet)
+;;; company-yasnippet.el ends here
--- /dev/null
+;;; company.el --- Modular text completion framework -*- lexical-binding: t -*-
+
+;; Copyright (C) 2009-2022 Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+;; Maintainer: Dmitry Gutov <dgutovNOSPAMyandex.ru>
+;; URL: http://company-mode.github.io/
+;; Version: 0.9.13
+;; Keywords: abbrev, convenience, matching
+;; Package-Requires: ((emacs "25.1"))
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+
+;;; Commentary:
+;;
+;; Company is a modular completion framework. Modules for retrieving completion
+;; candidates are called backends, modules for displaying them are frontends.
+;;
+;; Company comes with many backends, e.g. `company-etags'. These are
+;; distributed in separate files and can be used individually.
+;;
+;; Enable `company-mode' in all buffers with M-x global-company-mode. For
+;; further information look at the documentation for `company-mode' (C-h f
+;; company-mode RET).
+;;
+;; If you want to start a specific backend, call it interactively or use
+;; `company-begin-backend'. For example:
+;; M-x company-abbrev will prompt for and insert an abbrev.
+;;
+;; To write your own backend, look at the documentation for `company-backends'.
+;; Here is a simple example completing "foo":
+;;
+;; (defun company-my-backend (command &optional arg &rest ignored)
+;; (interactive (list 'interactive))
+;; (pcase command
+;; (`interactive (company-begin-backend 'company-my-backend))
+;; (`prefix (company-grab-symbol))
+;; (`candidates (list "foobar" "foobaz" "foobarbaz"))
+;; (`meta (format "This value is named %s" arg))))
+;;
+;; Sometimes it is a good idea to mix several backends together, for example to
+;; enrich gtags with dabbrev-code results (to emulate local variables). To do
+;; this, add a list with both backends as an element in `company-backends'.
+;;
+;;; Change Log:
+;;
+;; See NEWS.md in the repository.
+
+;;; Code:
+
+(require 'cl-lib)
+(require 'subr-x)
+(require 'pcase)
+
+(defgroup company nil
+ "Extensible inline text completion mechanism."
+ :group 'abbrev
+ :group 'convenience
+ :group 'matching
+ :link '(custom-manual "(company) Top"))
+
+(defgroup company-faces nil
+ "Faces used by Company."
+ :group 'company
+ :group 'faces)
+
+(defface company-tooltip
+ '((((class color) (min-colors 88) (background light))
+ (:foreground "black" :background "cornsilk"))
+ (((class color) (min-colors 88) (background dark))
+ (:background "gray26"))
+ (t (:foreground "black" :background "yellow")))
+ "Face used for the tooltip.")
+
+(defface company-tooltip-selection
+ '((((class color) (min-colors 88) (background light))
+ (:background "light blue"))
+ (((class color) (min-colors 88) (background dark))
+ (:background "gray31"))
+ (t (:background "green")))
+ "Face used for the selection in the tooltip.")
+
+(defface company-tooltip-deprecated
+ '((t (:strike-through t)))
+ "Face used for the deprecated items.")
+
+(defface company-tooltip-search
+ '((default :inherit highlight))
+ "Face used for the search string in the tooltip.")
+
+(defface company-tooltip-search-selection
+ '((default :inherit highlight))
+ "Face used for the search string inside the selection in the tooltip.")
+
+(defface company-tooltip-mouse
+ '((default :inherit highlight))
+ "Face used for the tooltip item under the mouse.")
+
+(defface company-tooltip-common
+ '((((background light))
+ :foreground "darkred")
+ (((background dark))
+ :foreground "pale turquoise"))
+ "Face used for the common completion in the tooltip.")
+
+(defface company-tooltip-common-selection
+ '((default :inherit company-tooltip-common))
+ "Face used for the selected common completion in the tooltip.")
+
+(defface company-tooltip-annotation
+ '((((background light))
+ :foreground "firebrick4")
+ (((background dark))
+ :foreground "LightCyan3"))
+ "Face used for the completion annotation in the tooltip.")
+
+(defface company-tooltip-annotation-selection
+ '((default :inherit company-tooltip-annotation))
+ "Face used for the selected completion annotation in the tooltip.")
+
+(defface company-tooltip-quick-access
+ '((default :inherit company-tooltip-annotation))
+ "Face used for the quick-access hints shown in the tooltip."
+ :package-version '(company . "0.9.14"))
+
+(defface company-tooltip-quick-access-selection
+ '((default :inherit company-tooltip-annotation-selection))
+ "Face used for the selected quick-access hints shown in the tooltip."
+ :package-version '(company . "0.9.14"))
+
+(define-obsolete-face-alias
+ 'company-scrollbar-fg
+ 'company-tooltip-scrollbar-thumb
+ "0.9.14")
+
+(defface company-tooltip-scrollbar-thumb
+ '((((background light))
+ :background "darkred")
+ (((background dark))
+ :background "gray33"))
+ "Face used for the tooltip scrollbar thumb (bar).")
+
+(define-obsolete-face-alias
+ 'company-scrollbar-bg
+ 'company-tooltip-scrollbar-track
+ "0.9.14")
+
+(defface company-tooltip-scrollbar-track
+ '((((background light))
+ :background "wheat")
+ (((background dark))
+ :background "gray28"))
+ "Face used for the tooltip scrollbar track (trough).")
+
+(defface company-preview
+ '((default :inherit (company-tooltip-selection company-tooltip)))
+ "Face used for the completion preview.")
+
+(defface company-preview-common
+ '((default :inherit company-tooltip-common-selection))
+ "Face used for the common part of the completion preview.")
+
+(defface company-preview-search
+ '((default :inherit company-tooltip-common-selection))
+ "Face used for the search string in the completion preview.")
+
+(defface company-echo nil
+ "Face used for completions in the echo area.")
+
+(defface company-echo-common
+ '((((background light)) (:foreground "firebrick4"))
+ (((background dark)) (:foreground "firebrick1")))
+ "Face used for the common part of completions in the echo area.")
+
+;; Too lazy to re-add :group to all defcustoms down below.
+(setcdr (assoc load-file-name custom-current-group-alist)
+ 'company)
+
+(defun company-frontends-set (variable value)
+ ;; Uniquify.
+ (let ((value (delete-dups (copy-sequence value))))
+ (and (or (and (memq 'company-pseudo-tooltip-unless-just-one-frontend value)
+ (memq 'company-pseudo-tooltip-frontend value))
+ (and (memq 'company-pseudo-tooltip-unless-just-one-frontend-with-delay value)
+ (memq 'company-pseudo-tooltip-frontend value))
+ (and (memq 'company-pseudo-tooltip-unless-just-one-frontend-with-delay value)
+ (memq 'company-pseudo-tooltip-unless-just-one-frontend value)))
+ (user-error "Pseudo tooltip frontend cannot be used more than once"))
+ (and (or (and (memq 'company-preview-if-just-one-frontend value)
+ (memq 'company-preview-frontend value))
+ (and (memq 'company-preview-if-just-one-frontend value)
+ (memq 'company-preview-common-frontend value))
+ (and (memq 'company-preview-frontend value)
+ (memq 'company-preview-common-frontend value))
+ )
+ (user-error "Preview frontend cannot be used twice"))
+ (and (memq 'company-echo value)
+ (memq 'company-echo-metadata-frontend value)
+ (user-error "Echo area cannot be used twice"))
+ ;; Preview must come last.
+ (dolist (f '(company-preview-if-just-one-frontend company-preview-frontend company-preview-common-frontend))
+ (when (cdr (memq f value))
+ (setq value (append (delq f value) (list f)))))
+ (set variable value)))
+
+(defcustom company-frontends '(company-pseudo-tooltip-unless-just-one-frontend
+ company-preview-if-just-one-frontend
+ company-echo-metadata-frontend)
+ "The list of active frontends (visualizations).
+Each frontend is a function that takes one argument. It is called with
+one of the following arguments:
+
+`show': When the visualization should start.
+
+`hide': When the visualization should end.
+
+`update': When the data has been updated.
+
+`pre-command': Before every command that is executed while the
+visualization is active.
+
+`post-command': After every command that is executed while the
+visualization is active.
+
+`unhide': When an asynchronous backend is waiting for its completions.
+Only needed in frontends which hide their visualizations in `pre-command'
+for technical reasons.
+
+The visualized data is stored in `company-prefix', `company-candidates',
+`company-common', `company-selection', `company-point' and
+`company-search-string'."
+ :set 'company-frontends-set
+ :type '(repeat (choice (const :tag "echo" company-echo-frontend)
+ (const :tag "echo, strip common"
+ company-echo-strip-common-frontend)
+ (const :tag "show echo meta-data in echo"
+ company-echo-metadata-frontend)
+ (const :tag "pseudo tooltip"
+ company-pseudo-tooltip-frontend)
+ (const :tag "pseudo tooltip, multiple only"
+ company-pseudo-tooltip-unless-just-one-frontend)
+ (const :tag "pseudo tooltip, multiple only, delayed"
+ company-pseudo-tooltip-unless-just-one-frontend-with-delay)
+ (const :tag "preview" company-preview-frontend)
+ (const :tag "preview, unique only"
+ company-preview-if-just-one-frontend)
+ (const :tag "preview, common"
+ company-preview-common-frontend)
+ (function :tag "custom function" nil))))
+
+(defcustom company-tooltip-limit 10
+ "The maximum number of candidates in the tooltip."
+ :type 'integer)
+
+(defcustom company-tooltip-minimum 6
+ "Ensure visibility of this number of candidates.
+When that many lines are not available between point and the bottom of the
+window, display the tooltip above point."
+ :type 'integer)
+
+(defcustom company-tooltip-minimum-width 0
+ "The minimum width of the tooltip's inner area.
+This doesn't include the margins and the scroll bar."
+ :type 'integer
+ :package-version '(company . "0.8.0"))
+
+(defcustom company-tooltip-maximum-width most-positive-fixnum
+ "The maximum width of the tooltip's inner area.
+This doesn't include the margins and the scroll bar."
+ :type 'integer
+ :package-version '(company . "0.9.5"))
+
+(defcustom company-tooltip-width-grow-only nil
+ "When non-nil, the tooltip width is not allowed to decrease."
+ :type 'boolean
+ :package-version '(company . "0.9.14"))
+
+(defcustom company-tooltip-margin 1
+ "Width of margin columns to show around the toolip."
+ :type 'integer)
+
+(defcustom company-tooltip-offset-display 'scrollbar
+ "Method using which the tooltip displays scrolling position.
+`scrollbar' means draw a scrollbar to the right of the items.
+`lines' means wrap items in lines with \"before\" and \"after\" counters."
+ :type '(choice (const :tag "Scrollbar" scrollbar)
+ (const :tag "Two lines" lines)))
+
+(defcustom company-tooltip-align-annotations nil
+ "When non-nil, align annotations to the right tooltip border."
+ :type 'boolean
+ :package-version '(company . "0.7.1"))
+
+(defcustom company-tooltip-flip-when-above nil
+ "Whether to flip the tooltip when it's above the current line."
+ :type 'boolean
+ :package-version '(company . "0.8.1"))
+
+(defcustom company-tooltip-annotation-padding nil
+ "Non-nil to specify the padding before annotation.
+
+Depending on the value of `company-tooltip-align-annotations', the default
+padding is either 0 or 1 space. This variable allows to override that
+value to increase the padding. When annotations are right-aligned, it sets
+the minimum padding, and otherwise just the constant one."
+ :type 'number
+ :package-version '(company "0.9.14"))
+
+(defvar company-safe-backends
+ '((company-abbrev . "Abbrev")
+ (company-bbdb . "BBDB")
+ (company-capf . "completion-at-point-functions")
+ (company-clang . "Clang")
+ (company-cmake . "CMake")
+ (company-css . "CSS (obsolete backend)")
+ (company-dabbrev . "dabbrev for plain text")
+ (company-dabbrev-code . "dabbrev for code")
+ (company-elisp . "Emacs Lisp (obsolete backend)")
+ (company-etags . "etags")
+ (company-files . "Files")
+ (company-gtags . "GNU Global")
+ (company-ispell . "Ispell")
+ (company-keywords . "Programming language keywords")
+ (company-nxml . "nxml (obsolete backend)")
+ (company-oddmuse . "Oddmuse")
+ (company-semantic . "Semantic")
+ (company-tempo . "Tempo templates")))
+(put 'company-safe-backends 'risky-local-variable t)
+
+(defun company-safe-backends-p (backends)
+ (and (consp backends)
+ (not (cl-dolist (backend backends)
+ (unless (if (consp backend)
+ (company-safe-backends-p backend)
+ (assq backend company-safe-backends))
+ (cl-return t))))))
+
+(defcustom company-backends `(company-bbdb
+ ,@(unless (version<= "26" emacs-version)
+ (list 'company-nxml))
+ ,@(unless (version<= "26" emacs-version)
+ (list 'company-css))
+ company-semantic
+ company-cmake
+ company-capf
+ company-clang
+ company-files
+ (company-dabbrev-code company-gtags company-etags
+ company-keywords)
+ company-oddmuse company-dabbrev)
+ "The list of active backends (completion engines).
+
+Only one backend is used at a time. The choice depends on the order of
+the items in this list, and on the values they return in response to the
+`prefix' command (see below). But a backend can also be a \"grouped\"
+one (see below).
+
+`company-begin-backend' can be used to start a specific backend,
+`company-other-backend' will skip to the next matching backend in the list.
+
+Each backend is a function that takes a variable number of arguments.
+The first argument is the command requested from the backend. It is one
+of the following:
+
+`prefix': The backend should return the text to be completed. It must be
+text immediately before point. Returning nil from this command passes
+control to the next backend. The function should return `stop' if it
+should complete but cannot (e.g. when in the middle of a symbol).
+Instead of a string, the backend may return a cons (PREFIX . LENGTH)
+where LENGTH is a number used in place of PREFIX's length when
+comparing against `company-minimum-prefix-length'. LENGTH can also
+be just t, and in the latter case the test automatically succeeds.
+
+`candidates': The second argument is the prefix to be completed. The
+return value should be a list of candidates that match the prefix.
+
+Non-prefix matches are also supported (candidates that don't start with the
+prefix, but match it in some backend-defined way). Backends that use this
+feature must disable cache (return t to `no-cache') and might also want to
+respond to `match'.
+
+Optional commands
+=================
+
+`sorted': Return t here to indicate that the candidates are sorted and will
+not need to be sorted again.
+
+`duplicates': If non-nil, company will take care of removing duplicates
+from the list.
+
+`no-cache': Usually company doesn't ask for candidates again as completion
+progresses, unless the backend returns t for this command. The second
+argument is the latest prefix.
+
+`ignore-case': Return t here if the backend returns case-insensitive
+matches. This value is used to determine the longest common prefix (as
+used in `company-complete-common'), and to filter completions when fetching
+them from cache.
+
+`meta': The second argument is a completion candidate. Return a (short)
+documentation string for it.
+
+`doc-buffer': The second argument is a completion candidate. Return a
+buffer with documentation for it. Preferably use `company-doc-buffer'. If
+not all buffer contents pertain to this candidate, return a cons of buffer
+and window start position.
+
+`location': The second argument is a completion candidate. Return a cons
+of buffer and buffer location, or of file and line number where the
+completion candidate was defined.
+
+`annotation': The second argument is a completion candidate. Return a
+string to be displayed inline with the candidate in the popup. If
+duplicates are removed by company, candidates with equal string values will
+be kept if they have different annotations. For that to work properly,
+backends should store the related information on candidates using text
+properties.
+
+`deprecated': The second argument is a completion candidate. Return
+non-nil if the completion candidate is deprecated.
+
+`match': The second argument is a completion candidate. Return a positive
+integer, the index after the end of text matching `prefix' within the
+candidate string. Alternatively, return a list of (CHUNK-START
+. CHUNK-END) elements, where CHUNK-START and CHUNK-END are indexes within
+the candidate string. The corresponding regions are be used when rendering
+the popup. This command only makes sense for backends that provide
+non-prefix completion.
+
+`require-match': If this returns t, the user is not allowed to enter
+anything not offered as a candidate. Please don't use that value in normal
+backends. The default value nil gives the user that choice with
+`company-require-match'. Return value `never' overrides that option the
+other way around (using that value will indicate that the returned set of
+completions is often incomplete, so this behavior will not be useful).
+
+`init': Called once for each buffer. The backend can check for external
+programs and files and load any required libraries. Raising an error here
+will show up in message log once, and the backend will not be used for
+completion.
+
+`post-completion': Called after a completion candidate has been inserted
+into the buffer. The second argument is the candidate. Can be used to
+modify it, e.g. to expand a snippet.
+
+`kind': The second argument is a completion candidate. Return a symbol
+describing the kind of the candidate. Refer to `company-vscode-icons-mapping'
+for the possible values.
+
+The backend should return nil for all commands it does not support or
+does not know about. It should also be callable interactively and use
+`company-begin-backend' to start itself in that case.
+
+Grouped backends
+================
+
+An element of `company-backends' can also be a list of backends. The
+completions from backends in such groups are merged, but only from those
+backends which return the same `prefix'.
+
+If a backend command takes a candidate as an argument (e.g. `meta'), the
+call is dispatched to the backend the candidate came from. In other
+cases (except for `duplicates' and `sorted'), the first non-nil value among
+all the backends is returned.
+
+The group can also contain keywords. Currently, `:with' and `:separate'
+keywords are defined. If the group contains keyword `:with', the backends
+listed after this keyword are ignored for the purpose of the `prefix'
+command. If the group contains keyword `:separate', the candidates that
+come from different backends are sorted separately in the combined list.
+
+Asynchronous backends
+=====================
+
+The return value of each command can also be a cons (:async . FETCHER)
+where FETCHER is a function of one argument, CALLBACK. When the data
+arrives, FETCHER must call CALLBACK and pass it the appropriate return
+value, as described above. That call must happen in the same buffer as
+where completion was initiated.
+
+True asynchronous operation is only supported for command `candidates', and
+only during idle completion. Other commands will block the user interface,
+even if the backend uses the asynchronous calling convention."
+ :type `(repeat
+ (choice
+ :tag "backend"
+ ,@(mapcar (lambda (b) `(const :tag ,(cdr b) ,(car b)))
+ company-safe-backends)
+ (symbol :tag "User defined")
+ (repeat :tag "Merged backends"
+ (choice :tag "backend"
+ ,@(mapcar (lambda (b)
+ `(const :tag ,(cdr b) ,(car b)))
+ company-safe-backends)
+ (const :tag "With" :with)
+ (symbol :tag "User defined"))))))
+
+(put 'company-backends 'safe-local-variable 'company-safe-backends-p)
+
+(defcustom company-transformers nil
+ "Functions to change the list of candidates received from backends.
+
+Each function gets called with the return value of the previous one.
+The first one gets passed the list of candidates, already sorted and
+without duplicates."
+ :type '(choice
+ (const :tag "None" nil)
+ (const :tag "Sort by occurrence" (company-sort-by-occurrence))
+ (const :tag "Sort by backend importance"
+ (company-sort-by-backend-importance))
+ (const :tag "Prefer case sensitive prefix"
+ (company-sort-prefer-same-case-prefix))
+ (repeat :tag "User defined" function)))
+
+(defcustom company-completion-started-hook nil
+ "Hook run when company starts completing.
+The hook is called with one argument that is non-nil if the completion was
+started manually."
+ :type 'hook)
+
+(defcustom company-completion-cancelled-hook nil
+ "Hook run when company cancels completing.
+The hook is called with one argument that is non-nil if the completion was
+aborted manually."
+ :type 'hook)
+
+(defcustom company-completion-finished-hook nil
+ "Hook run when company successfully completes.
+The hook is called with the selected candidate as an argument.
+
+If you indend to use it to post-process candidates from a specific
+backend, consider using the `post-completion' command instead."
+ :type 'hook)
+
+(defcustom company-after-completion-hook nil
+ "Hook run at the end of completion, successful or not.
+The hook is called with one argument which is either a string or a symbol."
+ :type 'hook)
+
+(defcustom company-minimum-prefix-length 3
+ "The minimum prefix length for idle completion."
+ :type '(integer :tag "prefix length"))
+
+(defcustom company-abort-manual-when-too-short nil
+ "If enabled, cancel a manually started completion when the prefix gets
+shorter than both `company-minimum-prefix-length' and the length of the
+prefix it was started from."
+ :type 'boolean
+ :package-version '(company . "0.8.0"))
+
+(defcustom company-abort-on-unique-match t
+ "If non-nil, typing a full unique match aborts completion.
+
+You can still invoke `company-complete' manually to run the
+`post-completion' handler, though.
+
+If it's nil, completion will remain active until you type a prefix that
+doesn't match anything or finish it manually, e.g. with RET."
+ :type 'boolean)
+
+(defcustom company-require-match 'company-explicit-action-p
+ "If enabled, disallow non-matching input.
+This can be a function do determine if a match is required.
+
+This can be overridden by the backend, if it returns t or `never' to
+`require-match'. `company-insertion-on-trigger' also takes precedence over
+this."
+ :type '(choice (const :tag "Off" nil)
+ (function :tag "Predicate function")
+ (const :tag "On, if user interaction took place"
+ company-explicit-action-p)
+ (const :tag "On" t)))
+
+(define-obsolete-variable-alias
+ 'company-auto-complete
+ 'company-insertion-on-trigger
+ "0.9.14")
+
+(define-obsolete-variable-alias
+ 'company-auto-commit
+ 'company-insertion-on-trigger
+ "0.9.14")
+
+(defcustom company-insertion-on-trigger nil
+ "If enabled, allow triggering insertion of the selected candidate.
+This can also be a predicate function, for example,
+`company-explicit-action-p'.
+
+See `company-insertion-triggers' for more details on how to define
+triggers."
+ :type '(choice (const :tag "Off" nil)
+ (function :tag "Predicate function")
+ (const :tag "On, if user interaction took place"
+ company-explicit-action-p)
+ (const :tag "On" t))
+ :package-version '(company . "0.9.14"))
+
+(define-obsolete-variable-alias
+ 'company-auto-complete-chars
+ 'company-insertion-triggers
+ "0.9.14")
+
+(define-obsolete-variable-alias
+ 'company-auto-commit-chars
+ 'company-insertion-triggers
+ "0.9.14")
+
+(defcustom company-insertion-triggers '(?\ ?\) ?.)
+ "Determine triggers for `company-insertion-on-trigger'.
+
+If this is a string, then each character in it can trigger insertion of the
+selected candidate. If it is a list of syntax description characters (see
+`modify-syntax-entry'), then characters with any of those syntaxes can act
+as triggers.
+
+This can also be a function, which is called with the new input. To
+trigger insertion, the function should return a non-nil value.
+
+Note that a character that is part of a valid completion never triggers
+insertion."
+ :type '(choice (string :tag "Characters")
+ (set :tag "Syntax"
+ (const :tag "Whitespace" ?\ )
+ (const :tag "Symbol" ?_)
+ (const :tag "Opening parentheses" ?\()
+ (const :tag "Closing parentheses" ?\))
+ (const :tag "Word constituent" ?w)
+ (const :tag "Punctuation." ?.)
+ (const :tag "String quote." ?\")
+ (const :tag "Paired delimiter." ?$)
+ (const :tag "Expression quote or prefix operator." ?\')
+ (const :tag "Comment starter." ?<)
+ (const :tag "Comment ender." ?>)
+ (const :tag "Character-quote." ?/)
+ (const :tag "Generic string fence." ?|)
+ (const :tag "Generic comment fence." ?!))
+ (function :tag "Predicate function"))
+ :package-version '(company . "0.9.14"))
+
+(defcustom company-idle-delay .2
+ "The idle delay in seconds until completion starts automatically.
+The prefix still has to satisfy `company-minimum-prefix-length' before that
+happens. The value of nil means no idle completion."
+ :type '(choice (const :tag "never (nil)" nil)
+ (const :tag "immediate (0)" 0)
+ (function :tag "Predicate function")
+ (number :tag "seconds")))
+
+(defcustom company-tooltip-idle-delay .5
+ "The idle delay in seconds until tooltip is shown when using
+`company-pseudo-tooltip-unless-just-one-frontend-with-delay'."
+ :type '(choice (const :tag "never (nil)" nil)
+ (const :tag "immediate (0)" 0)
+ (number :tag "seconds")))
+
+(defcustom company-begin-commands '(self-insert-command
+ org-self-insert-command
+ orgtbl-self-insert-command
+ c-scope-operator
+ c-electric-colon
+ c-electric-lt-gt
+ c-electric-slash)
+ "A list of commands after which idle completion is allowed.
+If this is t, it can show completions after any command except a few from a
+pre-defined list. See `company-idle-delay'.
+
+Alternatively, any command with a non-nil `company-begin' property is
+treated as if it was on this list."
+ :type '(choice (const :tag "Any command" t)
+ (const :tag "Self insert command" (self-insert-command))
+ (repeat :tag "Commands" function))
+ :package-version '(company . "0.8.4"))
+
+(defcustom company-continue-commands '(not save-buffer save-some-buffers
+ save-buffers-kill-terminal
+ save-buffers-kill-emacs
+ completion-at-point)
+ "A list of commands that are allowed during completion.
+If this is t, or if `company-begin-commands' is t, any command is allowed.
+Otherwise, the value must be a list of symbols. If it starts with `not',
+the cdr is the list of commands that abort completion. Otherwise, all
+commands except those in that list, or in `company-begin-commands', or
+commands in the `company-' namespace, abort completion."
+ :type '(choice (const :tag "Any command" t)
+ (cons :tag "Any except"
+ (const not)
+ (repeat :tag "Commands" function))
+ (repeat :tag "Commands" function)))
+
+(defun company-custom--set-quick-access (option value)
+ "Re-bind quick-access key sequences on OPTION VALUE change."
+ (when (boundp 'company-active-map)
+ (company-keymap--unbind-quick-access company-active-map))
+ (when (boundp 'company-search-map)
+ (company-keymap--unbind-quick-access company-search-map))
+ (custom-set-default option value)
+ (when (boundp 'company-active-map)
+ (company-keymap--bind-quick-access company-active-map))
+ (when (boundp 'company-search-map)
+ (company-keymap--bind-quick-access company-search-map)))
+
+(defcustom company-quick-access-keys '("1" "2" "3" "4" "5" "6" "7" "8" "9" "0")
+ "Character strings used as a part of quick-access key sequences.
+To change this value without Customize interface, use `customize-set-variable'.
+
+To change the quick-access key sequences modifier, customize
+`company-quick-access-modifier'.
+
+If `company-show-quick-access' is non-nil, show quick-access hints
+beside the candidates."
+ :set #'company-custom--set-quick-access
+ :type '(choice
+ (const :tag "Digits" ("1" "2" "3" "4" "5" "6" "7" "8" "9" "0"))
+ (const :tag "QWERTY home row" ("a" "s" "d" "f" "g" "h" "j" "k" "l" ";"))
+ ;; TODO un-comment on removal of `M-n' `company--select-next-and-warn'.
+ ;; (const :tag "Dvorak home row" ("a" "o" "e" "u" "i" "d" "h" "t" "n" "s"))
+ (repeat :tag "User defined" string))
+ :package-version '(company . "0.9.14"))
+
+(defcustom company-quick-access-modifier 'meta
+ "Modifier key used for quick-access keys sequences.
+To change this value without Customize interface, use `customize-set-variable'.
+See `company-quick-access-keys' for more details."
+ :set #'company-custom--set-quick-access
+ :type '(choice (const :tag "Meta key" meta)
+ (const :tag "Super key" super)
+ (const :tag "Hyper key" hyper)
+ (const :tag "Control key" control))
+ :package-version '(company . "0.9.14"))
+
+(defun company-keymap--quick-access-modifier ()
+ "Return string representation of the `company-quick-access-modifier'."
+ (if-let ((modifier (assoc-default company-quick-access-modifier
+ '((meta . "M")
+ (super . "s")
+ (hyper . "H")
+ (control . "C")))))
+ modifier
+ (warn "company-quick-access-modifier value unknown: %S"
+ company-quick-access-modifier)
+ "M"))
+
+(defun company-keymap--unbind-quick-access (keymap)
+ (let ((modifier (company-keymap--quick-access-modifier)))
+ (dolist (key company-quick-access-keys)
+ (let ((key-seq (company-keymap--kbd-quick-access modifier key)))
+ (when (equal (lookup-key keymap key-seq) 'company-complete-quick-access)
+ (define-key keymap key-seq nil))))))
+
+(defun company-keymap--bind-quick-access (keymap)
+ (let ((modifier (company-keymap--quick-access-modifier)))
+ (dolist (key company-quick-access-keys)
+ (let ((key-seq (company-keymap--kbd-quick-access modifier key)))
+ (if (lookup-key keymap key-seq)
+ (warn "Key sequence %s already bound" (key-description key-seq))
+ (define-key keymap key-seq #'company-complete-quick-access))))))
+
+(defun company-keymap--kbd-quick-access (modifier key)
+ (kbd (format "%s-%s" modifier key)))
+
+(define-obsolete-variable-alias
+ 'company-show-numbers
+ 'company-show-quick-access
+ "0.9.14")
+
+(defcustom company-show-quick-access nil
+ "If non-nil, show quick-access hints beside the candidates.
+
+For a tooltip frontend, non-nil value enables a column with the hints
+on the right side of the tooltip, unless the configured value is `left'.
+
+To change the quick-access key bindings, customize `company-quick-access-keys'
+and `company-quick-access-modifier'.
+
+To change the shown quick-access hints, customize
+`company-quick-access-hint-function'."
+ :type '(choice (const :tag "off" nil)
+ (const :tag "left" left)
+ (const :tag "on" t)))
+
+(defcustom company-show-numbers-function nil
+ "Function called to get quick-access numbers for the first ten candidates.
+
+The function receives the candidate number (starting from 1) and should
+return a string prefixed with one space."
+ :type 'function)
+(make-obsolete-variable
+ 'company-show-numbers-function
+ "use `company-quick-access-hint-function' instead,
+but adjust the expected values appropriately."
+ "0.9.14")
+
+(defcustom company-quick-access-hint-function #'company-quick-access-hint-key
+ "Function called to get quick-access hints for the candidates.
+
+The function receives a candidate's 0-based number
+and should return a string.
+See `company-show-quick-access' for more details."
+ :type 'function)
+
+(defun company-quick-access-hint-key (candidate)
+ "Return a quick-access key for the CANDIDATE number.
+This is a default value of `company-quick-access-hint-function'."
+ (if company-show-numbers-function
+ (funcall company-show-numbers-function (1+ candidate))
+ (format "%s"
+ (if (< candidate (length company-quick-access-keys))
+ (nth candidate company-quick-access-keys)
+ ""))))
+
+(defcustom company-selection-wrap-around nil
+ "If enabled, selecting item before first or after last wraps around."
+ :type '(choice (const :tag "off" nil)
+ (const :tag "on" t)))
+
+(defcustom company-async-redisplay-delay 0.005
+ "Delay before redisplay when fetching candidates asynchronously.
+
+You might want to set this to a higher value if your backends respond
+quickly, to avoid redisplaying twice per each typed character."
+ :type 'number)
+
+(defvar company-async-wait 0.03
+ "Pause between checks to see if the value's been set when turning an
+asynchronous call into synchronous.")
+
+(defvar company-async-timeout 2
+ "Maximum wait time for a value to be set during asynchronous call.")
+
+;;; mode ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defvar company-mode-map (make-sparse-keymap)
+ "Keymap used by `company-mode'.")
+
+(defvar company-active-map
+ (let ((keymap (make-sparse-keymap)))
+ (define-key keymap "\e\e\e" 'company-abort)
+ (define-key keymap "\C-g" 'company-abort)
+ (define-key keymap (kbd "M-n") 'company--select-next-and-warn)
+ (define-key keymap (kbd "M-p") 'company--select-previous-and-warn)
+ (define-key keymap (kbd "C-n") 'company-select-next-or-abort)
+ (define-key keymap (kbd "C-p") 'company-select-previous-or-abort)
+ (define-key keymap (kbd "<down>") 'company-select-next-or-abort)
+ (define-key keymap (kbd "<up>") 'company-select-previous-or-abort)
+ (define-key keymap [remap scroll-up-command] 'company-next-page)
+ (define-key keymap [remap scroll-down-command] 'company-previous-page)
+ (define-key keymap [down-mouse-1] 'ignore)
+ (define-key keymap [down-mouse-3] 'ignore)
+ (define-key keymap [mouse-1] 'company-complete-mouse)
+ (define-key keymap [mouse-3] 'company-select-mouse)
+ (define-key keymap [up-mouse-1] 'ignore)
+ (define-key keymap [up-mouse-3] 'ignore)
+ (define-key keymap [return] 'company-complete-selection)
+ (define-key keymap (kbd "RET") 'company-complete-selection)
+ (define-key keymap [tab] 'company-complete-common)
+ (define-key keymap (kbd "TAB") 'company-complete-common)
+ (define-key keymap (kbd "<f1>") 'company-show-doc-buffer)
+ (define-key keymap (kbd "C-h") 'company-show-doc-buffer)
+ (define-key keymap "\C-w" 'company-show-location)
+ (define-key keymap "\C-s" 'company-search-candidates)
+ (define-key keymap "\C-\M-s" 'company-filter-candidates)
+ (company-keymap--bind-quick-access keymap)
+ keymap)
+ "Keymap that is enabled during an active completion.")
+
+(defvar company--disabled-backends nil)
+
+(defun company--select-next-and-warn (&optional arg)
+ (interactive "p")
+ (company--warn-changed-binding)
+ (company-select-next arg))
+
+(defun company--select-previous-and-warn (&optional arg)
+ (interactive "p")
+ (company--warn-changed-binding)
+ (company-select-previous arg))
+
+(defun company--warn-changed-binding ()
+ (interactive)
+ (run-with-idle-timer
+ 0.01 nil
+ (lambda ()
+ (message "Warning: default bindings are being changed to C-n and C-p"))))
+
+(defun company-init-backend (backend)
+ (and (symbolp backend)
+ (not (fboundp backend))
+ (ignore-errors (require backend nil t)))
+ (cond
+ ((symbolp backend)
+ (condition-case err
+ (progn
+ (funcall backend 'init)
+ (put backend 'company-init t))
+ (error
+ (put backend 'company-init 'failed)
+ (unless (memq backend company--disabled-backends)
+ (message "Company backend '%s' could not be initialized:\n%s"
+ backend (error-message-string err)))
+ (cl-pushnew backend company--disabled-backends)
+ nil)))
+ ;; No initialization for lambdas.
+ ((functionp backend) t)
+ (t ;; Must be a list.
+ (cl-dolist (b backend)
+ (unless (keywordp b)
+ (company-init-backend b))))))
+
+(defun company--maybe-init-backend (backend)
+ (or (not (symbolp backend))
+ (eq t (get backend 'company-init))
+ (unless (get backend 'company-init)
+ (company-init-backend backend))))
+
+(defcustom company-lighter-base "company"
+ "Base string to use for the `company-mode' lighter."
+ :type 'string
+ :package-version '(company . "0.8.10"))
+
+(defvar company-lighter '(" "
+ (company-candidates
+ (:eval
+ (if (consp company-backend)
+ (when company-selection
+ (company--group-lighter (nth company-selection
+ company-candidates)
+ company-lighter-base))
+ (symbol-name company-backend)))
+ company-lighter-base))
+ "Mode line lighter for Company.
+
+The value of this variable is a mode line template as in
+`mode-line-format'.")
+
+(put 'company-lighter 'risky-local-variable t)
+
+;;;###autoload
+(define-minor-mode company-mode
+ "\"complete anything\"; is an in-buffer completion framework.
+Completion starts automatically, depending on the values
+`company-idle-delay' and `company-minimum-prefix-length'.
+
+Completion can be controlled with the commands:
+`company-complete-common', `company-complete-selection', `company-complete',
+`company-select-next', `company-select-previous'. If these commands are
+called before `company-idle-delay', completion will also start.
+
+Completions can be searched with `company-search-candidates' or
+`company-filter-candidates'. These can be used while completion is
+inactive, as well.
+
+The completion data is retrieved using `company-backends' and displayed
+using `company-frontends'. If you want to start a specific backend, call
+it interactively or use `company-begin-backend'.
+
+By default, the completions list is sorted alphabetically, unless the
+backend chooses otherwise, or `company-transformers' changes it later.
+
+regular keymap (`company-mode-map'):
+
+\\{company-mode-map}
+keymap during active completions (`company-active-map'):
+
+\\{company-active-map}"
+ :lighter company-lighter
+ (if company-mode
+ (progn
+ (add-hook 'pre-command-hook 'company-pre-command nil t)
+ (add-hook 'post-command-hook 'company-post-command nil t)
+ (add-hook 'yas-keymap-disable-hook 'company--active-p nil t)
+ (mapc 'company-init-backend company-backends))
+ (remove-hook 'pre-command-hook 'company-pre-command t)
+ (remove-hook 'post-command-hook 'company-post-command t)
+ (remove-hook 'yas-keymap-disable-hook 'company--active-p t)
+ (company-cancel)
+ (kill-local-variable 'company-point)))
+
+(defcustom company-global-modes t
+ "Modes for which `company-mode' mode is turned on by `global-company-mode'.
+If nil, means no modes. If t, then all major modes have it turned on.
+If a list, it should be a list of `major-mode' symbol names for which
+`company-mode' should be automatically turned on. The sense of the list is
+negated if it begins with `not'. For example:
+ (c-mode c++-mode)
+means that `company-mode' is turned on for buffers in C and C++ modes only.
+ (not message-mode)
+means that `company-mode' is always turned on except in `message-mode' buffers."
+ :type '(choice (const :tag "none" nil)
+ (const :tag "all" t)
+ (set :menu-tag "mode specific" :tag "modes"
+ :value (not)
+ (const :tag "Except" not)
+ (repeat :inline t (symbol :tag "mode")))))
+
+;;;###autoload
+(define-globalized-minor-mode global-company-mode company-mode company-mode-on)
+
+(defun company-mode-on ()
+ (when (and (not (or noninteractive (eq (aref (buffer-name) 0) ?\s)))
+ (cond ((eq company-global-modes t)
+ t)
+ ((eq (car-safe company-global-modes) 'not)
+ (not (memq major-mode (cdr company-global-modes))))
+ (t (memq major-mode company-global-modes))))
+ (company-mode 1)))
+
+(defsubst company-assert-enabled ()
+ (unless company-mode
+ (company-uninstall-map)
+ (user-error "Company not enabled")))
+
+;;; keymaps ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defvar-local company-my-keymap nil)
+
+(defvar company-emulation-alist '((t . nil)))
+
+(defun company-enable-overriding-keymap (keymap)
+ (company-uninstall-map)
+ (setq company-my-keymap keymap))
+
+(defun company-ensure-emulation-alist ()
+ (unless (eq 'company-emulation-alist (car emulation-mode-map-alists))
+ (setq emulation-mode-map-alists
+ (cons 'company-emulation-alist
+ (delq 'company-emulation-alist emulation-mode-map-alists)))))
+
+(defun company-install-map ()
+ (unless (or (cdar company-emulation-alist)
+ (null company-my-keymap))
+ (setf (cdar company-emulation-alist) company-my-keymap)))
+
+(defun company-uninstall-map ()
+ (setf (cdar company-emulation-alist) nil))
+
+(defun company--company-command-p (keys)
+ "Checks if the keys are part of company's overriding keymap"
+ (or (equal [company-dummy-event] keys)
+ (commandp (lookup-key company-my-keymap keys))))
+
+;; To avoid warnings in Emacs < 26.
+(declare-function line-number-display-width "indent.c")
+
+(defun company--posn-col-row (posn)
+ (let ((col (car (posn-col-row posn)))
+ ;; `posn-col-row' doesn't work well with lines of different height.
+ ;; `posn-actual-col-row' doesn't handle multiple-width characters.
+ (row (cdr (or (posn-actual-col-row posn)
+ ;; When position is non-visible for some reason.
+ (posn-col-row posn)))))
+ (when (bound-and-true-p display-line-numbers)
+ (cl-decf col (+ 2 (line-number-display-width))))
+ (cons (+ col (window-hscroll)) row)))
+
+(defun company--col-row (&optional pos)
+ (company--posn-col-row (posn-at-point pos)))
+
+(defun company--row (&optional pos)
+ (cdr (company--col-row pos)))
+
+;;; backends ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defvar-local company-backend nil)
+
+(defun company-grab (regexp &optional expression limit)
+ (when (looking-back regexp limit)
+ (or (match-string-no-properties (or expression 0)) "")))
+
+(defun company-grab-line (regexp &optional expression)
+ "Return a match string for REGEXP if it matches text before point.
+If EXPRESSION is non-nil, return the match string for the respective
+parenthesized expression in REGEXP.
+Matching is limited to the current line."
+ (let ((inhibit-field-text-motion t))
+ (company-grab regexp expression (line-beginning-position))))
+
+(defun company-grab-symbol ()
+ "If point is at the end of a symbol, return it.
+Otherwise, if point is not inside a symbol, return an empty string."
+ (if (looking-at "\\_>")
+ (buffer-substring (point) (save-excursion (skip-syntax-backward "w_")
+ (point)))
+ (unless (and (char-after) (memq (char-syntax (char-after)) '(?w ?_)))
+ "")))
+
+(defun company-grab-word ()
+ "If point is at the end of a word, return it.
+Otherwise, if point is not inside a symbol, return an empty string."
+ (if (looking-at "\\>")
+ (buffer-substring (point) (save-excursion (skip-syntax-backward "w")
+ (point)))
+ (unless (and (char-after) (eq (char-syntax (char-after)) ?w))
+ "")))
+
+(defun company-grab-symbol-cons (idle-begin-after-re &optional max-len)
+ "Return a string SYMBOL or a cons (SYMBOL . t).
+SYMBOL is as returned by `company-grab-symbol'. If the text before point
+matches IDLE-BEGIN-AFTER-RE, return it wrapped in a cons."
+ (let ((symbol (company-grab-symbol)))
+ (when symbol
+ (save-excursion
+ (forward-char (- (length symbol)))
+ (if (looking-back idle-begin-after-re (if max-len
+ (- (point) max-len)
+ (line-beginning-position)))
+ (cons symbol t)
+ symbol)))))
+
+(defun company-in-string-or-comment ()
+ "Return non-nil if point is within a string or comment."
+ (let ((ppss (syntax-ppss)))
+ (or (car (setq ppss (nthcdr 3 ppss)))
+ (car (setq ppss (cdr ppss)))
+ (nth 3 ppss))))
+
+(defun company-call-backend (&rest args)
+ (company--force-sync #'company-call-backend-raw args company-backend))
+
+(defun company--force-sync (fun args backend)
+ (let ((value (apply fun args)))
+ (if (not (eq (car-safe value) :async))
+ value
+ (let ((res 'trash)
+ (start (time-to-seconds)))
+ (funcall (cdr value)
+ (lambda (result) (setq res result)))
+ (while (eq res 'trash)
+ (if (> (- (time-to-seconds) start) company-async-timeout)
+ (error "Company: backend %s async timeout with args %s"
+ backend args)
+ ;; XXX: Reusing the trick from company--fetch-candidates here
+ ;; doesn't work well: sit-for isn't a good fit when we want to
+ ;; ignore pending input (results in too many calls).
+ ;; FIXME: We should deal with this by standardizing on a kind of
+ ;; Future object that knows how to sync itself. In most cases (but
+ ;; not all), by calling accept-process-output, probably.
+ (sleep-for company-async-wait)))
+ res))))
+
+(defun company-call-backend-raw (&rest args)
+ (condition-case-unless-debug err
+ (if (functionp company-backend)
+ (apply company-backend args)
+ (apply #'company--multi-backend-adapter company-backend args))
+ (user-error (user-error
+ "Company: backend %s user-error: %s"
+ company-backend (error-message-string err)))
+ (error (error "Company: backend %s error \"%s\" with args %s"
+ company-backend (error-message-string err) args))))
+
+(defun company--multi-backend-adapter (backends command &rest args)
+ (let ((backends (cl-loop for b in backends
+ when (or (keywordp b)
+ (company--maybe-init-backend b))
+ collect b))
+ (separate (memq :separate backends)))
+
+ (when (eq command 'prefix)
+ (setq backends (butlast backends (length (member :with backends)))))
+
+ (setq backends (cl-delete-if #'keywordp backends))
+
+ (pcase command
+ (`candidates
+ (company--multi-backend-adapter-candidates backends (car args) separate))
+ (`sorted separate)
+ (`duplicates (not separate))
+ ((or `prefix `ignore-case `no-cache `require-match)
+ (let (value)
+ (cl-dolist (backend backends)
+ (when (setq value (company--force-sync
+ backend (cons command args) backend))
+ (when (and (eq command 'ignore-case)
+ (eq value 'keep-prefix))
+ (setq value t))
+ (cl-return value)))))
+ (_
+ (let ((arg (car args)))
+ (when (> (length arg) 0)
+ (let ((backend (or (get-text-property 0 'company-backend arg)
+ (car backends))))
+ (apply backend command args))))))))
+
+(defun company--multi-backend-adapter-candidates (backends prefix separate)
+ (let ((pairs (cl-loop for backend in backends
+ when (equal (company--prefix-str
+ (let ((company-backend backend))
+ (company-call-backend 'prefix)))
+ prefix)
+ collect (cons (funcall backend 'candidates prefix)
+ (company--multi-candidates-mapper
+ backend
+ separate
+ ;; Small perf optimization: don't tag the
+ ;; candidates received from the first
+ ;; backend in the group.
+ (not (eq backend (car backends))))))))
+ (company--merge-async pairs (lambda (values) (apply #'append values)))))
+
+(defun company--multi-candidates-mapper (backend separate tag)
+ (lambda (candidates)
+ (when separate
+ (let ((company-backend backend))
+ (setq candidates
+ (company--preprocess-candidates candidates))))
+ (when tag
+ (setq candidates
+ (mapcar
+ (lambda (str)
+ (propertize str 'company-backend backend))
+ candidates)))
+ candidates))
+
+(defun company--merge-async (pairs merger)
+ (let ((async (cl-loop for pair in pairs
+ thereis
+ (eq :async (car-safe (car pair))))))
+ (if (not async)
+ (funcall merger (cl-loop for (val . mapper) in pairs
+ collect (funcall mapper val)))
+ (cons
+ :async
+ (lambda (callback)
+ (let* (lst
+ (pending (mapcar #'car pairs))
+ (finisher (lambda ()
+ (unless pending
+ (funcall callback
+ (funcall merger
+ (nreverse lst)))))))
+ (dolist (pair pairs)
+ (push nil lst)
+ (let* ((cell lst)
+ (val (car pair))
+ (mapper (cdr pair))
+ (this-finisher (lambda (res)
+ (setq pending (delq val pending))
+ (setcar cell (funcall mapper res))
+ (funcall finisher))))
+ (if (not (eq :async (car-safe val)))
+ (funcall this-finisher val)
+ (let ((fetcher (cdr val)))
+ (funcall fetcher this-finisher)))))))))))
+
+(defun company--prefix-str (prefix)
+ (or (car-safe prefix) prefix))
+
+;;; completion mechanism ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defvar-local company-prefix nil)
+
+(defvar-local company-candidates nil)
+
+(defvar-local company-candidates-length nil)
+
+(defvar-local company-candidates-cache nil)
+
+(defvar-local company-candidates-predicate nil)
+
+(defvar-local company-common nil)
+
+(defvar company-selection-default 0
+ "The default value for `company-selection'.")
+(defvar-local company-selection company-selection-default)
+
+(defvar-local company-selection-changed nil)
+
+(defvar-local company--manual-action nil
+ "Non-nil, if manual completion took place.")
+
+(defvar-local company--manual-prefix nil)
+
+(defvar-local company--point-max nil)
+
+(defvar-local company-point nil)
+
+(defvar company-timer nil)
+(defvar company-tooltip-timer nil)
+
+(defsubst company-strip-prefix (str)
+ (substring str (length company-prefix)))
+
+(defun company--insert-candidate (candidate)
+ (when (> (length candidate) 0)
+ (setq candidate (substring-no-properties candidate))
+ ;; XXX: Return value we check here is subject to change.
+ (if (eq (company-call-backend 'ignore-case) 'keep-prefix)
+ (insert (company-strip-prefix candidate))
+ (unless (equal company-prefix candidate)
+ (delete-region (- (point) (length company-prefix)) (point))
+ (insert candidate)))))
+
+(defmacro company-with-candidate-inserted (candidate &rest body)
+ "Evaluate BODY with CANDIDATE temporarily inserted.
+This is a tool for backends that need candidates inserted before they
+can retrieve meta-data for them."
+ (declare (indent 1))
+ `(let ((inhibit-modification-hooks t)
+ (inhibit-point-motion-hooks t)
+ (modified-p (buffer-modified-p)))
+ (company--insert-candidate ,candidate)
+ (unwind-protect
+ (progn ,@body)
+ (delete-region company-point (point))
+ (set-buffer-modified-p modified-p))))
+
+(defun company-explicit-action-p ()
+ "Return whether explicit completion action was taken by the user."
+ (or company--manual-action
+ company-selection-changed))
+
+(defun company-reformat (candidate)
+ ;; company-ispell needs this, because the results are always lower-case
+ ;; It's mory efficient to fix it only when they are displayed.
+ ;; FIXME: Adopt the current text's capitalization instead?
+ (if (eq (company-call-backend 'ignore-case) 'keep-prefix)
+ (let ((prefix (company--clean-string company-prefix)))
+ (concat prefix (substring candidate (length prefix))))
+ candidate))
+
+(defun company--should-complete ()
+ (and (eq company-idle-delay 'now)
+ (not (or buffer-read-only
+ overriding-local-map))
+ ;; Check if in the middle of entering a key combination.
+ (or (equal (this-command-keys-vector) [])
+ (not (keymapp (key-binding (this-command-keys-vector)))))
+ (not (and transient-mark-mode mark-active))))
+
+(defun company--should-continue ()
+ (or (eq t company-begin-commands)
+ (eq t company-continue-commands)
+ (if (eq 'not (car company-continue-commands))
+ (not (memq this-command (cdr company-continue-commands)))
+ (or (memq this-command company-begin-commands)
+ (memq this-command company-continue-commands)
+ (and (symbolp this-command)
+ (string-match-p "\\`company-" (symbol-name this-command)))))))
+
+(defvar company-auto-update-doc nil
+ "If non-nil, update the documentation buffer on each selection change.
+To toggle the value of this variable, call `company-show-doc-buffer' with a
+prefix argument.")
+
+(defun company-call-frontends (command)
+ (when (and company-auto-update-doc
+ (memq command '(update show)))
+ (company-show-doc-buffer))
+ (cl-loop for frontend in company-frontends collect
+ (condition-case-unless-debug err
+ (funcall frontend command)
+ (error (error "Company: frontend %s error \"%s\" on command %s"
+ frontend (error-message-string err) command)))))
+
+(defun company-set-selection (selection &optional force-update)
+ "Set SELECTION for company candidates.
+This will update `company-selection' and related variable.
+Only update when the current selection is changed, but optionally always
+update if FORCE-UPDATE."
+ (when selection
+ (let* ((offset (if company-selection-default 0 1))
+ (company-candidates-length
+ (+ company-candidates-length offset)))
+ (setq selection (+ selection offset))
+ (setq selection
+ (if company-selection-wrap-around
+ (mod selection company-candidates-length)
+ (max 0 (min (1- company-candidates-length) selection))))
+ (setq selection (unless (< selection offset)
+ (- selection offset)))))
+ (when (or force-update (not (equal selection company-selection)))
+ (setq company-selection selection
+ company-selection-changed t)
+ (company-call-frontends 'update)))
+
+(defun company--group-lighter (candidate base)
+ (let ((backend (or (get-text-property 0 'company-backend candidate)
+ (cl-some (lambda (x) (and (not (keywordp x)) x))
+ company-backend))))
+ (when (and backend (symbolp backend))
+ (let ((name (replace-regexp-in-string "company-\\|-company" ""
+ (symbol-name backend))))
+ (format "%s-<%s>" base name)))))
+
+(defun company-update-candidates (candidates)
+ (setq company-candidates-length (length candidates))
+ (if company-selection-changed
+ ;; Try to restore the selection
+ (let ((selected (and company-selection
+ (nth company-selection company-candidates))))
+ (setq company-candidates candidates)
+ (when selected
+ (setq company-selection 0)
+ (catch 'found
+ (while candidates
+ (let ((candidate (pop candidates)))
+ (when (and (string= candidate selected)
+ (equal (company-call-backend 'annotation candidate)
+ (company-call-backend 'annotation selected)))
+ (throw 'found t)))
+ (cl-incf company-selection))
+ (setq company-selection company-selection-default
+ company-selection-changed nil))))
+ (setq company-selection company-selection-default
+ company-candidates candidates))
+ ;; Calculate common.
+ (let ((completion-ignore-case (company-call-backend 'ignore-case)))
+ ;; We want to support non-prefix completion, so filtering is the
+ ;; responsibility of each respective backend, not ours.
+ ;; On the other hand, we don't want to replace non-prefix input in
+ ;; `company-complete-common', unless there's only one candidate.
+ (setq company-common
+ (if (cdr company-candidates)
+ (let ((common (try-completion "" company-candidates)))
+ (when (string-prefix-p company-prefix common
+ completion-ignore-case)
+ common))
+ (car company-candidates)))))
+
+(defun company-calculate-candidates (prefix ignore-case)
+ (let ((candidates (cdr (assoc prefix company-candidates-cache))))
+ (or candidates
+ (when company-candidates-cache
+ (let ((len (length prefix))
+ (completion-ignore-case ignore-case)
+ prev)
+ (cl-dotimes (i (1+ len))
+ (when (setq prev (cdr (assoc (substring prefix 0 (- len i))
+ company-candidates-cache)))
+ (setq candidates (all-completions prefix prev))
+ (cl-return t)))))
+ ;; No cache match, call the backend.
+ (let ((refresh-timer (run-with-timer company-async-redisplay-delay
+ nil #'company--sneaky-refresh)))
+ (setq candidates (company--preprocess-candidates
+ (company--fetch-candidates prefix)))
+ ;; If the backend is synchronous, no chance for the timer to run.
+ (cancel-timer refresh-timer)
+ ;; Save in cache.
+ (push (cons prefix candidates) company-candidates-cache)))
+ ;; Only now apply the predicate and transformers.
+ (company--postprocess-candidates candidates)))
+
+(defun company--unique-match-p (candidates prefix ignore-case)
+ (and candidates
+ (not (cdr candidates))
+ (eq t (compare-strings (car candidates) nil nil
+ prefix nil nil ignore-case))
+ (not (eq (company-call-backend 'kind (car candidates))
+ 'snippet))))
+
+(defun company--fetch-candidates (prefix)
+ (let* ((non-essential (not (company-explicit-action-p)))
+ (inhibit-redisplay t)
+ (c (if (or company-selection-changed
+ ;; FIXME: This is not ideal, but we have not managed to deal
+ ;; with these situations in a better way yet.
+ (company-require-match-p))
+ (company-call-backend 'candidates prefix)
+ (company-call-backend-raw 'candidates prefix))))
+ (if (not (eq (car c) :async))
+ c
+ (let ((res 'none))
+ (funcall
+ (cdr c)
+ (lambda (candidates)
+ (when (eq res 'none)
+ (push 'company-foo unread-command-events))
+ (setq res candidates)))
+ (if (company--flyspell-workaround-p)
+ (while (and (eq res 'none)
+ (not (input-pending-p)))
+ (sleep-for company-async-wait))
+ (while (and (eq res 'none)
+ (sit-for 0.5 t))))
+ (while (member (car unread-command-events)
+ '(company-foo (t . company-foo)))
+ (pop unread-command-events))
+ (prog1
+ (and (consp res) res)
+ (setq res 'exited))))))
+
+(defun company--sneaky-refresh ()
+ (when company-candidates (company-call-frontends 'unhide))
+ (let (inhibit-redisplay)
+ (redisplay))
+ (when company-candidates (company-call-frontends 'pre-command)))
+
+(defun company--flyspell-workaround-p ()
+ ;; https://debbugs.gnu.org/23980
+ (and (bound-and-true-p flyspell-mode)
+ (version< emacs-version "27")))
+
+(defun company--preprocess-candidates (candidates)
+ (cl-assert (cl-every #'stringp candidates))
+ (unless (company-call-backend 'sorted)
+ (setq candidates (sort candidates 'string<)))
+ (when (company-call-backend 'duplicates)
+ (company--strip-duplicates candidates))
+ candidates)
+
+(defun company--postprocess-candidates (candidates)
+ (when (or company-candidates-predicate company-transformers)
+ (setq candidates (copy-sequence candidates)))
+ (when company-candidates-predicate
+ (setq candidates (cl-delete-if-not company-candidates-predicate candidates)))
+ (company--transform-candidates candidates))
+
+(defun company--strip-duplicates (candidates)
+ (let ((c2 candidates)
+ (extras 'unk))
+ (while c2
+ (setcdr c2
+ (let ((str (pop c2)))
+ (while (let ((str2 (car c2)))
+ (if (not (equal str str2))
+ (progn
+ (setq extras 'unk)
+ nil)
+ (when (eq extras 'unk)
+ (setq extras (list (cons (company-call-backend
+ 'annotation str)
+ (company-call-backend
+ 'kind str)))))
+ (let ((extra2 (cons (company-call-backend
+ 'annotation str2)
+ (company-call-backend
+ 'kind str2))))
+ (if (member extra2 extras)
+ t
+ (push extra2 extras)
+ nil))))
+ (pop c2))
+ c2)))))
+
+(defun company--transform-candidates (candidates)
+ (let ((c candidates))
+ (dolist (tr company-transformers)
+ (setq c (funcall tr c)))
+ c))
+
+(defcustom company-occurrence-weight-function
+ #'company-occurrence-prefer-closest-above
+ "Function to weigh matches in `company-sort-by-occurrence'.
+It's called with three arguments: cursor position, the beginning and the
+end of the match."
+ :type '(choice
+ (const :tag "First above point, then below point"
+ company-occurrence-prefer-closest-above)
+ (const :tag "Prefer closest in any direction"
+ company-occurrence-prefer-any-closest)))
+
+(defvar company-vscode-icons-mapping
+ '((array . "symbol-array.svg")
+ (boolean . "symbol-boolean.svg")
+ (class . "symbol-class.svg")
+ (color . "symbol-color.svg")
+ (constant . "symbol-constant.svg")
+ (constructor . "symbol-method.svg")
+ (enum-member . "symbol-enumerator-member.svg")
+ (enum . "symbol-enumerator.svg")
+ (event . "symbol-event.svg")
+ (field . "symbol-field.svg")
+ (file . "symbol-file.svg")
+ (folder . "folder.svg")
+ (interface . "symbol-interface.svg")
+ (keyword . "symbol-keyword.svg")
+ (method . "symbol-method.svg")
+ (function . "symbol-method.svg")
+ (module . "symbol-namespace.svg")
+ (numeric . "symbol-numeric.svg")
+ (operator . "symbol-operator.svg")
+ (property . "symbol-property.svg")
+ (reference . "references.svg")
+ (snippet . "symbol-snippet.svg")
+ (string . "symbol-string.svg")
+ (struct . "symbol-structure.svg")
+ (text . "symbol-key.svg")
+ (type-parameter . "symbol-parameter.svg")
+ (unit . "symbol-ruler.svg")
+ (value . "symbol-enumerator.svg")
+ (variable . "symbol-variable.svg")
+ (t . "symbol-misc.svg")))
+
+(defconst company-icons-root
+ (file-name-as-directory
+ (expand-file-name "icons"
+ (file-name-directory (or load-file-name buffer-file-name)))))
+
+(defcustom company-icon-size '(auto-scale . 16)
+ "Size of icons indicating completion kind in the popup."
+ :type '(choice (integer :tag "Size in pixels" :value 16)
+ (cons :tag "Size in pixels, scaled 2x on HiDPI screens"
+ (const auto-scale)
+ (integer :value 16))))
+
+(defcustom company-icon-margin 2
+ "Width of the margin that shows the icons, in characters."
+ :type 'integer)
+
+(defun company--render-icons-margin (icon-mapping root-dir candidate selected)
+ (if-let ((ws (window-system))
+ (candidate candidate)
+ (kind (company-call-backend 'kind candidate))
+ (icon-file (or (alist-get kind icon-mapping)
+ (alist-get t icon-mapping))))
+ (let* ((bkg (face-attribute (if selected
+ 'company-tooltip-selection
+ 'company-tooltip)
+ :background))
+ (dfw (default-font-width))
+ (icon-size (cond
+ ((integerp company-icon-size)
+ company-icon-size)
+ ;; XXX: Also consider smooth scaling, e.g. using
+ ;; (aref (font-info (face-font 'default)) 2)
+ ((and (consp company-icon-size)
+ (eq 'auto-scale (car company-icon-size)))
+ (let ((base-size (cdr company-icon-size))
+ (dfh (default-font-height)))
+ (min
+ (if (>= dfh (* 2 base-size))
+ (* 2 base-size)
+ base-size)
+ (* company-icon-margin dfw))))))
+ (spec (list 'image
+ :file (expand-file-name icon-file root-dir)
+ :type 'svg
+ :width icon-size
+ :height icon-size
+ :ascent 'center
+ :background (unless (eq bkg 'unspecified)
+ bkg)))
+ (spacer-px-width (- (* company-icon-margin dfw) icon-size)))
+ (cond
+ ((<= company-icon-margin 2)
+ (concat
+ (propertize " " 'display spec)
+ (propertize (company-space-string (1- company-icon-margin))
+ 'display `(space . (:width (,spacer-px-width))))))
+ (t
+ (let* ((spacer-left (/ spacer-px-width 2))
+ (spacer-right (- spacer-px-width spacer-left)))
+ (concat
+ (propertize (company-space-string 1)
+ 'display `(space . (:width (,spacer-left))))
+ (propertize " " 'display spec)
+ (propertize (company-space-string (- company-icon-margin 2))
+ 'display `(space . (:width (,spacer-right)))))))))
+ nil))
+
+(defun company-vscode-dark-icons-margin (candidate selected)
+ "Margin function which returns icons from vscode's dark theme."
+ (company--render-icons-margin company-vscode-icons-mapping
+ (expand-file-name "vscode-dark" company-icons-root)
+ candidate
+ selected))
+
+(defun company-vscode-light-icons-margin (candidate selected)
+ "Margin function which returns icons from vscode's light theme."
+ (company--render-icons-margin company-vscode-icons-mapping
+ (expand-file-name "vscode-light" company-icons-root)
+ candidate
+ selected))
+
+(defcustom company-text-icons-mapping
+ '((array "a" font-lock-type-face)
+ (boolean "b" font-lock-builtin-face)
+ (class "c" font-lock-type-face)
+ (color "#" success)
+ (constant "c" font-lock-constant-face)
+ (constructor "c" font-lock-function-name-face)
+ (enum-member "e" font-lock-builtin-face)
+ (enum "e" font-lock-builtin-face)
+ (field "f" font-lock-variable-name-face)
+ (file "f" font-lock-string-face)
+ (folder "d" font-lock-doc-face)
+ (interface "i" font-lock-type-face)
+ (keyword "k" font-lock-keyword-face)
+ (method "m" font-lock-function-name-face)
+ (function "f" font-lock-function-name-face)
+ (module "{" font-lock-type-face)
+ (numeric "n" font-lock-builtin-face)
+ (operator "o" font-lock-comment-delimiter-face)
+ (property "p" font-lock-variable-name-face)
+ (reference "r" font-lock-doc-face)
+ (snippet "S" font-lock-string-face)
+ (string "s" font-lock-string-face)
+ (struct "%" font-lock-variable-name-face)
+ (text "w" shadow)
+ (type-parameter "p" font-lock-type-face)
+ (unit "u" shadow)
+ (value "v" font-lock-builtin-face)
+ (variable "v" font-lock-variable-name-face)
+ (t "." shadow))
+ "Mapping of the text icons.
+The format should be an alist of (KIND . CONF) where CONF is a list of the
+form (ICON FG BG) which is used to propertize the icon to be shown for a
+candidate of kind KIND. FG can either be color string or a face from which
+we can get a color string (using the :foreground face-property). BG must be
+of the same form as FG or a cons cell of (BG . BG-WHEN-SELECTED) which each
+should be of the same form as FG.
+
+The only mandatory element in CONF is ICON, you can omit both the FG and BG
+fields without issue.
+
+When BG is omitted and `company-text-icons-add-background' is non-nil, a BG
+color is generated using a gradient between the active tooltip color and
+the FG color."
+ :type '(repeat sexp))
+
+(defcustom company-text-face-extra-attributes '(:weight bold)
+ "Additional attributes to add to text/dot icons faces.
+If non-nil, an anonymous face is generated.
+
+Affects `company-text-icons-margin' and `company-dot-icons-margin'."
+ :type '(plist :tag "Face property list"))
+
+(defcustom company-text-icons-format " %s "
+ "Format string for printing the text icons."
+ :type 'string)
+
+(defcustom company-text-icons-add-background nil
+ "Generate a background color for text/dot icons when none is given.
+See `company-text-icons-mapping'."
+ :type 'boolean)
+
+(defun company-text-icons-margin (candidate selected)
+ "Margin function which returns unicode icons."
+ (when-let ((candidate candidate)
+ (kind (company-call-backend 'kind candidate))
+ (conf (or (alist-get kind company-text-icons-mapping)
+ (alist-get t company-text-icons-mapping))))
+ (cl-destructuring-bind (icon &optional fg bg) conf
+ (propertize
+ (format company-text-icons-format icon)
+ 'face
+ (company-text-icons--face fg bg selected)))))
+
+(declare-function color-rgb-to-hex "color")
+(declare-function color-gradient "color")
+
+(defun company-text-icons--extract-property (face property)
+ "Try to extract PROPERTY from FACE.
+If FACE isn't a valid face return FACE as is. If FACE doesn't have
+PROPERTY return nil."
+ (if (facep face)
+ (let ((value (face-attribute face property)))
+ (unless (eq value 'unspecified)
+ value))
+ face))
+
+(defun company-text-icons--face (fg bg selected)
+ (let ((fg-color (company-text-icons--extract-property fg :foreground)))
+ `(,@company-text-face-extra-attributes
+ ,@(and fg-color
+ (list :foreground fg-color))
+ ,@(let* ((bg-is-cons (consp bg))
+ (bg (if bg-is-cons (if selected (cdr bg) (car bg)) bg))
+ (bg-color (company-text-icons--extract-property bg :background))
+ (tooltip-bg-color (company-text-icons--extract-property
+ (if selected
+ 'company-tooltip-selection
+ 'company-tooltip)
+ :background)))
+ (cond
+ ((and company-text-icons-add-background selected
+ (not bg-is-cons) bg-color tooltip-bg-color)
+ ;; Adjust the coloring of the background when *selected* but user hasn't
+ ;; specified an alternate background color for selected item icons.
+ (list :background
+ (apply #'color-rgb-to-hex
+ (nth 0 (color-gradient (color-name-to-rgb tooltip-bg-color)
+ (color-name-to-rgb bg-color)
+ 2)))))
+ (bg
+ ;; When background is configured we use it as is, even if it doesn't
+ ;; constrast well with other candidates when selected.
+ (and bg-color
+ (list :background bg-color)))
+ ((and company-text-icons-add-background fg-color tooltip-bg-color)
+ ;; Lastly attempt to generate a background from the foreground.
+ (list :background
+ (apply #'color-rgb-to-hex
+ (nth 0 (color-gradient (color-name-to-rgb tooltip-bg-color)
+ (color-name-to-rgb fg-color)
+ 10))))))))))
+
+(defcustom company-dot-icons-format "● "
+ "Format string for `company-dot-icons-margin'."
+ :type 'string)
+
+(defun company-dot-icons-margin (candidate selected)
+ "Margin function that uses a colored dot to display completion kind."
+ (when-let ((kind (company-call-backend 'kind candidate))
+ (conf (or (assoc-default kind company-text-icons-mapping)
+ (assoc-default t company-text-icons-mapping))))
+ (cl-destructuring-bind (_icon &optional fg bg) conf
+ (propertize company-dot-icons-format
+ 'face
+ (company-text-icons--face fg bg selected)))))
+
+(defun company-detect-icons-margin (candidate selected)
+ "Margin function which picks the appropriate icon set automatically."
+ (if (and (display-graphic-p)
+ (image-type-available-p 'svg))
+ (cl-case (frame-parameter nil 'background-mode)
+ (light (company-vscode-light-icons-margin candidate selected))
+ (t (company-vscode-dark-icons-margin candidate selected)))
+ (company-text-icons-margin candidate selected)))
+
+(defcustom company-format-margin-function #'company-detect-icons-margin
+ "Function to format the margin.
+It accepts 2 params `candidate' and `selected' and can be used for
+inserting prefix/image before the completion items. Typically, the
+functions call the backends with `kind' and then insert the appropriate
+image for the returned kind image. Function is called with (nil nil) to get
+the default margin."
+ :type '(choice
+ (const :tag "Disabled" nil)
+ (const :tag "Detect icons theme base on conditions" company-detect-icons-margin)
+ (const :tag "Text characters as icons" company-text-icons-margin)
+ (const :tag "Colored dots as icons" company-dot-icons-margin)
+ (const :tag "VScode dark icons theme" company-vscode-dark-icons-margin)
+ (const :tag "VScode light icons theme" company-vscode-light-icons-margin)
+ (function :tag "Custom icon function.")))
+
+(defun company-occurrence-prefer-closest-above (pos match-beg match-end)
+ "Give priority to the matches above point, then those below point."
+ (if (< match-beg pos)
+ (- pos match-end)
+ (- match-beg (window-start))))
+
+(defun company-occurrence-prefer-any-closest (pos _match-beg match-end)
+ "Give priority to the matches closest to the point."
+ (abs (- pos match-end)))
+
+(defun company-sort-by-occurrence (candidates)
+ "Sort CANDIDATES according to their occurrences.
+Searches for each in the currently visible part of the current buffer and
+prioritizes the matches according to `company-occurrence-weight-function'.
+The rest of the list is appended unchanged.
+Keywords and function definition names are ignored."
+ (let* ((w-start (window-start))
+ (w-end (window-end))
+ (start-point (point))
+ occurs
+ (noccurs
+ (save-excursion
+ (cl-delete-if
+ (lambda (candidate)
+ (goto-char w-start)
+ (when (and (not (equal candidate ""))
+ (search-forward candidate w-end t)
+ ;; ^^^ optimize for large lists where most elements
+ ;; won't have a match.
+ (catch 'done
+ (goto-char (1- start-point))
+ (while (search-backward candidate w-start t)
+ (when (save-match-data
+ (company--occurrence-predicate))
+ (throw 'done t)))
+ (goto-char start-point)
+ (while (search-forward candidate w-end t)
+ (when (save-match-data
+ (company--occurrence-predicate))
+ (throw 'done t)))))
+ (push
+ (cons candidate
+ (funcall company-occurrence-weight-function
+ start-point
+ (match-beginning 0)
+ (match-end 0)))
+ occurs)
+ t))
+ candidates))))
+ (nconc
+ (mapcar #'car (sort occurs (lambda (e1 e2) (<= (cdr e1) (cdr e2)))))
+ noccurs)))
+
+(defun company--occurrence-predicate ()
+ (defvar comint-last-prompt)
+ (let ((beg (match-beginning 0))
+ (end (match-end 0))
+ (comint-last-prompt (bound-and-true-p comint-last-prompt)))
+ (save-excursion
+ (goto-char end)
+ ;; Workaround for python-shell-completion-at-point's behavior:
+ ;; https://github.com/company-mode/company-mode/issues/759
+ ;; https://github.com/company-mode/company-mode/issues/549
+ (when (derived-mode-p 'inferior-python-mode)
+ (let ((lbp (line-beginning-position)))
+ (setq comint-last-prompt (cons lbp lbp))))
+ (and (not (memq (get-text-property (1- (point)) 'face)
+ '(font-lock-function-name-face
+ font-lock-keyword-face)))
+ (let ((prefix (company--prefix-str
+ (company-call-backend 'prefix))))
+ (and (stringp prefix)
+ (= (length prefix) (- end beg))))))))
+
+(defun company-sort-by-backend-importance (candidates)
+ "Sort CANDIDATES as two priority groups.
+If `company-backend' is a function, do nothing. If it's a list, move
+candidates from backends before keyword `:with' to the front. Candidates
+from the rest of the backends in the group, if any, will be left at the end."
+ (if (functionp company-backend)
+ candidates
+ (let ((low-priority (cdr (memq :with company-backend))))
+ (if (null low-priority)
+ candidates
+ (sort candidates
+ (lambda (c1 c2)
+ (and
+ (let ((b2 (get-text-property 0 'company-backend c2)))
+ (and b2 (memq b2 low-priority)))
+ (let ((b1 (get-text-property 0 'company-backend c1)))
+ (or (not b1) (not (memq b1 low-priority)))))))))))
+
+(defun company-sort-prefer-same-case-prefix (candidates)
+ "Prefer CANDIDATES with the exact same prefix.
+If a backend returns case insensitive matches, candidates with the an exact
+prefix match (same case) will be prioritized."
+ (cl-loop for candidate in candidates
+ if (string-prefix-p company-prefix candidate)
+ collect candidate into same-case
+ else collect candidate into other-case
+ finally return (append same-case other-case)))
+
+(defun company-idle-begin (buf win tick pos)
+ (and (eq buf (current-buffer))
+ (eq win (selected-window))
+ (eq tick (buffer-chars-modified-tick))
+ (eq pos (point))
+ (let ((non-essential t))
+ (when (company-auto-begin)
+ (let ((this-command 'company-idle-begin))
+ (company-post-command))))))
+
+(defun company-auto-begin ()
+ (and company-mode
+ (not company-candidates)
+ (let ((company-idle-delay 'now))
+ (condition-case-unless-debug err
+ (let ((inhibit-quit nil))
+ (company--perform)
+ ;; Return non-nil if active.
+ company-candidates)
+ (error (message "Company: An error occurred in auto-begin")
+ (message "%s" (error-message-string err))
+ (company-cancel))
+ (quit (company-cancel))))))
+
+;;;###autoload
+(defun company-manual-begin ()
+ (interactive)
+ (company-assert-enabled)
+ (setq company--manual-action t)
+ (unwind-protect
+ (let ((company-minimum-prefix-length 0))
+ (or company-candidates
+ (company-auto-begin)))
+ (unless company-candidates
+ (setq company--manual-action nil))))
+
+(defun company-other-backend (&optional backward)
+ (interactive (list current-prefix-arg))
+ (company-assert-enabled)
+ (let* ((after (if company-backend
+ (cdr (member company-backend company-backends))
+ company-backends))
+ (before (cdr (member company-backend (reverse company-backends))))
+ (next (if backward
+ (append before (reverse after))
+ (append after (reverse before)))))
+ (company-cancel)
+ (cl-dolist (backend next)
+ (when (ignore-errors (company-begin-backend backend))
+ (cl-return t))))
+ (unless company-candidates
+ (user-error "No other backend")))
+
+(defun company-require-match-p ()
+ (let ((backend-value (company-call-backend 'require-match)))
+ (or (eq backend-value t)
+ (and (not (eq backend-value 'never))
+ (if (functionp company-require-match)
+ (funcall company-require-match)
+ (eq company-require-match t))))))
+
+(defun company-insertion-on-trigger-p (input)
+ "Return non-nil if INPUT should trigger insertion.
+For more details see `company-insertion-on-trigger' and
+`company-insertion-triggers'."
+ (and (if (functionp company-insertion-on-trigger)
+ (funcall company-insertion-on-trigger)
+ company-insertion-on-trigger)
+ (if (functionp company-insertion-triggers)
+ (funcall company-insertion-triggers input)
+ (if (consp company-insertion-triggers)
+ (memq (char-syntax (string-to-char input))
+ company-insertion-triggers)
+ (string-match (regexp-quote (substring input 0 1))
+ company-insertion-triggers)))))
+
+(defun company--incremental-p ()
+ (and (> (point) company-point)
+ (> (point-max) company--point-max)
+ (not (eq this-command 'backward-delete-char-untabify))
+ (equal (buffer-substring (- company-point (length company-prefix))
+ company-point)
+ company-prefix)))
+
+(defun company--continue-failed (new-prefix)
+ (cond
+ ((and (or (not (company-require-match-p))
+ ;; Don't require match if the new prefix
+ ;; doesn't continue the old one, and the latter was a match.
+ (not (stringp new-prefix))
+ (<= (length new-prefix) (length company-prefix)))
+ (member company-prefix company-candidates))
+ ;; Last input was a success,
+ ;; but we're treating it as an abort + input anyway,
+ ;; like the `unique' case below.
+ (company-cancel 'non-unique))
+ ((company-require-match-p)
+ ;; Wrong incremental input, but required match.
+ (delete-char (- company-point (point)))
+ (ding)
+ (message "Matching input is required")
+ company-candidates)
+ (t (company-cancel))))
+
+(defun company--good-prefix-p (prefix)
+ (and (stringp (company--prefix-str prefix)) ;excludes 'stop
+ (or (eq (cdr-safe prefix) t)
+ (let ((len (or (cdr-safe prefix) (length prefix))))
+ (if company--manual-prefix
+ (or (not company-abort-manual-when-too-short)
+ ;; Must not be less than minimum or initial length.
+ (>= len (min company-minimum-prefix-length
+ (length company--manual-prefix))))
+ (>= len company-minimum-prefix-length))))))
+
+(defun company--continue ()
+ (when (company-call-backend 'no-cache company-prefix)
+ ;; Don't complete existing candidates, fetch new ones.
+ (setq company-candidates-cache nil))
+ (let* ((new-prefix (company-call-backend 'prefix))
+ (ignore-case (company-call-backend 'ignore-case))
+ (c (when (and (company--good-prefix-p new-prefix)
+ (setq new-prefix (company--prefix-str new-prefix))
+ (= (- (point) (length new-prefix))
+ (- company-point (length company-prefix))))
+ (company-calculate-candidates new-prefix ignore-case))))
+ (cond
+ ((and company-abort-on-unique-match
+ (company--unique-match-p c new-prefix ignore-case))
+ ;; Handle it like completion was aborted, to differentiate from user
+ ;; calling one of Company's commands to insert the candidate,
+ ;; not to trigger template expansion, etc.
+ (company-cancel 'unique))
+ ((consp c)
+ ;; incremental match
+ (setq company-prefix new-prefix)
+ (company-update-candidates c)
+ c)
+ ((and (characterp last-command-event)
+ (company-insertion-on-trigger-p (string last-command-event)))
+ ;; Insertion on trigger.
+ (save-excursion
+ (goto-char company-point)
+ (company-complete-selection)
+ nil))
+ ((not (company--incremental-p))
+ (company-cancel))
+ (t (company--continue-failed new-prefix)))))
+
+(defun company--begin-new ()
+ (let (prefix c)
+ (cl-dolist (backend (if company-backend
+ ;; prefer manual override
+ (list company-backend)
+ company-backends))
+ (setq prefix
+ (if (or (symbolp backend)
+ (functionp backend))
+ (when (company--maybe-init-backend backend)
+ (let ((company-backend backend))
+ (company-call-backend 'prefix)))
+ (company--multi-backend-adapter backend 'prefix)))
+ (when prefix
+ (when (company--good-prefix-p prefix)
+ (let ((ignore-case (company-call-backend 'ignore-case)))
+ (setq company-prefix (company--prefix-str prefix)
+ company-backend backend
+ c (company-calculate-candidates company-prefix ignore-case))
+ (cond
+ ((and company-abort-on-unique-match
+ (company--unique-match-p c company-prefix ignore-case)
+ (if company--manual-action
+ ;; If `company-manual-begin' was called, the user
+ ;; really wants something to happen. Otherwise...
+ (ignore (message "Sole completion"))
+ t))
+ ;; ...abort and run the hooks, e.g. to clear the cache.
+ (company-cancel 'unique))
+ ((null c)
+ (when company--manual-action
+ (message "No completion found")))
+ (t ;; We got completions!
+ (when company--manual-action
+ (setq company--manual-prefix prefix))
+ (company-update-candidates c)
+ (run-hook-with-args 'company-completion-started-hook
+ (company-explicit-action-p))
+ (company-call-frontends 'show)))))
+ (cl-return c)))))
+
+(defun company--perform ()
+ (cond
+ (company-candidates
+ (company--continue))
+ ((company--should-complete)
+ (company--begin-new)))
+ (if (not company-candidates)
+ (setq company-backend nil)
+ (setq company-point (point)
+ company--point-max (point-max))
+ (company-ensure-emulation-alist)
+ (company-enable-overriding-keymap company-active-map)
+ (company-call-frontends 'update)))
+
+(defun company-cancel (&optional result)
+ (let ((prefix company-prefix)
+ (backend company-backend))
+ (setq company-backend nil
+ company-prefix nil
+ company-candidates nil
+ company-candidates-length nil
+ company-candidates-cache nil
+ company-candidates-predicate nil
+ company-common nil
+ company-selection company-selection-default
+ company-selection-changed nil
+ company--manual-action nil
+ company--manual-prefix nil
+ company--point-max nil
+ company-point nil)
+ (when company-timer
+ (cancel-timer company-timer))
+ (company-echo-cancel t)
+ (company-search-mode 0)
+ (company-call-frontends 'hide)
+ (company-enable-overriding-keymap nil)
+ (when prefix
+ (if (stringp result)
+ (let ((company-backend backend))
+ (run-hook-with-args 'company-completion-finished-hook result)
+ (company-call-backend 'post-completion result))
+ (run-hook-with-args 'company-completion-cancelled-hook result))
+ (run-hook-with-args 'company-after-completion-hook result)))
+ ;; Make return value explicit.
+ nil)
+
+(defun company-abort ()
+ (interactive)
+ (company-cancel 'abort))
+
+(defun company-finish (result)
+ (company--insert-candidate result)
+ (company-cancel result))
+
+(defsubst company-keep (command)
+ (and (symbolp command) (get command 'company-keep)))
+
+(defun company--active-p ()
+ company-candidates)
+
+(defun company-pre-command ()
+ (company--electric-restore-window-configuration)
+ (unless (company-keep this-command)
+ (condition-case-unless-debug err
+ (when company-candidates
+ (company-call-frontends 'pre-command)
+ (unless (company--should-continue)
+ (company-abort)))
+ (error (message "Company: An error occurred in pre-command")
+ (message "%s" (error-message-string err))
+ (company-cancel))))
+ (when company-timer
+ (cancel-timer company-timer)
+ (setq company-timer nil))
+ (company-echo-cancel t)
+ (company-uninstall-map))
+
+(defun company-post-command ()
+ (when (and company-candidates
+ (null this-command))
+ ;; Happens when the user presses `C-g' while inside
+ ;; `flyspell-post-command-hook', for example.
+ ;; Or any other `post-command-hook' function that can call `sit-for',
+ ;; or any quittable timer function.
+ (company-abort)
+ (setq this-command 'company-abort))
+ (unless (company-keep this-command)
+ (condition-case-unless-debug err
+ (progn
+ (unless (equal (point) company-point)
+ (let (company-idle-delay) ; Against misbehavior while debugging.
+ (company--perform)))
+ (if company-candidates
+ (company-call-frontends 'post-command)
+ (let ((delay (company--idle-delay)))
+ (and (numberp delay)
+ (not defining-kbd-macro)
+ (company--should-begin)
+ (setq company-timer
+ (run-with-timer delay nil
+ 'company-idle-begin
+ (current-buffer) (selected-window)
+ (buffer-chars-modified-tick) (point)))))))
+ (error (message "Company: An error occurred in post-command")
+ (message "%s" (error-message-string err))
+ (company-cancel))))
+ (company-install-map))
+
+(defun company--idle-delay ()
+ (let ((delay
+ (if (functionp company-idle-delay)
+ (funcall company-idle-delay)
+ company-idle-delay)))
+ (if (memql delay '(t 0 0.0))
+ 0.01
+ delay)))
+
+(defvar company--begin-inhibit-commands '(company-abort
+ company-complete-mouse
+ company-complete
+ company-complete-common
+ company-complete-selection
+ company-complete-tooltip-row)
+ "List of commands after which idle completion is (still) disabled when
+`company-begin-commands' is t.")
+
+(defun company--should-begin ()
+ (if (eq t company-begin-commands)
+ (not (memq this-command company--begin-inhibit-commands))
+ (or
+ (memq this-command company-begin-commands)
+ (and (symbolp this-command) (get this-command 'company-begin)))))
+
+;;; search ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defcustom company-search-regexp-function #'regexp-quote
+ "Function to construct the search regexp from input.
+It's called with one argument, the current search input. It must return
+either a regexp without groups, or one where groups don't intersect and
+each one wraps a part of the input string."
+ :type '(choice
+ (const :tag "Exact match" regexp-quote)
+ (const :tag "Words separated with spaces" company-search-words-regexp)
+ (const :tag "Words separated with spaces, in any order"
+ company-search-words-in-any-order-regexp)
+ (const :tag "All characters in given order, with anything in between"
+ company-search-flex-regexp)))
+
+(defvar-local company-search-string "")
+
+(defvar company-search-lighter '(" "
+ (company-search-filtering "Filter" "Search")
+ ": \""
+ company-search-string
+ "\""))
+
+(defvar-local company-search-filtering nil
+ "Non-nil to filter the completion candidates by the search string")
+
+(defvar-local company--search-old-selection 0)
+
+(defvar-local company--search-old-changed nil)
+
+(defun company-search-words-regexp (input)
+ (mapconcat (lambda (word) (format "\\(%s\\)" (regexp-quote word)))
+ (split-string input " +" t) ".*"))
+
+(defun company-search-words-in-any-order-regexp (input)
+ (let* ((words (mapcar (lambda (word) (format "\\(%s\\)" (regexp-quote word)))
+ (split-string input " +" t)))
+ (permutations (company--permutations words)))
+ (mapconcat (lambda (words)
+ (mapconcat #'identity words ".*"))
+ permutations
+ "\\|")))
+
+(defun company-search-flex-regexp (input)
+ (if (zerop (length input))
+ ""
+ (concat (regexp-quote (string (aref input 0)))
+ (mapconcat (lambda (c)
+ (concat "[^" (string c) "]*"
+ (regexp-quote (string c))))
+ (substring input 1) ""))))
+
+(defun company--permutations (lst)
+ (if (not lst)
+ '(nil)
+ ;; FIXME: Replace with `mapcan' in Emacs 26.
+ (cl-mapcan
+ (lambda (e)
+ (mapcar (lambda (perm) (cons e perm))
+ (company--permutations (cl-remove e lst :count 1))))
+ lst)))
+
+(defun company--search (text lines)
+ (let ((re (funcall company-search-regexp-function text))
+ (i 0))
+ (cl-dolist (line lines)
+ (when (string-match-p re line)
+ (cl-return i))
+ (cl-incf i))))
+
+(defun company-search-printing-char ()
+ (interactive)
+ (company--search-assert-enabled)
+ (let* ((event-type (event-basic-type last-command-event))
+ (event-string (if (characterp event-type)
+ (string last-command-event)
+ ;; Handle key press on the keypad.
+ (let ((name (symbol-name event-type)))
+ (if (string-match "kp-\\([0-9]\\)" name)
+ (match-string 1 name)
+ (error "Unexpected printing char input")))))
+ (ss (concat company-search-string event-string)))
+ (when company-search-filtering
+ (company--search-update-predicate ss))
+ (company--search-update-string ss)))
+
+(defun company--search-update-predicate (ss)
+ (let* ((re (funcall company-search-regexp-function ss))
+ (company-candidates-predicate
+ (and (not (string= re ""))
+ company-search-filtering
+ (lambda (candidate) (string-match re candidate))))
+ (cc (company-calculate-candidates company-prefix
+ (company-call-backend 'ignore-case))))
+ (unless cc (user-error "No match"))
+ (company-update-candidates cc)))
+
+(defun company--search-update-string (new)
+ (let* ((selection (or company-selection 0))
+ (pos (company--search new (nthcdr selection company-candidates))))
+ (if (null pos)
+ (ding)
+ (setq company-search-string new)
+ (company-set-selection (+ selection pos) t))))
+
+(defun company--search-assert-input ()
+ (company--search-assert-enabled)
+ (when (string= company-search-string "")
+ (user-error "Empty search string")))
+
+(defun company-search-repeat-forward ()
+ "Repeat the incremental search in completion candidates forward."
+ (interactive)
+ (company--search-assert-input)
+ (let* ((selection (or company-selection 0))
+ (pos (company--search company-search-string
+ (cdr (nthcdr selection company-candidates)))))
+ (if (null pos)
+ (ding)
+ (company-set-selection (+ selection pos 1) t))))
+
+(defun company-search-repeat-backward ()
+ "Repeat the incremental search in completion candidates backwards."
+ (interactive)
+ (company--search-assert-input)
+ (let* ((selection (or company-selection 0))
+ (pos (company--search company-search-string
+ (nthcdr (- company-candidates-length
+ selection)
+ (reverse company-candidates)))))
+ (if (null pos)
+ (ding)
+ (company-set-selection (- selection pos 1) t))))
+
+(defun company-search-toggle-filtering ()
+ "Toggle `company-search-filtering'."
+ (interactive)
+ (company--search-assert-enabled)
+ (setq company-search-filtering (not company-search-filtering))
+ (let ((ss company-search-string))
+ (company--search-update-predicate ss)
+ (company--search-update-string ss)))
+
+(defun company-search-abort ()
+ "Abort searching the completion candidates."
+ (interactive)
+ (company--search-assert-enabled)
+ (company-search-mode 0)
+ (company-set-selection company--search-old-selection t)
+ (setq company-selection-changed company--search-old-changed))
+
+(defun company-search-other-char ()
+ (interactive)
+ (company--search-assert-enabled)
+ (company-search-mode 0)
+ (company--unread-this-command-keys))
+
+(defun company-search-delete-char ()
+ (interactive)
+ (company--search-assert-enabled)
+ (if (string= company-search-string "")
+ (ding)
+ (let ((ss (substring company-search-string 0 -1)))
+ (when company-search-filtering
+ (company--search-update-predicate ss))
+ (company--search-update-string ss))))
+
+(defvar company-search-map
+ (let ((i 0)
+ (keymap (make-keymap)))
+ (if (fboundp 'max-char)
+ (set-char-table-range (nth 1 keymap) (cons #x100 (max-char))
+ 'company-search-printing-char)
+ (with-no-warnings
+ ;; obsolete in Emacs 23
+ (let ((l (generic-character-list))
+ (table (nth 1 keymap)))
+ (while l
+ (set-char-table-default table (car l) 'company-search-printing-char)
+ (setq l (cdr l))))))
+ (define-key keymap [t] 'company-search-other-char)
+ (while (< i ?\s)
+ (define-key keymap (make-string 1 i) 'company-search-other-char)
+ (cl-incf i))
+ (while (< i 256)
+ (define-key keymap (vector i) 'company-search-printing-char)
+ (cl-incf i))
+ (dotimes (i 10)
+ (define-key keymap (kbd (format "<kp-%d>" i)) 'company-search-printing-char))
+ (let ((meta-map (make-sparse-keymap)))
+ (define-key keymap (char-to-string meta-prefix-char) meta-map)
+ (define-key keymap [escape] meta-map))
+ (define-key keymap (vector meta-prefix-char t) 'company-search-other-char)
+ (define-key keymap (kbd "C-n") 'company-select-next-or-abort)
+ (define-key keymap (kbd "C-p") 'company-select-previous-or-abort)
+ (define-key keymap (kbd "M-n") 'company--select-next-and-warn)
+ (define-key keymap (kbd "M-p") 'company--select-previous-and-warn)
+ (define-key keymap (kbd "<down>") 'company-select-next-or-abort)
+ (define-key keymap (kbd "<up>") 'company-select-previous-or-abort)
+ (define-key keymap "\e\e\e" 'company-search-other-char)
+ (define-key keymap [escape escape escape] 'company-search-other-char)
+ (define-key keymap (kbd "DEL") 'company-search-delete-char)
+ (define-key keymap [backspace] 'company-search-delete-char)
+ (define-key keymap "\C-g" 'company-search-abort)
+ (define-key keymap "\C-s" 'company-search-repeat-forward)
+ (define-key keymap "\C-r" 'company-search-repeat-backward)
+ (define-key keymap "\C-o" 'company-search-toggle-filtering)
+ (company-keymap--bind-quick-access keymap)
+ keymap)
+ "Keymap used for incrementally searching the completion candidates.")
+
+(define-minor-mode company-search-mode
+ "Search mode for completion candidates.
+Don't start this directly, use `company-search-candidates' or
+`company-filter-candidates'."
+ :lighter company-search-lighter
+ (if company-search-mode
+ (if (company-manual-begin)
+ (progn
+ (setq company--search-old-selection company-selection
+ company--search-old-changed company-selection-changed)
+ (company-call-frontends 'update)
+ (company-enable-overriding-keymap company-search-map))
+ (setq company-search-mode nil))
+ (kill-local-variable 'company-search-string)
+ (kill-local-variable 'company-search-filtering)
+ (kill-local-variable 'company--search-old-selection)
+ (kill-local-variable 'company--search-old-changed)
+ (when company-backend
+ (company--search-update-predicate "")
+ (company-call-frontends 'update))
+ (company-enable-overriding-keymap company-active-map)))
+
+(defun company--search-assert-enabled ()
+ (company-assert-enabled)
+ (unless company-search-mode
+ (company-uninstall-map)
+ (user-error "Company not in search mode")))
+
+(defun company-search-candidates ()
+ "Start searching the completion candidates incrementally.
+
+\\<company-search-map>Search can be controlled with the commands:
+- `company-search-repeat-forward' (\\[company-search-repeat-forward])
+- `company-search-repeat-backward' (\\[company-search-repeat-backward])
+- `company-search-abort' (\\[company-search-abort])
+- `company-search-delete-char' (\\[company-search-delete-char])
+
+Regular characters are appended to the search string.
+
+Customize `company-search-regexp-function' to change how the input
+is interpreted when searching.
+
+The command `company-search-toggle-filtering' (\\[company-search-toggle-filtering])
+uses the search string to filter the completion candidates."
+ (interactive)
+ (company-search-mode 1))
+
+(defun company-filter-candidates ()
+ "Start filtering the completion candidates incrementally.
+This works the same way as `company-search-candidates' immediately
+followed by `company-search-toggle-filtering'."
+ (interactive)
+ (company-search-mode 1)
+ (setq company-search-filtering t))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun company-select-next (&optional arg)
+ "Select the next candidate in the list.
+
+With ARG, move by that many elements.
+When `company-selection-default' is nil, add a special pseudo candidates
+meant for no selection."
+ (interactive "p")
+ (when (company-manual-begin)
+ (let ((selection (+ (or arg 1)
+ (or company-selection
+ company-selection-default
+ -1))))
+ (company-set-selection selection))))
+
+(defun company-select-previous (&optional arg)
+ "Select the previous candidate in the list.
+
+With ARG, move by that many elements."
+ (interactive "p")
+ (company-select-next (if arg (- arg) -1)))
+
+(defun company-select-next-or-abort (&optional arg)
+ "Select the next candidate if more than one, else abort
+and invoke the normal binding.
+
+With ARG, move by that many elements."
+ (interactive "p")
+ (if (or (not company-selection)
+ (> company-candidates-length 1))
+ (company-select-next arg)
+ (company-abort)
+ (company--unread-this-command-keys)))
+
+(defun company-select-previous-or-abort (&optional arg)
+ "Select the previous candidate if more than one, else abort
+and invoke the normal binding.
+
+With ARG, move by that many elements."
+ (interactive "p")
+ (if (> company-candidates-length 1)
+ (company-select-previous arg)
+ (company-abort)
+ (company--unread-this-command-keys)))
+
+(defun company-select-first ()
+ "Select the first completion candidate."
+ (interactive)
+ (company-set-selection 0))
+
+(defun company-select-last ()
+ "Select the last completion candidate."
+ (interactive)
+ (company-set-selection (1- company-candidates-length)))
+
+(defun company-next-page ()
+ "Select the candidate one page further."
+ (interactive)
+ (when (company-manual-begin)
+ (if (and company-selection-wrap-around
+ (= company-selection (1- company-candidates-length)))
+ (company-set-selection 0)
+ (let (company-selection-wrap-around)
+ (company-set-selection (+ company-selection
+ company-tooltip-limit))))))
+
+(defun company-previous-page ()
+ "Select the candidate one page earlier."
+ (interactive)
+ (when (company-manual-begin)
+ (if (and company-selection-wrap-around
+ (zerop company-selection))
+ (company-set-selection (1- company-candidates-length))
+ (let (company-selection-wrap-around)
+ (company-set-selection (- company-selection
+ company-tooltip-limit))))))
+
+(defun company--event-col-row (event)
+ (company--posn-col-row (event-start event)))
+
+(defvar company-mouse-event nil
+ "Holds the mouse event from `company-select-mouse'.
+For use in the `select-mouse' frontend action. `let'-bound.")
+
+(defun company-select-mouse (event)
+ "Select the candidate picked by the mouse."
+ (interactive "e")
+ (or (let ((company-mouse-event event))
+ (cl-some #'identity (company-call-frontends 'select-mouse)))
+ (progn
+ (company-abort)
+ (company--unread-this-command-keys)
+ nil)))
+
+(defun company-complete-mouse (event)
+ "Insert the candidate picked by the mouse."
+ (interactive "e")
+ (when (company-select-mouse event)
+ (company-complete-selection)))
+
+(defun company-complete-selection ()
+ "Insert the selected candidate."
+ (interactive)
+ (when (and (company-manual-begin) company-selection)
+ (let ((result (nth company-selection company-candidates)))
+ (company-finish result))))
+
+(defun company-complete-common ()
+ "Insert the common part of all candidates."
+ (interactive)
+ (when (company-manual-begin)
+ (if (and (not (cdr company-candidates))
+ (equal company-common (car company-candidates)))
+ (company-complete-selection)
+ (company--insert-candidate company-common))))
+
+(defun company-complete-common-or-cycle (&optional arg)
+ "Insert the common part of all candidates, or select the next one.
+
+With ARG, move by that many elements."
+ (interactive "p")
+ (when (company-manual-begin)
+ (let ((tick (buffer-chars-modified-tick)))
+ (call-interactively 'company-complete-common)
+ (when (eq tick (buffer-chars-modified-tick))
+ (let ((company-selection-wrap-around t)
+ (current-prefix-arg arg))
+ (call-interactively 'company-select-next))))))
+
+(defun company-complete-common-or-show-delayed-tooltip ()
+ "Insert the common part of all candidates, or show a tooltip."
+ (interactive)
+ (when (company-manual-begin)
+ (let ((tick (buffer-chars-modified-tick)))
+ (call-interactively 'company-complete-common)
+ (when (eq tick (buffer-chars-modified-tick))
+ (let ((company-tooltip-idle-delay 0.0))
+ (company-complete)
+ (and company-candidates
+ (company-call-frontends 'post-command)))))))
+
+(defun company-indent-or-complete-common (arg)
+ "Indent the current line or region, or complete the common part."
+ (interactive "P")
+ (cond
+ ((use-region-p)
+ (indent-region (region-beginning) (region-end)))
+ ((memq indent-line-function
+ '(indent-relative indent-relative-maybe))
+ (company-complete-common))
+ ((let ((old-point (point))
+ (old-tick (buffer-chars-modified-tick))
+ (tab-always-indent t))
+ (indent-for-tab-command arg)
+ (when (and (eq old-point (point))
+ (eq old-tick (buffer-chars-modified-tick)))
+ (company-complete-common))))))
+
+(defun company-select-next-if-tooltip-visible-or-complete-selection ()
+ "Insert selection if appropriate, or select the next candidate.
+Insert selection if only preview is showing or only one candidate,
+otherwise select the next candidate."
+ (interactive)
+ (if (and (company-tooltip-visible-p) (> company-candidates-length 1))
+ (call-interactively 'company-select-next)
+ (call-interactively 'company-complete-selection)))
+
+;;;###autoload
+(defun company-complete ()
+ "Insert the common part of all candidates or the current selection.
+The first time this is called, the common part is inserted, the second
+time, or when the selection has been changed, the selected candidate is
+inserted."
+ (interactive)
+ (when (company-manual-begin)
+ (if (or company-selection-changed
+ (and (eq real-last-command 'company-complete)
+ (eq last-command 'company-complete-common)))
+ (call-interactively 'company-complete-selection)
+ (call-interactively 'company-complete-common)
+ (when company-candidates
+ (setq this-command 'company-complete-common)))))
+
+(define-obsolete-function-alias
+ 'company-complete-number
+ 'company-complete-tooltip-row
+ "0.9.14")
+
+(defun company-complete-tooltip-row (number)
+ "Insert a candidate visible on the tooltip's row NUMBER.
+
+Inserts one of the first ten candidates,
+numbered according to the current scrolling position starting with 1.
+
+When called interactively, uses the last typed digit, stripping the
+modifiers and translating 0 into 10, so `M-1' inserts the first visible
+candidate, and `M-0' insert to 10th one.
+
+To show hint numbers beside the candidates, enable `company-show-quick-access'."
+ (interactive
+ (list (let* ((type (event-basic-type last-command-event))
+ (char (if (characterp type)
+ ;; Number on the main row.
+ type
+ ;; Keypad number, if bound directly.
+ (car (last (string-to-list (symbol-name type))))))
+ (number (- char ?0)))
+ (if (zerop number) 10 number))))
+ (company--complete-nth (1- number)))
+
+(defun company-complete-quick-access (row)
+ "Insert a candidate visible on a ROW matched by a quick-access key binding.
+See `company-quick-access-keys' for more details."
+ (interactive
+ (list (let* ((event-type (event-basic-type last-command-event))
+ (event-string (if (characterp event-type)
+ (string event-type)
+ (error "Unexpected input"))))
+ (cl-position event-string company-quick-access-keys :test 'equal))))
+ (when row
+ (company--complete-nth row)))
+
+(defvar-local company-tooltip-offset 0
+ "Current scrolling state of the tooltip.
+Represented by the index of the first visible completion candidate
+from the candidates list.")
+
+(defun company--complete-nth (row)
+ "Insert a candidate visible on the tooltip's zero-based ROW."
+ (when (company-manual-begin)
+ (and (or (< row 0) (>= row (- company-candidates-length
+ company-tooltip-offset)))
+ (user-error "No candidate on the row number %d" row))
+ (company-finish (nth (+ row company-tooltip-offset)
+ company-candidates))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defconst company-space-strings-limit 100)
+
+(defconst company-space-strings
+ (let (lst)
+ (dotimes (i company-space-strings-limit)
+ (push (make-string (- company-space-strings-limit 1 i) ?\ ) lst))
+ (apply 'vector lst)))
+
+(defun company-space-string (len)
+ (if (< len company-space-strings-limit)
+ (aref company-space-strings len)
+ (make-string len ?\ )))
+
+(defun company-safe-substring (str from &optional to)
+ (let ((bis buffer-invisibility-spec))
+ (if (> from (string-width str))
+ ""
+ (with-temp-buffer
+ (setq buffer-invisibility-spec bis)
+ (insert str)
+ (move-to-column from)
+ (let ((beg (point)))
+ (if to
+ (progn
+ (move-to-column to)
+ (concat (buffer-substring beg (point))
+ (let ((padding (- to (current-column))))
+ (when (> padding 0)
+ (company-space-string padding)))))
+ (buffer-substring beg (point-max))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defvar-local company-last-metadata nil)
+
+(defun company-fetch-metadata ()
+ (let ((selected (nth (or company-selection 0) company-candidates)))
+ (unless (eq selected (car company-last-metadata))
+ (setq company-last-metadata
+ (cons selected (company-call-backend 'meta selected))))
+ (cdr company-last-metadata)))
+
+(defun company-doc-buffer (&optional string)
+ (with-current-buffer (get-buffer-create "*company-documentation*")
+ (erase-buffer)
+ (fundamental-mode)
+ (when string
+ (save-excursion
+ (insert string)
+ (visual-line-mode)))
+ (current-buffer)))
+
+(defvar company--electric-saved-window-configuration nil)
+
+(defvar company--electric-commands
+ '(scroll-other-window scroll-other-window-down mwheel-scroll)
+ "List of Commands that won't break out of electric commands.")
+
+(defun company--electric-restore-window-configuration ()
+ "Restore window configuration (after electric commands)."
+ (when (and company--electric-saved-window-configuration
+ (not (memq this-command company--electric-commands)))
+ (set-window-configuration company--electric-saved-window-configuration)
+ (setq company--electric-saved-window-configuration nil)))
+
+(defmacro company--electric-do (&rest body)
+ (declare (indent 0) (debug t))
+ `(when (company-manual-begin)
+ (cl-assert (null company--electric-saved-window-configuration))
+ (setq company--electric-saved-window-configuration (current-window-configuration))
+ (let ((height (window-height))
+ (row (company--row)))
+ ,@body
+ (and (< (window-height) height)
+ (< (- (window-height) row 2) company-tooltip-limit)
+ (recenter (- (window-height) row 2))))))
+
+(defun company--unread-this-command-keys ()
+ (when (> (length (this-command-keys)) 0)
+ (setq unread-command-events (nconc
+ (listify-key-sequence (this-command-keys))
+ unread-command-events))
+ (clear-this-command-keys t)))
+
+(defun company--show-doc-buffer ()
+ "Show the documentation buffer for the selection."
+ (let ((other-window-scroll-buffer)
+ (selection (or company-selection 0)))
+ (let* ((selected (nth selection company-candidates))
+ (doc-buffer (or (company-call-backend 'doc-buffer selected)
+ (if company-auto-update-doc
+ (company-doc-buffer
+ (format "%s: No documentation available"
+ selected))
+ (user-error "No documentation available"))))
+ start)
+ (when (consp doc-buffer)
+ (setq start (cdr doc-buffer)
+ doc-buffer (car doc-buffer)))
+ (setq other-window-scroll-buffer (get-buffer doc-buffer))
+ (let ((win (display-buffer doc-buffer t)))
+ (set-window-start win (if start start (point-min)))))))
+
+(defun company-show-doc-buffer (&optional toggle-auto-update)
+ "Show the documentation buffer for the selection.
+With a prefix argument TOGGLE-AUTO-UPDATE, toggle the value of
+`company-auto-update-doc'. When `company-auto-update-doc' is non-nil,
+automatically show the documentation buffer for each selection."
+ (interactive "P")
+ (when toggle-auto-update
+ (setq company-auto-update-doc (not company-auto-update-doc)))
+ (if company-auto-update-doc
+ (company--show-doc-buffer)
+ (company--electric-do
+ (company--show-doc-buffer))))
+(put 'company-show-doc-buffer 'company-keep t)
+
+(defun company-show-location ()
+ "Temporarily display a buffer showing the selected candidate in context."
+ (interactive)
+ (let (other-window-scroll-buffer)
+ (company--electric-do
+ (let* ((selected (nth company-selection company-candidates))
+ (location (company-call-backend 'location selected))
+ (pos (or (cdr location) (user-error "No location available")))
+ (buffer (or (and (bufferp (car location)) (car location))
+ (find-file-noselect (car location) t))))
+ (setq other-window-scroll-buffer (get-buffer buffer))
+ (with-selected-window (display-buffer buffer t)
+ (save-restriction
+ (widen)
+ (if (bufferp (car location))
+ (goto-char pos)
+ (goto-char (point-min))
+ (forward-line (1- pos))))
+ (set-window-start nil (point)))))))
+(put 'company-show-location 'company-keep t)
+
+;;; package functions ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defvar-local company-callback nil)
+
+(defun company-remove-callback (&optional _ignored)
+ (remove-hook 'company-completion-finished-hook company-callback t)
+ (remove-hook 'company-completion-cancelled-hook 'company-remove-callback t)
+ (remove-hook 'company-completion-finished-hook 'company-remove-callback t))
+
+(defun company-begin-backend (backend &optional callback)
+ "Start a completion at point using BACKEND."
+ (interactive (let ((val (completing-read "Company backend: "
+ obarray
+ 'functionp nil "company-")))
+ (when val
+ (list (intern val)))))
+ (when (setq company-callback callback)
+ (add-hook 'company-completion-finished-hook company-callback nil t))
+ (add-hook 'company-completion-cancelled-hook 'company-remove-callback nil t)
+ (add-hook 'company-completion-finished-hook 'company-remove-callback nil t)
+ (setq company-backend backend)
+ ;; Return non-nil if active.
+ (or (company-manual-begin)
+ (user-error "Cannot complete at point")))
+
+(defun company-begin-with (candidates
+ &optional prefix-length require-match callback)
+ "Start a completion at point.
+CANDIDATES is the list of candidates to use and PREFIX-LENGTH is the length
+of the prefix that already is in the buffer before point.
+It defaults to 0.
+
+CALLBACK is a function called with the selected result if the user
+successfully completes the input.
+
+Example: \(company-begin-with \\='\(\"foo\" \"foobar\" \"foobarbaz\"\)\)"
+ (let ((begin-marker (copy-marker (point) t)))
+ (company-begin-backend
+ (lambda (command &optional arg &rest _ignored)
+ (pcase command
+ (`prefix
+ (when (equal (point) (marker-position begin-marker))
+ (buffer-substring (- (point) (or prefix-length 0)) (point))))
+ (`candidates
+ (all-completions arg candidates))
+ (`require-match
+ require-match)))
+ callback)))
+
+(declare-function find-library-name "find-func")
+(declare-function lm-version "lisp-mnt")
+
+(defun company-version (&optional show-version)
+ "Get the Company version as string.
+
+If SHOW-VERSION is non-nil, show the version in the echo area."
+ (interactive (list t))
+ (with-temp-buffer
+ (require 'find-func)
+ (insert-file-contents (find-library-name "company"))
+ (require 'lisp-mnt)
+ (if show-version
+ (message "Company version: %s" (lm-version))
+ (lm-version))))
+
+(defun company-diag ()
+ "Pop a buffer with information about completions at point."
+ (interactive)
+ (let* ((bb company-backends)
+ (mode (symbol-name major-mode))
+ backend
+ (prefix (cl-loop for b in bb
+ thereis (let ((company-backend b))
+ (setq backend b)
+ (company-call-backend 'prefix))))
+ (c-a-p-f completion-at-point-functions)
+ cc annotations)
+ (when (or (stringp prefix) (consp prefix))
+ (let ((company-backend backend))
+ (condition-case nil
+ (setq cc (company-call-backend 'candidates (company--prefix-str prefix))
+ annotations
+ (mapcar
+ (lambda (c) (cons c (company-call-backend 'annotation c)))
+ cc))
+ (error (setq annotations 'error)))))
+ (pop-to-buffer (get-buffer-create "*company-diag*"))
+ (setq buffer-read-only nil)
+ (erase-buffer)
+ (insert (format "Emacs %s (%s) of %s on %s"
+ emacs-version system-configuration
+ (format-time-string "%Y-%m-%d" emacs-build-time)
+ emacs-build-system))
+ (insert "\nCompany " (company-version) "\n\n")
+ (insert "company-backends: " (pp-to-string bb))
+ (insert "\n")
+ (insert "Used backend: " (pp-to-string backend))
+ (insert "\n")
+ (when (if (listp backend)
+ (memq 'company-capf backend)
+ (eq backend 'company-capf))
+ (insert "Value of c-a-p-f: "
+ (pp-to-string c-a-p-f)))
+ (insert "Major mode: " mode)
+ (insert "\n")
+ (insert "Prefix: " (pp-to-string prefix))
+ (insert "\n")
+ (insert "Completions:")
+ (unless cc (insert " none"))
+ (if (eq annotations 'error)
+ (insert "(error fetching)")
+ (save-excursion
+ (dolist (c annotations)
+ (insert "\n " (prin1-to-string (car c)))
+ (when (cdr c)
+ (insert " " (prin1-to-string (cdr c)))))))
+ (special-mode)))
+
+;;; pseudo-tooltip ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defvar-local company--tooltip-current-width 0)
+
+(defun company-tooltip--lines-update-offset (selection num-lines limit)
+ (cl-decf limit 2)
+ (setq company-tooltip-offset
+ (max (min selection company-tooltip-offset)
+ (- selection -1 limit)))
+
+ (when (<= company-tooltip-offset 1)
+ (cl-incf limit)
+ (setq company-tooltip-offset 0))
+
+ (when (>= company-tooltip-offset (- num-lines limit 1))
+ (cl-incf limit)
+ (when (= selection (1- num-lines))
+ (cl-decf company-tooltip-offset)
+ (when (<= company-tooltip-offset 1)
+ (setq company-tooltip-offset 0)
+ (cl-incf limit))))
+
+ limit)
+
+(defun company-tooltip--simple-update-offset (selection _num-lines limit)
+ (setq company-tooltip-offset
+ (if (< selection company-tooltip-offset)
+ selection
+ (max company-tooltip-offset
+ (- selection limit -1)))))
+
+;;; propertize
+
+(defun company-round-tab (arg)
+ (* (/ (+ arg tab-width) tab-width) tab-width))
+
+(defun company-plainify (str)
+ (let ((prefix (get-text-property 0 'line-prefix str)))
+ (when prefix ; Keep the original value unmodified, for no special reason.
+ (setq str (concat prefix str))
+ (remove-text-properties 0 (length str) '(line-prefix) str)))
+ (let* ((pieces (split-string str "\t"))
+ (copy pieces))
+ (while (cdr copy)
+ (setcar copy (company-safe-substring
+ (car copy) 0 (company-round-tab (string-width (car copy)))))
+ (pop copy))
+ (apply 'concat pieces)))
+
+(defun company--common-or-matches (value)
+ (let ((matches (company-call-backend 'match value)))
+ (when (and matches
+ company-common
+ (listp matches)
+ (= 1 (length matches))
+ (= 0 (caar matches))
+ (> (length company-common) (cdar matches)))
+ (setq matches nil))
+ (when (integerp matches)
+ (setq matches `((0 . ,matches))))
+ (or matches
+ (and company-common `((0 . ,(length company-common))))
+ nil)))
+
+(defun company-fill-propertize (value annotation width selected left right)
+ (let* ((margin (length left))
+ (company-common (and company-common (company--clean-string company-common)))
+ (common (company--common-or-matches value))
+ (_ (setq value (company-reformat (company--pre-render value))
+ annotation (and annotation (company--pre-render annotation t))))
+ (ann-ralign company-tooltip-align-annotations)
+ (ann-padding (or company-tooltip-annotation-padding 0))
+ (ann-truncate (< width
+ (+ (length value) (length annotation)
+ ann-padding)))
+ (ann-start (+ margin
+ (if ann-ralign
+ (if ann-truncate
+ (+ (length value) ann-padding)
+ (- width (length annotation)))
+ (+ (length value) ann-padding))))
+ (ann-end (min (+ ann-start (length annotation)) (+ margin width)))
+ (line (concat left
+ (if (or ann-truncate (not ann-ralign))
+ (company-safe-substring
+ (concat value
+ (when annotation
+ (company-space-string ann-padding))
+ annotation)
+ 0 width)
+ (concat
+ (company-safe-substring value 0
+ (- width (length annotation)))
+ annotation))
+ right)))
+ (setq width (+ width margin (length right)))
+
+ (font-lock-append-text-property 0 width 'mouse-face
+ 'company-tooltip-mouse
+ line)
+ (when (< ann-start ann-end)
+ (add-face-text-property ann-start ann-end
+ (if selected
+ 'company-tooltip-annotation-selection
+ 'company-tooltip-annotation)
+ t line))
+ (cl-loop
+ with width = (- width (length right))
+ for (comp-beg . comp-end) in common
+ for inline-beg = (+ margin comp-beg)
+ for inline-end = (min (+ margin comp-end) width)
+ when (< inline-beg width)
+ do (add-face-text-property inline-beg inline-end
+ (if selected
+ 'company-tooltip-common-selection
+ 'company-tooltip-common)
+ nil line))
+ (when (let ((re (funcall company-search-regexp-function
+ company-search-string)))
+ (and (not (string= re ""))
+ (string-match re value)))
+ (pcase-dolist (`(,mbeg . ,mend) (company--search-chunks))
+ (let ((beg (+ margin mbeg))
+ (end (+ margin mend))
+ (width (- width (length right))))
+ (when (< beg width)
+ (add-face-text-property beg (min end width)
+ (if selected
+ 'company-tooltip-search-selection
+ 'company-tooltip-search)
+ nil line)))))
+ (when selected
+ (add-face-text-property 0 width 'company-tooltip-selection t line))
+
+ (when (company-call-backend 'deprecated value)
+ (add-face-text-property margin
+ (min
+ (+ margin (length value))
+ (- width (length right)))
+ 'company-tooltip-deprecated t line))
+
+ (add-face-text-property 0 width 'company-tooltip t line)
+ line))
+
+(defun company--search-chunks ()
+ (let ((md (match-data t))
+ res)
+ (if (<= (length md) 2)
+ (push (cons (nth 0 md) (nth 1 md)) res)
+ (while (setq md (nthcdr 2 md))
+ (when (car md)
+ (push (cons (car md) (cadr md)) res))))
+ res))
+
+(defun company--pre-render (str &optional annotation-p)
+ (or (company-call-backend 'pre-render str annotation-p)
+ (progn
+ (when (or (text-property-not-all 0 (length str) 'face nil str)
+ (text-property-not-all 0 (length str) 'mouse-face nil str))
+ (setq str (copy-sequence str))
+ (remove-text-properties 0 (length str)
+ '(face nil font-lock-face nil mouse-face nil)
+ str))
+ str)))
+
+(defun company--clean-string (str)
+ (replace-regexp-in-string
+ "\\([^[:graph:] ]\\)\\|\\(\ufeff\\)\\|[[:multibyte:]]"
+ (lambda (match)
+ (cond
+ ((match-beginning 1)
+ ;; FIXME: Better char for 'non-printable'?
+ ;; We shouldn't get any of these, but sometimes we might.
+ ;; The official "replacement character" is not supported by some fonts.
+ ;;"\ufffd"
+ "?"
+ )
+ ((match-beginning 2)
+ ;; Zero-width non-breakable space.
+ "")
+ ((> (string-width match) 1)
+ (concat
+ (make-string (1- (string-width match)) ?\ufeff)
+ match))
+ (t match)))
+ str))
+
+;;; replace
+
+(defun company-buffer-lines (beg end)
+ (goto-char beg)
+ (let (lines lines-moved)
+ (while (and (not (eobp)) ; http://debbugs.gnu.org/19553
+ (> (setq lines-moved (vertical-motion 1)) 0)
+ (<= (point) end))
+ (let ((bound (min end (point))))
+ ;; A visual line can contain several physical lines (e.g. with outline's
+ ;; folding overlay). Take only the first one.
+ (push (buffer-substring beg
+ (save-excursion
+ (goto-char beg)
+ (re-search-forward "$" bound 'move)
+ (point)))
+ lines))
+ ;; One physical line can be displayed as several visual ones as well:
+ ;; add empty strings to the list, to even the count.
+ (dotimes (_ (1- lines-moved))
+ (push "" lines))
+ (setq beg (point)))
+ (unless (eq beg end)
+ (push (buffer-substring beg end) lines))
+ (nreverse lines)))
+
+(defun company-modify-line (old new offset)
+ (concat (company-safe-substring old 0 offset)
+ new
+ (company-safe-substring old (+ offset (length new)))))
+
+(defun company--show-numbers (numbered)
+ (format " %s" (if (<= numbered 10)
+ (mod numbered 10)
+ " ")))
+(make-obsolete
+ 'company--show-numbers
+ "use `company-quick-access-hint-key' instead,
+but adjust the expected values appropriately."
+ "0.9.14")
+
+(defsubst company--window-height ()
+ (if (fboundp 'window-screen-lines)
+ (floor (window-screen-lines))
+ (window-body-height)))
+
+(defun company--window-width ()
+ (let ((ww (window-body-width)))
+ ;; Account for the line continuation column.
+ (when (zerop (cadr (window-fringes)))
+ (cl-decf ww))
+ (when (bound-and-true-p display-line-numbers)
+ (cl-decf ww (+ 2 (line-number-display-width))))
+ ;; whitespace-mode with newline-mark
+ (when (and buffer-display-table
+ (aref buffer-display-table ?\n))
+ (cl-decf ww (1- (length (aref buffer-display-table ?\n)))))
+ ww))
+
+(defun company--face-attribute (face attr)
+ ;; Like `face-attribute', but accounts for faces that have been remapped to
+ ;; another face, a list of faces, or a face spec.
+ (cond ((null face) nil)
+ ((symbolp face)
+ (let ((remap (cdr (assq face face-remapping-alist))))
+ (if remap
+ (company--face-attribute
+ ;; Faces can be remapped to their unremapped selves, but that
+ ;; would cause us infinite recursion.
+ (if (listp remap) (remq face remap) remap)
+ attr)
+ (face-attribute face attr nil t))))
+ ((keywordp (car-safe face))
+ (or (plist-get face attr)
+ (company--face-attribute (plist-get face :inherit) attr)))
+ ((listp face)
+ (cl-find-if #'stringp
+ (mapcar (lambda (f) (company--face-attribute f attr))
+ face)))))
+
+(defun company--replacement-string (lines column-offset old column nl &optional align-top)
+ (cl-decf column column-offset)
+
+ (when (< column 0) (setq column 0))
+
+ (when (and align-top company-tooltip-flip-when-above)
+ (setq lines (reverse lines)))
+
+ (let ((width (length (car lines)))
+ (remaining-cols (- (+ (company--window-width) (window-hscroll))
+ column)))
+ (when (> width remaining-cols)
+ (cl-decf column (- width remaining-cols))))
+
+ (let (new)
+ (when align-top
+ ;; untouched lines first
+ (dotimes (_ (- (length old) (length lines)))
+ (push (pop old) new)))
+ ;; length into old lines.
+ (while old
+ (push (company-modify-line (pop old) (pop lines) column)
+ new))
+ ;; Append whole new lines.
+ (while lines
+ (push (concat (company-space-string column) (pop lines))
+ new))
+
+ ;; XXX: Also see branch 'more-precise-extend'.
+ (let* ((nl-face `(,@(when (version<= "27" emacs-version)
+ '(:extend t))
+ :inverse-video nil
+ :background ,(or (company--face-attribute 'default :background)
+ (face-attribute 'default :background nil t))))
+ (str (apply #'concat
+ (when nl " \n")
+ (cl-mapcan
+ ;; https://debbugs.gnu.org/cgi/bugreport.cgi?bug=42552#23
+ (lambda (line) (list line (propertize "\n" 'face nl-face)))
+ (nreverse new)))))
+ ;; https://debbugs.gnu.org/38563
+ (add-face-text-property 0 (length str) 'default t str)
+ (when nl (put-text-property 0 1 'cursor t str))
+ str)))
+
+(defun company--create-lines (selection limit)
+ (let ((len company-candidates-length)
+ (window-width (company--window-width))
+ (company-tooltip-annotation-padding
+ (or company-tooltip-annotation-padding
+ (if company-tooltip-align-annotations 1 0)))
+ left-margins
+ left-margin-size
+ lines
+ width
+ lines-copy
+ items
+ previous
+ remainder
+ scrollbar-bounds)
+
+ ;; Maybe clear old offset.
+ (when (< len (+ company-tooltip-offset limit))
+ (setq company-tooltip-offset 0))
+
+ (let ((selection (or selection 0)))
+ ;; Scroll to offset.
+ (if (eq company-tooltip-offset-display 'lines)
+ (setq limit (company-tooltip--lines-update-offset selection len limit))
+ (company-tooltip--simple-update-offset selection len limit))
+
+ (cond
+ ((eq company-tooltip-offset-display 'scrollbar)
+ (setq scrollbar-bounds (company--scrollbar-bounds company-tooltip-offset
+ limit len)))
+ ((eq company-tooltip-offset-display 'lines)
+ (when (> company-tooltip-offset 0)
+ (setq previous (format "...(%d)" company-tooltip-offset)))
+ (setq remainder (- len limit company-tooltip-offset)
+ remainder (when (> remainder 0)
+ (setq remainder (format "...(%d)" remainder)))))))
+
+ (when selection
+ (cl-decf selection company-tooltip-offset))
+
+ (setq width (max (length previous) (length remainder))
+ lines (nthcdr company-tooltip-offset company-candidates)
+ len (min limit len)
+ lines-copy lines)
+
+ (when scrollbar-bounds (cl-decf window-width))
+
+ (when company-format-margin-function
+ (let ((lines-copy lines-copy)
+ res)
+ (dotimes (i len)
+ (push (funcall company-format-margin-function
+ (pop lines-copy)
+ (equal selection i))
+ res))
+ (setq left-margins (nreverse res))))
+
+ ;; XXX: format-function outputting shorter strings than the
+ ;; default margin is not supported (yet?).
+ (setq left-margin-size (apply #'max company-tooltip-margin
+ (mapcar #'length left-margins)))
+
+ (cl-decf window-width company-tooltip-margin)
+ (cl-decf window-width left-margin-size)
+
+ (dotimes (_ len)
+ (let* ((value (pop lines-copy))
+ (annotation (company-call-backend 'annotation value))
+ (left (or (pop left-margins)
+ (company-space-string left-margin-size))))
+ (setq value (company--clean-string value))
+ (when annotation
+ (setq annotation (company--clean-string annotation))
+ (when company-tooltip-align-annotations
+ ;; `lisp-completion-at-point' adds a space.
+ (setq annotation (string-trim-left annotation))))
+ (push (list value annotation left) items)
+ (setq width (max (+ (length value)
+ (if annotation
+ (+ (length annotation)
+ company-tooltip-annotation-padding)
+ (length annotation)))
+ width))))
+
+ (setq width (min window-width
+ company-tooltip-maximum-width
+ (max company-tooltip-minimum-width
+ (if company-show-quick-access
+ (+ 2 width)
+ width))))
+
+ (when company-tooltip-width-grow-only
+ (setq width (max company--tooltip-current-width width))
+ (setq company--tooltip-current-width width))
+
+ (let ((items (nreverse items))
+ (row (if company-show-quick-access 0 99999))
+ new)
+ (when previous
+ (push (company--scrollpos-line previous width left-margin-size) new))
+
+ (dotimes (i len)
+ (let* ((item (pop items))
+ (str (car item))
+ (annotation (cadr item))
+ (left (nth 2 item))
+ (right (company-space-string company-tooltip-margin))
+ (width width)
+ (selected (equal selection i)))
+ (when company-show-quick-access
+ (let ((quick-access (gv-ref (if (eq company-show-quick-access 'left)
+ left right)))
+ (qa-hint (company-tooltip--format-quick-access-hint
+ row selected)))
+ (cl-decf width (string-width qa-hint))
+ (setf (gv-deref quick-access)
+ (concat qa-hint (gv-deref quick-access))))
+ (cl-incf row))
+ (push (concat
+ (company-fill-propertize str annotation
+ width selected
+ left
+ right)
+ (when scrollbar-bounds
+ (company--scrollbar i scrollbar-bounds)))
+ new)))
+
+ (when remainder
+ (push (company--scrollpos-line remainder width left-margin-size) new))
+
+ (cons
+ left-margin-size
+ (nreverse new)))))
+
+(defun company--scrollbar-bounds (offset limit length)
+ (when (> length limit)
+ (let* ((size (ceiling (* limit (float limit)) length))
+ (lower (floor (* limit (float offset)) length))
+ (upper (+ lower size -1)))
+ (cons lower upper))))
+
+(defun company--scrollbar (i bounds)
+ (propertize " " 'face
+ (if (and (>= i (car bounds)) (<= i (cdr bounds)))
+ 'company-tooltip-scrollbar-thumb
+ 'company-tooltip-scrollbar-track)))
+
+(defun company--scrollpos-line (text width fancy-margin-width)
+ (propertize (concat (company-space-string company-tooltip-margin)
+ (company-safe-substring text 0 width)
+ (company-space-string fancy-margin-width))
+ 'face 'company-tooltip))
+
+(defun company-tooltip--format-quick-access-hint (row selected)
+ "Format a quick-access hint for outputting on a tooltip's ROW.
+Value of SELECTED determines the added face."
+ (propertize (format "%2s" (funcall company-quick-access-hint-function row))
+ 'face
+ (if selected
+ 'company-tooltip-quick-access-selection
+ 'company-tooltip-quick-access)))
+
+;; show
+
+(defvar-local company-pseudo-tooltip-overlay nil)
+
+(defun company--inside-tooltip-p (event-col-row row height)
+ (let* ((ovl company-pseudo-tooltip-overlay)
+ (column (overlay-get ovl 'company-column))
+ (width (overlay-get ovl 'company-width))
+ (evt-col (car event-col-row))
+ (evt-row (cdr event-col-row)))
+ (and (>= evt-col column)
+ (< evt-col (+ column width))
+ (if (> height 0)
+ (and (> evt-row row)
+ (<= evt-row (+ row height) ))
+ (and (< evt-row row)
+ (>= evt-row (+ row height)))))))
+
+(defun company--pseudo-tooltip-height ()
+ "Calculate the appropriate tooltip height.
+Returns a negative number if the tooltip should be displayed above point."
+ (let* ((lines (company--row))
+ (below (- (company--window-height) 1 lines)))
+ (if (and (< below (min company-tooltip-minimum company-candidates-length))
+ (> lines below))
+ (- (max 3 (min company-tooltip-limit lines)))
+ (max 3 (min company-tooltip-limit below)))))
+
+(defun company-pseudo-tooltip-show (row column selection)
+ (company-pseudo-tooltip-hide)
+
+ (let* ((height (company--pseudo-tooltip-height))
+ above)
+
+ (when (< height 0)
+ (setq row (+ row height -1)
+ above t))
+
+ ;; This can happen in Emacs versions which allow arbitrary scrolling,
+ ;; such as Yamamoto's Mac Port.
+ (unless (pos-visible-in-window-p (window-start))
+ (cl-decf row))
+
+ (let (nl beg end ov args)
+ (save-excursion
+ (setq nl (< (move-to-window-line row) row)
+ beg (point)
+ end (save-excursion
+ (move-to-window-line (+ row (abs height)))
+ (point))
+ ov (make-overlay beg end nil t)
+ args (list (mapcar 'company-plainify
+ (company-buffer-lines beg end))
+ column nl above)))
+
+ (setq company-pseudo-tooltip-overlay ov)
+ (overlay-put ov 'company-replacement-args args)
+
+ (let* ((lines-and-offset (company--create-lines selection (abs height)))
+ (lines (cdr lines-and-offset))
+ (column-offset (car lines-and-offset)))
+ (overlay-put ov 'company-display
+ (apply 'company--replacement-string
+ lines column-offset args))
+ (overlay-put ov 'company-width (string-width (car lines))))
+
+ (overlay-put ov 'company-column column)
+ (overlay-put ov 'company-height height))))
+
+(defun company-pseudo-tooltip-show-at-point (pos column-offset)
+ (let* ((col-row (company--col-row pos))
+ (col (- (car col-row) column-offset)))
+ (when (< col 0) (setq col 0))
+ (company-pseudo-tooltip-show (1+ (cdr col-row)) col company-selection)))
+
+(defun company-pseudo-tooltip-edit (selection)
+ (let* ((height (overlay-get company-pseudo-tooltip-overlay 'company-height))
+ (lines-and-offset (company--create-lines selection (abs height)))
+ (lines (cdr lines-and-offset))
+ (column-offset (car lines-and-offset)))
+ (overlay-put company-pseudo-tooltip-overlay 'company-width
+ (string-width (car lines)))
+ (overlay-put company-pseudo-tooltip-overlay 'company-display
+ (apply 'company--replacement-string
+ lines column-offset
+ (overlay-get company-pseudo-tooltip-overlay
+ 'company-replacement-args)))))
+
+(defun company-pseudo-tooltip-hide ()
+ (when company-pseudo-tooltip-overlay
+ (delete-overlay company-pseudo-tooltip-overlay)
+ (setq company-pseudo-tooltip-overlay nil)))
+
+(defun company-pseudo-tooltip-hide-temporarily ()
+ (when (overlayp company-pseudo-tooltip-overlay)
+ (overlay-put company-pseudo-tooltip-overlay 'invisible nil)
+ (overlay-put company-pseudo-tooltip-overlay 'line-prefix nil)
+ (overlay-put company-pseudo-tooltip-overlay 'before-string nil)
+ (overlay-put company-pseudo-tooltip-overlay 'display nil)
+ (overlay-put company-pseudo-tooltip-overlay 'face nil)))
+
+(defun company-pseudo-tooltip-unhide ()
+ (when company-pseudo-tooltip-overlay
+ (let* ((ov company-pseudo-tooltip-overlay)
+ (disp (overlay-get ov 'company-display)))
+ ;; Beat outline's folding overlays.
+ ;; And Flymake (53). And Flycheck (110).
+ (overlay-put ov 'priority 111)
+ ;; visual-line-mode
+ (when (and (memq (char-before (overlay-start ov)) '(?\s ?\t))
+ ;; not eob
+ (not (nth 2 (overlay-get ov 'company-replacement-args))))
+ (setq disp (concat "\n" disp)))
+ ;; No (extra) prefix for the first line.
+ (overlay-put ov 'line-prefix "")
+ (overlay-put ov 'before-string disp)
+ ;; `display' is better than `invisible':
+ ;; https://debbugs.gnu.org/18285
+ ;; https://debbugs.gnu.org/20847
+ ;; https://debbugs.gnu.org/42521
+ (overlay-put ov 'display "")
+ (overlay-put ov 'window (selected-window)))))
+
+(defun company-pseudo-tooltip-guard ()
+ (list
+ (save-excursion (beginning-of-visual-line))
+ (window-width)
+ (let ((ov company-pseudo-tooltip-overlay)
+ (overhang (save-excursion (end-of-visual-line)
+ (- (line-end-position) (point)))))
+ (when (>= (overlay-get ov 'company-height) 0)
+ (cons
+ (buffer-substring-no-properties (point) (overlay-start ov))
+ (when (>= overhang 0) overhang))))))
+
+(defun company-pseudo-tooltip-frontend (command)
+ "`company-mode' frontend similar to a tooltip but based on overlays."
+ (cl-case command
+ (pre-command (company-pseudo-tooltip-hide-temporarily))
+ (unhide
+ (let ((ov company-pseudo-tooltip-overlay))
+ (when (> (overlay-get ov 'company-height) 0)
+ ;; Sleight of hand: if the current line wraps, we adjust the
+ ;; start of the overlay so that the popup does not zig-zag,
+ ;; but don't update the popup's background. This seems just
+ ;; non-annoying enough to avoid the work required for the latter.
+ (save-excursion
+ (vertical-motion 1)
+ (unless (= (point) (overlay-start ov))
+ (move-overlay ov (point) (overlay-end ov))))))
+ (company-pseudo-tooltip-unhide))
+ (post-command
+ (unless (when (overlayp company-pseudo-tooltip-overlay)
+ (let* ((ov company-pseudo-tooltip-overlay)
+ (old-height (overlay-get ov 'company-height))
+ (new-height (company--pseudo-tooltip-height)))
+ (and
+ (>= (* old-height new-height) 0)
+ (>= (abs old-height) (abs new-height))
+ (equal (company-pseudo-tooltip-guard)
+ (overlay-get ov 'company-guard)))))
+ ;; Redraw needed.
+ (company-pseudo-tooltip-show-at-point (point) (length company-prefix))
+ (overlay-put company-pseudo-tooltip-overlay
+ 'company-guard (company-pseudo-tooltip-guard)))
+ (company-pseudo-tooltip-unhide))
+ (show (setq company--tooltip-current-width 0))
+ (hide (company-pseudo-tooltip-hide)
+ (setq company-tooltip-offset 0))
+ (update (when (overlayp company-pseudo-tooltip-overlay)
+ (company-pseudo-tooltip-edit company-selection)))
+ (select-mouse
+ (let ((event-col-row (company--event-col-row company-mouse-event))
+ (ovl-row (company--row))
+ (ovl-height (and company-pseudo-tooltip-overlay
+ (min (overlay-get company-pseudo-tooltip-overlay
+ 'company-height)
+ company-candidates-length))))
+ (cond ((and ovl-height
+ (company--inside-tooltip-p event-col-row ovl-row ovl-height))
+ (company-set-selection (+ (cdr event-col-row)
+ (1- company-tooltip-offset)
+ (if (and (eq company-tooltip-offset-display 'lines)
+ (not (zerop company-tooltip-offset)))
+ -1 0)
+ (- ovl-row)
+ (if (< ovl-height 0)
+ (- 1 ovl-height)
+ 0)))
+ t))))))
+
+(defun company-pseudo-tooltip-unless-just-one-frontend (command)
+ "`company-pseudo-tooltip-frontend', but not shown for single candidates."
+ (unless (and (memq command '(post-command unhide))
+ (company--show-inline-p))
+ (company-pseudo-tooltip-frontend command)))
+
+(defun company-pseudo-tooltip--ujofwd-on-timer (command)
+ (when company-candidates
+ (company-pseudo-tooltip-unless-just-one-frontend-with-delay command)))
+
+(defun company-pseudo-tooltip-unless-just-one-frontend-with-delay (command)
+ "`compandy-pseudo-tooltip-frontend', but shown after a delay.
+Delay is determined by `company-tooltip-idle-delay'."
+ (defvar company-preview-overlay)
+ (when (and (memq command '(pre-command hide))
+ company-tooltip-timer)
+ (cancel-timer company-tooltip-timer)
+ (setq company-tooltip-timer nil))
+ (cl-case command
+ (post-command
+ (if (or company-tooltip-timer
+ (overlayp company-pseudo-tooltip-overlay))
+ (if (not (overlayp company-preview-overlay))
+ (company-pseudo-tooltip-unless-just-one-frontend command)
+ (let (company-tooltip-timer)
+ (company-call-frontends 'pre-command))
+ (company-call-frontends 'post-command))
+ (setq company-tooltip-timer
+ (run-with-timer company-tooltip-idle-delay nil
+ 'company-pseudo-tooltip--ujofwd-on-timer
+ 'post-command))))
+ (unhide
+ (when (overlayp company-pseudo-tooltip-overlay)
+ (company-pseudo-tooltip-unless-just-one-frontend command)))
+ (t
+ (company-pseudo-tooltip-unless-just-one-frontend command))))
+
+;;; overlay ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defvar-local company-preview-overlay nil)
+
+(defun company-preview-show-at-point (pos completion)
+ (company-preview-hide)
+
+ (let* ((company-common (and company-common
+ (string-prefix-p company-prefix company-common)
+ company-common))
+ (common (company--common-or-matches completion)))
+ (setq completion (copy-sequence (company--pre-render completion)))
+ (add-face-text-property 0 (length completion) 'company-preview
+ nil completion)
+
+ (cl-loop for (beg . end) in common
+ do (add-face-text-property beg end 'company-preview-common
+ nil completion))
+
+ ;; Add search string
+ (and (string-match (funcall company-search-regexp-function
+ company-search-string)
+ completion)
+ (pcase-dolist (`(,mbeg . ,mend) (company--search-chunks))
+ (add-face-text-property mbeg mend 'company-preview-search
+ nil completion)))
+
+ (setq completion (if (string-prefix-p company-prefix completion
+ (eq (company-call-backend 'ignore-case)
+ 'keep-prefix))
+ (company-strip-prefix completion)
+ completion))
+
+ (when (string-prefix-p "\n" completion)
+ (setq completion (concat (propertize " " 'face 'company-preview) "\n"
+ (substring completion 1))))
+
+ (and (equal pos (point))
+ (not (equal completion ""))
+ (add-text-properties 0 1 '(cursor 1) completion))
+
+ (let* ((beg pos)
+ (pto company-pseudo-tooltip-overlay)
+ (ptf-workaround (and
+ pto
+ (char-before pos)
+ (eq pos (overlay-start pto)))))
+ ;; Try to accommodate for the pseudo-tooltip overlay,
+ ;; which may start at the same position if it's at eol.
+ (when ptf-workaround
+ (cl-decf beg)
+ (setq completion (concat (buffer-substring beg pos) completion)))
+
+ (setq company-preview-overlay (make-overlay beg pos))
+
+ (let ((ov company-preview-overlay))
+ (overlay-put ov (if ptf-workaround 'display 'after-string)
+ completion)
+ (overlay-put ov 'window (selected-window))))))
+
+(defun company-preview-hide ()
+ (when company-preview-overlay
+ (delete-overlay company-preview-overlay)
+ (setq company-preview-overlay nil)))
+
+(defun company-preview-frontend (command)
+ "`company-mode' frontend showing the selection as if it had been inserted."
+ (pcase command
+ (`pre-command (company-preview-hide))
+ (`unhide
+ (when company-selection
+ (let* ((current (nth company-selection company-candidates))
+ (company-prefix (if (equal current company-prefix)
+ ;; Would be more accurate to compare lengths,
+ ;; but this is shorter.
+ current
+ (buffer-substring
+ (- company-point (length company-prefix))
+ (point)))))
+ (company-preview-show-at-point (point) current))))
+ (`post-command
+ (when company-selection
+ (company-preview-show-at-point (point)
+ (nth company-selection company-candidates))))
+ (`hide (company-preview-hide))))
+
+(defun company-preview-if-just-one-frontend (command)
+ "`company-preview-frontend', but only shown for single candidates."
+ (when (or (not (memq command '(post-command unhide)))
+ (company--show-inline-p))
+ (company-preview-frontend command)))
+
+(defun company--show-inline-p ()
+ (and (not (cdr company-candidates))
+ company-common
+ (not (eq t (compare-strings company-prefix nil nil
+ (car company-candidates) nil nil
+ t)))
+ (or (eq (company-call-backend 'ignore-case) 'keep-prefix)
+ (string-prefix-p company-prefix company-common))))
+
+(defun company-tooltip-visible-p ()
+ "Returns whether the tooltip is visible."
+ (when (overlayp company-pseudo-tooltip-overlay)
+ (not (overlay-get company-pseudo-tooltip-overlay 'invisible))))
+
+(defun company-preview-common--show-p ()
+ "Returns whether the preview of common can be showed or not"
+ (and company-common
+ (or (eq (company-call-backend 'ignore-case) 'keep-prefix)
+ (string-prefix-p company-prefix company-common))))
+
+(defun company-preview-common-frontend (command)
+ "`company-mode' frontend preview the common part of candidates."
+ (when (or (not (memq command '(post-command unhide)))
+ (company-preview-common--show-p))
+ (pcase command
+ (`pre-command (company-preview-hide))
+ ((or 'post-command 'unhide)
+ (company-preview-show-at-point (point) company-common))
+ (`hide (company-preview-hide)))))
+
+;;; echo ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defvar-local company-echo-last-msg nil)
+
+(defvar company-echo-timer nil)
+
+(defvar company-echo-delay .01)
+
+(defcustom company-echo-truncate-lines t
+ "Whether frontend messages written to the echo area should be truncated."
+ :type 'boolean
+ :package-version '(company . "0.9.3"))
+
+(defun company-echo-show (&optional getter)
+ (let ((last-msg company-echo-last-msg)
+ (message-log-max nil)
+ (message-truncate-lines company-echo-truncate-lines))
+ (when getter
+ (setq company-echo-last-msg (funcall getter)))
+ ;; Avoid modifying the echo area if we don't have anything to say, and we
+ ;; didn't put the previous message there (thus there's nothing to clear),
+ ;; https://debbugs.gnu.org/cgi/bugreport.cgi?bug=62816#20
+ (if (not (member company-echo-last-msg '(nil "")))
+ (message "%s" company-echo-last-msg)
+ (unless (member last-msg '(nil ""))
+ (message "")))))
+
+(defun company-echo-show-soon (&optional getter delay)
+ (company-echo-cancel)
+ (setq company-echo-timer (run-with-timer (or delay company-echo-delay)
+ nil
+ 'company-echo-show getter)))
+
+(defun company-echo-cancel (&optional unset)
+ (when company-echo-timer
+ (cancel-timer company-echo-timer))
+ (when unset
+ (setq company-echo-timer nil)))
+
+(defun company-echo-format ()
+ (let ((selection (or company-selection 0)))
+ (let ((limit (window-body-width (minibuffer-window)))
+ (len -1)
+ (candidates (nthcdr selection company-candidates))
+ (numbered (if company-show-quick-access selection 99999))
+ (qa-keys-len (length company-quick-access-keys))
+ comp msg)
+
+ (while candidates
+ (setq comp (propertize
+ (company-reformat (company--clean-string (pop candidates)))
+ 'face
+ 'company-echo)
+ len (+ len 1 (length comp)))
+ (let ((beg 0)
+ (end (string-width (or company-common ""))))
+ (when (< numbered qa-keys-len)
+ (let ((qa-hint
+ (format "%s: " (funcall
+ company-quick-access-hint-function
+ numbered))))
+ (setq beg (string-width qa-hint)
+ end (+ beg end))
+ (cl-incf len beg)
+ (setq comp (propertize (concat qa-hint comp) 'face 'company-echo)))
+ (cl-incf numbered))
+ ;; FIXME: Add support for the `match' backend action, and thus,
+ ;; non-prefix matches.
+ (add-text-properties beg end '(face company-echo-common) comp))
+ (if (>= len limit)
+ (setq candidates nil)
+ (push comp msg)))
+
+ (mapconcat 'identity (nreverse msg) " "))))
+
+(defun company-echo-strip-common-format ()
+ (let ((selection (or company-selection 0)))
+ (let ((limit (window-body-width (minibuffer-window)))
+ (len (+ (length company-prefix) 2))
+ (candidates (nthcdr selection company-candidates))
+ (numbered (if company-show-quick-access selection 99999))
+ (qa-keys-len (length company-quick-access-keys))
+ comp msg)
+
+ (while candidates
+ (setq comp (company-strip-prefix (pop candidates))
+ len (+ len 2 (length comp)))
+ (when (< numbered qa-keys-len)
+ (let ((qa-hint (format " (%s)"
+ (funcall company-quick-access-hint-function
+ numbered))))
+ (setq comp (concat comp qa-hint))
+ (cl-incf len (string-width qa-hint)))
+ (cl-incf numbered))
+ (if (>= len limit)
+ (setq candidates nil)
+ (push (propertize comp 'face 'company-echo) msg)))
+
+ (concat (propertize company-prefix 'face 'company-echo-common) "{"
+ (mapconcat 'identity (nreverse msg) ", ")
+ "}"))))
+
+(defun company-echo-hide ()
+ (unless (equal company-echo-last-msg "")
+ (setq company-echo-last-msg "")
+ (company-echo-show)))
+
+(defun company-echo-frontend (command)
+ "`company-mode' frontend showing the candidates in the echo area."
+ (pcase command
+ (`post-command (company-echo-show-soon 'company-echo-format 0))
+ (`hide (company-echo-hide))))
+
+(defun company-echo-strip-common-frontend (command)
+ "`company-mode' frontend showing the candidates in the echo area."
+ (pcase command
+ (`post-command (company-echo-show-soon 'company-echo-strip-common-format 0))
+ (`hide (company-echo-hide))))
+
+(defun company-echo-metadata-frontend (command)
+ "`company-mode' frontend showing the documentation in the echo area."
+ (pcase command
+ (`post-command (company-echo-show-soon 'company-fetch-metadata))
+ (`unhide (company-echo-show))
+ (`hide (company-echo-hide))))
+
+(provide 'company)
+;;; company.el ends here
--- /dev/null
+This is company.info, produced by makeinfo version 6.7 from
+company.texi.
+
+This user manual is for Company version 0.9.14snapshot (16 April 2023).
+
+Copyright © 2021-2023 Free Software Foundation, Inc.
+
+ Permission is granted to copy, distribute and/or modify this
+ document under the terms of the GNU Free Documentation License,
+ Version 1.3 or any later version published by the Free Software
+ Foundation.
+INFO-DIR-SECTION Emacs misc features
+START-INFO-DIR-ENTRY
+* Company: (company). A modular text completion framework.
+END-INFO-DIR-ENTRY
+
+\1f
+File: company.info, Node: Top, Next: Overview, Up: (dir)
+
+Company
+*******
+
+Company is a modular text completion framework for GNU Emacs.
+
+The goal of this document is to lay out the foundational knowledge of
+the package, so that the readers of the manual could competently start
+adapting Company to their needs and preferences.
+
+This user manual is for Company version 0.9.14snapshot (16 April 2023).
+
+Copyright © 2021-2023 Free Software Foundation, Inc.
+
+ Permission is granted to copy, distribute and/or modify this
+ document under the terms of the GNU Free Documentation License,
+ Version 1.3 or any later version published by the Free Software
+ Foundation.
+
+* Menu:
+
+* Overview:: Terminology and Structure
+* Getting Started:: Quick Start Guide
+* Customization:: User Options
+* Frontends:: Frontends Usage Instructions
+* Backends:: Backends Usage Instructions
+* Troubleshooting:: When Something Goes Wrong
+* Index::
+
+— The Detailed Node Listing —
+
+Overview
+
+* Terminology::
+* Structure::
+
+Getting Started
+
+* Installation::
+* Initial Setup::
+* Usage Basics::
+* Commands::
+
+Customization
+
+* Customization Interface::
+* Configuration File::
+
+Frontends
+
+* Tooltip Frontends::
+* Preview Frontends::
+* Echo Frontends::
+* Candidates Search::
+* Filter Candidates::
+* Quick Access a Candidate::
+
+Backends
+
+* Backends Usage Basics::
+* Grouped Backends::
+* Package Backends::
+* Candidates Post-Processing::
+
+
+\1f
+File: company.info, Node: Overview, Next: Getting Started, Prev: Top, Up: Top
+
+1 Overview
+**********
+
+“Company” is a modular text completion framework for GNU Emacs.
+
+In other words, it is a package for retrieving, manipulating, and
+displaying text completion candidates. It aims to assist developers,
+writers, and scientists during code and text writing.
+
+* Menu:
+
+* Terminology::
+* Structure::
+
+\1f
+File: company.info, Node: Terminology, Next: Structure, Up: Overview
+
+1.1 Terminology
+===============
+
+“Completion” is an act of intelligibly guessing possible variants of
+words based on already typed characters. To “complete” a word means to
+insert a correctly guessed variant into the buffer.
+
+Consequently, the “candidates” are the aforementioned guessed variants
+of words. Each of the candidates has the potential to be chosen for
+successful completion. And each of the candidates contains the
+initially typed characters: either only at the beginning (so-called
+“prefix matches”), or also inside (“non-prefix matches”) of a candidate
+(1).
+
+The package’s name “Company” is based on the combination of the two
+words: ‘Complete’ and ‘Anything’. These words reflect the package’s
+commitment to handling completion candidates and its extensible nature
+allowing it to cover a wide range of usage scenarios.
+
+ ---------- Footnotes ----------
+
+ (1) A good starting point to learn about types of matches is to play
+with the Emacs’s user option ‘completion-styles’. For illustrations on
+how Company visualizes the matches, *note Frontends::.
+
+\1f
+File: company.info, Node: Structure, Prev: Terminology, Up: Overview
+
+1.2 Structure
+=============
+
+The Company is easily extensible because its significant building blocks
+are pluggable modules: backends (*note Backends::) and frontends (*note
+Frontends::).
+
+The “backends” are responsible for retrieving completion candidates;
+which are then outputted by the “frontends”. For an easy and quick
+initial setup, Company is supplied with the preconfigured sets of the
+backends and frontends. The default behavior of the modules can be
+adjusted per particular needs, goals, and preferences. It is also
+typical to utilize backends from a variety of third-party libraries
+(https://github.com/company-mode/company-mode/wiki/Third-Party-Packages),
+developed to be pluggable with Company.
+
+But Company consists not only of the backends and frontends.
+
+A core of the package plays the role of a controller, connecting the
+modules, making them work together; and exposing configurations and
+commands for a user to operate with. For more details, *note
+Customization:: and *note Commands::.
+
+Also, Company is bundled with an alternative workflow configuration
+“company-tng” — defining ‘company-tng-frontend’, ‘company-tng-mode’, and
+‘company-tng-map’ — that allows performing completion with just <TAB>.
+To enable this configuration, add the following line to the Emacs
+initialization file (*note (emacs)Init File::):
+
+ (add-hook 'after-init-hook 'company-tng-mode)
+
+\1f
+File: company.info, Node: Getting Started, Next: Customization, Prev: Overview, Up: Top
+
+2 Getting Started
+*****************
+
+This chapter provides basic instructions for Company setup and usage.
+
+* Menu:
+
+* Installation::
+* Initial Setup::
+* Usage Basics::
+* Commands::
+
+\1f
+File: company.info, Node: Installation, Next: Initial Setup, Up: Getting Started
+
+2.1 Installation
+================
+
+Company package is distributed via commonly used package archives in a
+form of both stable and development releases. To install Company, type
+‘M-x package-install <RET> company <RET>’.
+
+For more details on Emacs package archives, *note (emacs)Packages::.
+
+\1f
+File: company.info, Node: Initial Setup, Next: Usage Basics, Prev: Installation, Up: Getting Started
+
+2.2 Initial Setup
+=================
+
+The package Company provides a minor mode “company-mode”.
+
+To activate the _company-mode_, execute the command ‘M-x company-mode’
+that toggles the mode on and off. When it is switched on, the mode line
+(*note (emacs)Mode line::) should indicate its presence with an
+indicator ‘company’.
+
+After _company-mode_ had been enabled, the package auto-starts
+suggesting completion candidates. The candidates are retrieved and
+shown according to the typed characters and the default (until a user
+specifies otherwise) configurations.
+
+To have Company always enabled for the following sessions, add the line
+‘(global-company-mode)’ to the Emacs configuration file (*note
+(emacs)Init File::).
+
+\1f
+File: company.info, Node: Usage Basics, Next: Commands, Prev: Initial Setup, Up: Getting Started
+
+2.3 Usage Basics
+================
+
+By default — having _company-mode_ enabled (*note Initial Setup::) — a
+tooltip with completion candidates is shown when a user types in a few
+characters.
+
+To initiate completion manually, use the command ‘M-x company-complete’.
+
+To select next or previous of the shown completion candidates, use
+respectively key bindings ‘C-n’ and ‘C-p’, then do one of the following:
+
+ • Hit <RET> to choose a selected candidate for completion.
+
+ • Hit <TAB> to complete with the “common part”: characters present at
+ the beginning of all the candidates.
+
+ • Hit ‘C-g’ to stop activity of Company.
+
+\1f
+File: company.info, Node: Commands, Prev: Usage Basics, Up: Getting Started
+
+2.4 Commands
+============
+
+Under the hood, mentioned in the previous section keys are bound to the
+commands of the out-of-the-box Company.
+
+‘C-n’
+‘M-n’
+ Select the next candidate (‘company-select-next-or-abort’,
+ ‘company-select-next’).
+
+‘C-p’
+‘M-p’
+ Select the previous candidate (‘company-select-previous-or-abort’,
+ ‘company-select-previous’).
+
+‘RET’
+‘<return>’
+ Insert the selected candidate (‘company-complete-selection’).
+
+‘TAB’
+‘<tab>’
+ Insert the common part of all the candidates
+ (‘company-complete-common’).
+
+‘C-g’
+‘<ESC ESC ESC>’
+ Cancel _company-mode_ activity (‘company-abort’).
+
+‘C-h’
+‘<F1>’
+ Display a buffer with the documentation for the selected candidate
+ (‘company-show-doc-buffer’). With a prefix argument (‘C-u C-h’,
+ ‘C-u <F1>’), this command toggles between temporary showing the
+ documentation and keeping the documentation buffer up-to-date
+ whenever the selection changes.
+
+‘C-w’
+ Display a buffer with the definition of the selected candidate
+ (‘company-show-location’).
+
+The full list of the default key bindings is stored in the variables
+‘company-active-map’ and ‘company-search-map’ (1).
+
+Moreover, Company is bundled with a number of convenience commands that
+do not have default key bindings defined. The following examples
+illustrate how to assign key bindings to such commands.
+
+ (global-set-key (kbd "<tab>") #'company-indent-or-complete-common)
+
+ (with-eval-after-load 'company
+ (define-key company-active-map (kbd "M-/") #'company-complete))
+
+ (with-eval-after-load 'company
+ (define-key company-active-map
+ (kbd "TAB")
+ #'company-complete-common-or-cycle)
+ (define-key company-active-map
+ (kbd "<backtab>")
+ (lambda ()
+ (interactive)
+ (company-complete-common-or-cycle -1))))
+
+In the same manner, an additional key can be assigned to a command or a
+command can be unbound from a key. For instance:
+
+ (with-eval-after-load 'company
+ (define-key company-active-map (kbd "M-.") #'company-show-location)
+ (define-key company-active-map (kbd "RET") nil))
+
+ ---------- Footnotes ----------
+
+ (1) For a more user-friendly output of the pre-defined key bindings,
+utilize ‘M-x describe-keymap <RET> company-active-map’ or
+‘C-h f <RET> company-mode’.
+
+\1f
+File: company.info, Node: Customization, Next: Frontends, Prev: Getting Started, Up: Top
+
+3 Customization
+***************
+
+Emacs provides two equally acceptable ways for user preferences
+configuration: via customization interface (for more details, *note
+(emacs)Easy Customization::) and a configuration file (*note (emacs)Init
+File::). Naturally, Company can be configured by both of these
+approaches.
+
+* Menu:
+
+* Customization Interface::
+* Configuration File::
+
+\1f
+File: company.info, Node: Customization Interface, Next: Configuration File, Up: Customization
+
+3.1 Customization Interface
+===========================
+
+In order to employ the customization interface, run
+‘M-x customize-group <RET> company’.
+
+This interface outputs all the options available for user customization,
+so you may find it beneficial to review this list even if you are going
+to configure Company with the configuration file.
+
+For instructions on how to change the settings, *note (emacs)Changing a
+Variable::.
+
+\1f
+File: company.info, Node: Configuration File, Prev: Customization Interface, Up: Customization
+
+3.2 Configuration File
+======================
+
+Company is a customization-rich package. This section lists some of the
+core settings that influence the overall behavior of the _company-mode_.
+
+ -- User Option: company-minimum-prefix-length
+ This is one of the values (together with ‘company-idle-delay’),
+ based on which Company auto-stars looking up completion candidates.
+ This option configures how many characters have to be typed in by a
+ user before candidates start to be collected and displayed. An
+ often choice nowadays is to configure this option to a lower number
+ than the default value of ‘3’.
+
+ -- User Option: company-idle-delay
+ This is the second of the options that configure Company’s
+ auto-start behavior (together with
+ ‘company-minimum-prefix-length’). The value of this option defines
+ how fast Company is going to react to the typed input, such that
+ setting ‘company-idle-delay’ to ‘0’ makes Company react
+ immediately, ‘nil’ disables auto-starting, and a larger value
+ postpones completion auto-start for that number of seconds. For an
+ even fancier setup, set this option value to a predicate function,
+ as shown in the following example:
+
+ (setq company-idle-delay
+ (lambda () (if (company-in-string-or-comment) nil 0.3)))
+
+ -- User Option: company-global-modes
+ This option allows to specify in which major modes _company-mode_
+ can be enabled by ‘(global-company-mode)’. *Note Initial Setup::.
+ The default value of ‘t’ enables Company in all major modes.
+ Setting ‘company-global-modes’ to ‘nil’ equal in action to toggling
+ off _global-company-mode_. Providing a list of major modes results
+ in having _company-mode_ enabled in the listed modes only. For the
+ opposite result, provide a list of major modes with ‘not’ being the
+ first element of the list, as shown in the following example:
+
+ (setq company-global-modes '(not erc-mode message-mode eshell-mode))
+
+ -- User Option: company-selection-wrap-around
+ Enable this option to loop (cycle) the candidates’ selection: after
+ selecting the last candidate on the list, a command to select the
+ next candidate does so with the first candidate. By default, this
+ option is disabled, which means the selection of the next candidate
+ stops on the last item. The selection of the previous candidate is
+ influenced by this option similarly.
+
+ -- User Option: company-require-match
+ To allow typing in characters that don’t match the candidates, set
+ the value of this option to ‘nil’. For an opposite behavior (that
+ is, to disallow non-matching input), set it to ‘t’. By default,
+ Company is configured to require a matching input only if a user
+ manually enables completion or selects a candidate; by having the
+ option configured to call the function ‘company-explicit-action-p’.
+
+ -- User Option: company-lighter-base
+ This user options allows to configure a string indicator of the
+ enabled _company-mode_ in the mode line. The default value is
+ ‘company’.
+
+ -- User Option: company-insertion-on-trigger
+ One more pair of the user options may instruct Company to complete
+ with the selected candidate by typing one of the
+ ‘company-insertion-triggers’. The user option
+ ‘company-insertion-on-trigger’ can be enabled or disabled by
+ setting its value to one of: ‘nil’, ‘t’, or a predicate function
+ name. *note Predicate: (eintr)Wrong Type of Argument.
+
+ -- User Option: company-insertion-triggers
+ This option has an effect only when ‘company-insertion-on-trigger’
+ is enabled. The value can be one of: a string of characters, a
+ list of syntax description characters (*note (elisp)Syntax Class
+ Table::), or a predicate function. By default, this user option is
+ set to the list of the syntax characters: ‘(?\ ?\) ?.)’, which
+ translates to the whitespaces, close parenthesis, and punctuation.
+ It is safe to configure the value to a character that can
+ potentially be part of a valid completion; in this case, Company
+ does not treat such characters as triggers.
+
+Hooks
+-----
+
+Company exposes the following life-cycle hooks:
+
+ -- User Option: company-completion-started-hook
+
+ -- User Option: company-completion-cancelled-hook
+
+ -- User Option: company-completion-finished-hook
+
+ -- User Option: company-after-completion-hook
+
+\1f
+File: company.info, Node: Frontends, Next: Backends, Prev: Customization, Up: Top
+
+4 Frontends
+***********
+
+Company is packaged with several frontends and provides a predefined set
+of enabled frontends. A list of the enabled frontends can be changed by
+configuring the user option ‘company-frontends’.
+
+Each frontend is simply a function that receives a command and acts
+accordingly to it: outputs candidates, hides its output, refreshes
+displayed data, and so on.
+
+All of the Company frontends can be categorized by the type of the
+output into the three groups: “tooltip-”, “preview-”, and “echo-”
+frontends. We overview these groups in the first sections of this
+chapter. The sections that follow are dedicated to the ways the
+displayed candidates can be searched, filtered, and quick-accessed.
+
+* Menu:
+
+* Tooltip Frontends::
+* Preview Frontends::
+* Echo Frontends::
+* Candidates Search::
+* Filter Candidates::
+* Quick Access a Candidate::
+
+\1f
+File: company.info, Node: Tooltip Frontends, Next: Preview Frontends, Up: Frontends
+
+4.1 Tooltip Frontends
+=====================
+
+This group of frontends displays completion candidates in an overlayed
+tooltip (aka pop-up). Company provides three _tooltip frontends_,
+listed below.
+
+ -- Function: company-pseudo-tooltip-unless-just-one-frontend
+ This is one of the default frontends. It starts displaying a
+ tooltip only if more than one completion candidate is available,
+ which nicely combines — and it is done so by default — with
+ ‘company-preview-if-just-one-frontend’, *note Preview Frontends::.
+
+ -- Function: company-pseudo-tooltip-frontend
+ This frontend outputs a tooltip for any number of completion
+ candidates.
+
+ -- Function: company-pseudo-tooltip-unless-just-one-frontend-with-delay
+ This is a peculiar frontend, that displays a tooltip only if more
+ than one candidate is available, and only after a delay. The delay
+ can be configured with the user option
+ ‘company-tooltip-idle-delay’. A typical use case for plugging in
+ this frontend would be displaying a tooltip only on a manual
+ request (when needed), as shown in the following example:
+
+ (setq company-idle-delay 0
+ company-tooltip-idle-delay 10
+ company-require-match nil
+ company-frontends
+ '(company-pseudo-tooltip-unless-just-one-frontend-with-delay
+ company-preview-frontend
+ company-echo-metadata-frontend)
+ company-backends '(company-capf))
+
+ (global-set-key (kbd "<tab>")
+ (lambda ()
+ (interactive)
+ (let ((company-tooltip-idle-delay 0.0))
+ (company-complete)
+ (and company-candidates
+ (company-call-frontends 'post-command)))))
+
+User Options
+------------
+
+To change the _tooltip frontends_ configuration, adjust the following
+user options.
+
+ -- User Option: company-tooltip-align-annotations
+ An “annotation” is a string that carries additional information
+ about a candidate; such as a data type, function arguments, or
+ whatever a backend appoints to be a valuable piece of information
+ about a candidate. By default, the annotations are shown right
+ beside the candidates. Setting the option value to ‘t’ aligns
+ annotations to the right side of the tooltip.
+
+ (setq company-tooltip-align-annotations t)
+
+ \0\b[image src="./images/small/tooltip-annotations.png"\0\b]
+
+ -- User Option: company-tooltip-annotation-padding
+ Adds left padding to the candidates’ annotations. It is disabled
+ by default. If ‘company-tooltip-align-annotations’ is enabled,
+ ‘company-tooltip-annotation-padding’ defines the minimum spacing
+ between a candidate and annotation, with the default value of 1.
+
+ (setq company-tooltip-annotation-padding 1)
+
+ -- User Option: company-tooltip-limit
+ Controls the maximum number of the candidates shown simultaneously
+ in the tooltip (the default value is ‘10’). When the number of the
+ available candidates is larger than this option’s value, Company
+ paginates the results.
+
+ (setq company-tooltip-limit 4)
+
+ \0\b[image src="./images/small/tooltip-limit.png"\0\b]
+
+ -- User Option: company-tooltip-offset-display
+ Use this option to choose in which way to output paginated results.
+ The default value is ‘scrollbar’. Another supported value is
+ ‘lines’; choose it to show the quantity of the candidates not
+ displayed by the current tooltip page.
+
+ (setq company-tooltip-offset-display 'lines)
+
+ \0\b[image src="./images/small/tooltip-offset-display.png"\0\b]
+
+ -- User Option: company-tooltip-minimum
+ This user option acts only when a tooltip is shown close to the
+ bottom of a window. It guarantees visibility of this number of
+ completion candidates below point. When the number of lines
+ between point and the bottom of a window is less than
+ ‘company-tooltip-minimum’ value, the tooltip is displayed above
+ point.
+
+ (setq company-tooltip-minimum 4)
+
+ \0\b[image src="./images/small/tooltip-minimum-below.png"\0\b]
+
+
+ \0\b[image src="./images/small/tooltip-minimum-above.png"\0\b]
+
+ -- User Option: company-tooltip-flip-when-above
+ This is one of the fancy features Company has to suggest. When
+ this setting is enabled, no matter if a tooltip is shown above or
+ below point, the candidates are always listed starting near point.
+ (Putting it differently, the candidates are mirrored horizontally
+ if a tooltip changes its position, instead of being commonly listed
+ top-to-bottom.)
+
+ (setq company-tooltip-flip-when-above t)
+
+ \0\b[image src="./images/small/tooltip-flip.png"\0\b]
+
+ -- User Option: company-tooltip-minimum-width
+ Sets the minimum width of a tooltip, excluding the margins and the
+ scroll bar. Changing this value especially makes sense if a user
+ navigates between tooltip pages. Keeping this value at the default
+ ‘0’ allows Company to always adapt the width of the tooltip to the
+ longest shown candidate. Enlarging ‘company-tooltip-minimum-width’
+ prevents possible significant shifts in the width of the tooltip
+ when navigating to the next/previous tooltip page. (For an
+ alternate solution, see ‘company-tooltip-width-grow-only’.)
+
+ -- User Option: company-tooltip-width-grow-only
+ This is another way to restrict auto-adaptation of the tooltip
+ width (another is by adjusting ‘company-tooltip-minimum-width’
+ value) when navigating between the tooltip pages.
+
+ -- User Option: company-tooltip-maximum-width
+ This user option controls the maximum width of the tooltip inner
+ area. By default, its value is pseudo-limitless, potentially
+ permitting the output of extremely long candidates. But if long
+ lines become an issue, set this option to a smaller number, such as
+ ‘60’ or ‘70’.
+
+ -- User Option: company-tooltip-margin
+ Controls the width of the “margin” on the sides of the tooltip
+ inner area. If ‘company-format-margin-function’ is set,
+ ‘company-tooltip-margin’ defines only the right margin.
+
+ (setq company-tooltip-margin 3)
+
+ \0\b[image src="./images/small/tooltip-margin.png"\0\b]
+
+Candidates Icons
+----------------
+
+An “icon” is an image or a text that represents a candidate’s kind; it
+is displayed in front of a candidate. The term “kind” here stands for a
+high-level category a candidate fits into. (Such as ‘array’,
+‘function’, ‘file’, ‘string’, ‘color’, etc. For an extended list of the
+possible _kinds_, see the user option ‘company-text-icons-mapping’ or
+the variable ‘company-vscode-icons-mapping’.)
+
+ -- User Option: company-format-margin-function
+ Allows setting a function to format the left margin of a tooltip
+ inner area; namely, to output candidate’s _icons_. The predefined
+ formatting functions are listed below. A user may also set this
+ option to a custom function. To disable left margin formatting,
+ set the value of the option to ‘nil’ (this way control over the
+ size of the left margin returns to the user option
+ ‘company-tooltip-margin’).
+
+ -- Function: company-vscode-dark-icons-margin
+ -- Function: company-vscode-light-icons-margin
+ These functions utilize VSCode dark and light theme icon sets (1).
+ The related two user options are ‘company-icon-size’ and
+ ‘company-icon-margin’.
+
+ \0\b[image src="./images/small/tooltip-icons-vscode.png"\0\b]
+
+ -- Function: company-text-icons-margin
+ This function produces letters and symbols formatted according to
+ the ‘company-text-icons-format’. The rest of the user options
+ affecting this function behavior are listed below.
+
+ \0\b[image src="./images/small/tooltip-icons-text.png"\0\b]
+
+ -- Function: company-dot-icons-margin
+ This function produces a colored Unicode symbol of a circle
+ formatted according to the ‘company-dot-icons-format’. Other user
+ options that affect the resulting output are listed below.
+
+ \0\b[image src="./images/small/tooltip-icons-dot.png"\0\b]
+
+The following user options influence appearance of the _text_ and _dot_
+_icons_.
+
+ -- User Option: company-text-icons-mapping
+ Lists candidates’ _kinds_ with their corresponding _icons_
+ configurations.
+
+ -- User Option: company-text-face-extra-attributes
+ A list of face attributes to be applied to the _icons_.
+
+ (setq company-text-face-extra-attributes
+ '(:weight bold :slant italic))
+
+ \0\b[image src="./images/small/tooltip-icon-face.png"\0\b]
+
+ -- User Option: company-text-icons-add-background
+ If this option is enabled, when an _icon_ doesn’t have a background
+ configured by ‘company-text-icons-mapping’, then a generated
+ background is applied.
+
+ (setq company-text-icons-add-background t)
+
+ \0\b[image src="./images/small/tooltip-icon-bg.png"\0\b]
+
+ -- Function: company-detect-icons-margin
+ This is the default margin formatting function, that applies one of
+ the ‘company-vscode-*-icons-margin’ functions if ‘vscode’ icons set
+ is supported; otherwise applies a ‘company-text-icons-margin’
+ function.
+
+Faces
+-----
+
+Out-of-the-box Company defines and configures distinguished faces (*note
+(emacs)Faces::) for light and dark themes. Moreover, some of the
+built-in and third-party themes fine-tune Company to fit their palettes.
+That is why there’s often no real need to make such adjustments on a
+user side. However, this chapter presents some hints on where to start
+customizing Company interface.
+
+Namely, the look of a tooltip is controlled by the ‘company-tooltip*’
+named faces.
+
+The following example hints how a user may approach tooltip faces
+customization:
+
+ (custom-set-faces
+ '(company-tooltip
+ ((t (:background "ivory" :foreground "MistyRose3"))))
+ '(company-tooltip-selection
+ ((t (:background "LemonChiffon1" :foreground "MistyRose4"))))
+ '(company-tooltip-common ((t (:weight bold :foreground "pink1"))))
+ '(company-scrollbar-fg ((t (:background "ivory3"))))
+ '(company-scrollbar-bg ((t (:background "ivory2"))))
+ '(company-tooltip-annotation ((t (:foreground "MistyRose2")))))
+
+ \0\b[image src="./images/small/tooltip-faces-light.png"\0\b]
+
+ ---------- Footnotes ----------
+
+ (1) SVG images support has to be enabled in Emacs for these icons set
+to be used. The supported images types can be checked with ‘C-h v
+image-types’. Before compiling Emacs, make sure ‘librsvg’ is installed
+on your system.
+
+\1f
+File: company.info, Node: Preview Frontends, Next: Echo Frontends, Prev: Tooltip Frontends, Up: Frontends
+
+4.2 Preview Frontends
+=====================
+
+Frontends in this group output a completion candidate or a common part
+of the candidates temporarily inline, as if a word had already been
+completed (1).
+
+ -- Function: company-preview-if-just-one-frontend
+ This is one of the frontends enabled by default. This frontend
+ outputs a preview if only one completion candidate is available; it
+ is a good suit to be combined with
+ ‘company-pseudo-tooltip-unless-just-one-frontend’, *note Tooltip
+ Frontends::.
+
+ -- Function: company-preview-frontend
+ This frontend outputs the first of the available completion
+ candidates inline for a preview.
+
+ -- Function: company-preview-common-frontend
+ As the name of this frontend suggests, it outputs for a preview
+ only a common part of the candidates.
+
+The look of the preview is controlled by the following faces:
+‘company-preview’, ‘company-preview-common’, and
+‘company-preview-search’.
+
+ \0\b[image src="./images/small/preview-light.png"\0\b]
+
+
+ \0\b[image src="./images/small/preview-dark.png"\0\b]
+
+ ---------- Footnotes ----------
+
+ (1) The candidates retrieved according to ‘non-prefix’ matches (*note
+Terminology::) may be shown in full after point.
+
+\1f
+File: company.info, Node: Echo Frontends, Next: Candidates Search, Prev: Preview Frontends, Up: Frontends
+
+4.3 Echo Frontends
+==================
+
+The frontends listed in this section display information in the Emacs’s
+echo area, *note (emacs)Echo Area::.
+
+ -- Function: company-echo-metadata-frontend
+ This frontend is a part of the predefined frontends set. Its
+ responsibility is to output a short documentation string for a
+ completion candidate in the echo area.
+
+ \0\b[image src="./images/small/echo-meta.png"\0\b]
+
+
+The last pair of the built-in frontends isn’t that commonly used and not
+as full-featured as the previously reviewed _tooltip-_ and _preview-_
+frontends, but still, feel free to play with them and have some fun!
+
+ -- Function: company-echo-frontend
+ This frontend outputs all the available completion candidates in
+ the echo area.
+
+ \0\b[image src="./images/small/echo.png"\0\b]
+
+ -- Function: company-echo-strip-common-frontend
+ It acts similarly to the previous frontend but outputs a common
+ part of the candidates once for all of them.
+
+ \0\b[image src="./images/small/echo-strip.png"\0\b]
+
+ -- User Option: company-echo-truncate-lines
+ This is the only _echo frontends_ targeted setting. When enabled,
+ the output is truncated to fit the echo area. This setting is set
+ to ‘t’ by default.
+
+To apply visual changes to the output of these frontends, configure the
+faces ‘company-echo’ and ‘company-echo-common’.
+
+\1f
+File: company.info, Node: Candidates Search, Next: Filter Candidates, Prev: Echo Frontends, Up: Frontends
+
+4.4 Candidates Search
+=====================
+
+By default, when _company-mode_ is in action, a key binding ‘C-s’ starts
+looking for matches to additionally typed characters among the displayed
+candidates. When a search is initiated, an indicator
+‘Search: CHARACTERS’ is shown in the Emacs’s mode line.
+
+To quit the search mode, hit ‘C-g’.
+
+ -- User Option: company-search-regexp-function
+ The value of this user option must be a function that interprets
+ the search input. By default it is set to the function
+ ‘regexp-quote’, with looks for an exact match. Company defines
+ several more functions suitable for this option. They are listed
+ below.
+
+ -- Function: company-search-words-regexp
+ Searches for words separated with spaces in the given order.
+
+ -- Function: company-search-words-in-any-order-regexp
+ Searches for words separated with spaces in any order.
+
+ -- Function: company-search-flex-regexp
+ Searches for characters in the given order, with anything in
+ between.
+
+Search matches are distinguished by the ‘company-tooltip-search’ and
+‘company-tooltip-search-selection’ faces.
+
+ \0\b[image src="./images/small/tooltip-search.png"\0\b]
+
+\1f
+File: company.info, Node: Filter Candidates, Next: Quick Access a Candidate, Prev: Candidates Search, Up: Frontends
+
+4.5 Filter Candidates
+=====================
+
+Candidates filtering is started by typing the default key binding
+‘C-M-s’. Filtering acts on a par with the search (*note Candidates
+Search::), indicating its activation by the text ‘Filter: CHARACTERS’ in
+the mode line and influencing the displayed candidates. The difference
+is that the filtering, as its name suggests, keeps displaying only the
+matching candidates (in addition to distinguishing the matches with a
+face).
+
+To quit the filtering, hit ‘C-g’. To toggle between search and filter
+states, use key binding ‘C-o’.
+
+ \0\b[image src="./images/small/tooltip-filter.png"\0\b]
+
+\1f
+File: company.info, Node: Quick Access a Candidate, Prev: Filter Candidates, Up: Frontends
+
+4.6 Quick Access a Candidate
+============================
+
+Company provides a way to choose a candidate for completion without
+having to navigate to that candidate: by hitting one of the quick-access
+keys. By default, quick-access key bindings utilize a modifier <META>
+and one of the digits, such that pressing ‘M-1’ completes with the first
+candidate on the list and ‘M-0’ with the tenth candidate.
+
+If ‘company-show-quick-access’ is enabled, _tooltip-_ and _echo-_
+frontends show quick-access hints.
+
+ (setq company-show-quick-access 'left)
+
+ \0\b[image src="./images/small/tooltip-quick-access.png"\0\b]
+
+
+ \0\b[image src="./images/small/echo-qa.png"\0\b]
+
+
+ \0\b[image src="./images/small/echo-strip-qa.png"\0\b]
+
+To customize the key bindings, either do it via Customization Interface
+(*note Customization Interface::) or use the following approach:
+
+ (custom-set-variables
+ '(company-quick-access-keys '("a" "o" "e" "u" "i"))
+ '(company-quick-access-modifier 'super))
+
+A modifier should be one of ‘meta’, ‘super’, ‘hyper’, ‘ control’.
+
+The following example applies a bit of customization and demonstrates
+how to change quick-access hints faces.
+
+ (setq company-show-quick-access t)
+
+ (custom-set-faces
+ '(company-tooltip-quick-access ((t (:foreground "pink1"))))
+ '(company-tooltip-quick-access-selection
+ ((t (:foreground "pink1" :slant italic)))))
+
+ \0\b[image src="./images/small/tooltip-qa-faces-light.png"\0\b]
+
+\1f
+File: company.info, Node: Backends, Next: Troubleshooting, Prev: Frontends, Up: Top
+
+5 Backends
+**********
+
+We can metaphorically say that each backend is like an engine. (The
+reality is even better since backends are just functions.) Fueling such
+an engine with a command causes the production of material for Company
+to move further on. Typically, moving on means outputting that material
+to a user via one or several configured frontends, *note Frontends::.
+
+Just like Company provides a preconfigured list of the enabled
+frontends, it also defines a list of the backends to rely on by default.
+This list is stored in the user option ‘company-backends’. The
+docstring of this variable has been a source of valuable information for
+years. That’s why we’re going to stick to a tradition and suggest
+reading the output of ‘C-h v company-backends’ for insightful details
+about backends. Nevertheless, the fundamental concepts are described in
+this user manual too.
+
+* Menu:
+
+* Backends Usage Basics::
+* Grouped Backends::
+* Package Backends::
+* Candidates Post-Processing::
+
+\1f
+File: company.info, Node: Backends Usage Basics, Next: Grouped Backends, Up: Backends
+
+5.1 Backends Usage Basics
+=========================
+
+One of the significant concepts to understand about Company is that the
+package relies on one backend at a time (1). The backends are invoked
+one by one, in the sequential order of the items on the
+‘company-backends’ list.
+
+The name of the currently active backend is shown in the mode line and
+in the output of the command ‘M-x company-diag’.
+
+In most cases (mainly to exclude false-positive results), the next
+backend is not invoked automatically. For the purpose of invoking the
+next backend, use the command ‘company-other-backend’: either by calling
+it with ‘M-x’ or by binding the command to the keys of your choice, such
+as:
+
+ (global-set-key (kbd "C-c C-/") #'company-other-backend)
+
+It is also possible to specifically start a backend with the command
+‘M-x company-begin-backend’ or by calling a backend by its name, for
+instance: ‘M-x company-capf’. As usual for Emacs, such backends calls
+can be assigned to key bindings, for example:
+
+ (global-set-key (kbd "C-c y") 'company-yasnippet)
+
+ ---------- Footnotes ----------
+
+ (1) The grouped backends act as one complex backend. *Note Grouped
+Backends::.
+
+\1f
+File: company.info, Node: Grouped Backends, Next: Package Backends, Prev: Backends Usage Basics, Up: Backends
+
+5.2 Grouped Backends
+====================
+
+In many cases, it can be desirable to receive candidates from several
+backends simultaneously. This can be achieved by configuring “grouped
+backends”: a sub-list of backends in the ‘company-backends’ list, that
+is handled specifically by Company.
+
+The most important part of this handling is the merge of the completion
+candidates from the grouped backends. (But only from the backends that
+return the same _prefix_ value, see ‘C-h v company-backends’ for more
+details.)
+
+To keep the candidates organized in accordance with the grouped backends
+order, add the keyword ‘:separate’ to the list of the grouped backends.
+The following example illustrates this.
+
+ (defun my-text-mode-hook ()
+ (setq-local company-backends
+ '((company-dabbrev company-ispell :separate)
+ company-files)))
+
+ (add-hook 'text-mode-hook #'my-text-mode-hook)
+
+Another keyword ‘:with’ helps to make sure the results from major/minor
+mode agnostic backends (such as _company-yasnippet_,
+_company-dabbrev-code_) are returned without preventing results from
+context-aware backends (such as _company-capf_ or _company-clang_). For
+this feature to work, put backends dependent on a mode at the beginning
+of the grouped backends list, then put a keyword ‘:with’, and only then
+put context agnostic backend(s), as shown in the following concise
+example:
+
+ (setq company-backends '((company-capf :with company-yasnippet)))
+
+\1f
+File: company.info, Node: Package Backends, Next: Candidates Post-Processing, Prev: Grouped Backends, Up: Backends
+
+5.3 Package Backends
+====================
+
+The following sections give a short overview of the commonly used
+backends bundled with Company. Each section is devoted to one of the
+roughly outlined groups of the backends.
+
+Some of the backends expose user options for customization; a few of
+these options are introduced below. For those who would like to fetch
+the full list of a backend’s user options, we suggest doing one of the
+following:
+
+ • Execute command ‘M-x customize-group <RET> <backend-name>’.
+
+ • Open the source file of the backend and run
+ ‘M-x occur <RET> ^(defcustom’.
+
+ − Optionally, search for the matches with
+ ‘M-x isearch <RET> (defcustom’.
+
+* Menu:
+
+* Code Completion::
+* Text Completion::
+* File Name Completion::
+* Template Expansion::
+
+\1f
+File: company.info, Node: Code Completion, Next: Text Completion, Up: Package Backends
+
+5.3.1 Code Completion
+---------------------
+
+ -- Function: company-capf
+ In the Emacs’s world, the current tendency is to have the
+ completion logic provided by ‘completion-at-point-functions’ (CAPF)
+ implementations. [Among the other things, this is what the popular
+ packages that support language server protocol (LSP) also rely on.]
+
+ Since _company-capf_ works as a bridge to the standard CAPF
+ facility, it is probably the most often used and recommended
+ backend nowadays, including for Emacs Lisp coding.
+
+ Just to illustrate, the following minimal backends setup
+
+ (setq company-backends '((company-capf company-dabbrev-code)))
+
+ might cover a large number of basic use cases, especially so in
+ major modes that have CAPF support implemented.
+
+ For more details on CAPF, *note (elisp)Completion in Buffers::.
+
+ -- Function: company-dabbrev-code
+ This backend works similarly to the built-in Emacs package
+ _dabbrev_, searching for completion candidates inside the contents
+ of the open buffer(s). Internally, its based on the backend
+ _company-dabbrev_ (*note Text Completion::).
+
+ -- Function: company-keywords
+ This backend provides completions for many of the widely spread
+ programming languages _keywords_: words bearing specific meaning in
+ a language.
+
+ -- Function: company-clang
+ As the name suggests, use this backend to get completions from
+ _Clang_ compiler; that is, for the languages in the _C_ language
+ family: _C_, _C++_, _Objective-C_.
+
+ -- Function: company-semantic
+ This backend relies on a built-in Emacs package that provides
+ language-aware editing commands based on source code parsers, *note
+ (emacs)Semantic::. Having enabled _semantic-mode_ makes it to be
+ used by the CAPF mechanism (*note (emacs)Symbol Completion::),
+ hence a user may consider enabling _company-capf_ backend instead.
+
+ -- Function: company-etags
+ This backend works on top of a built-in Emacs package _etags_,
+ *note (emacs)Tags Tables::. Similarly to aforementioned _Semantic_
+ usage, tags-based completions now are a part of the Emacs’ CAPF
+ facility, therefore a user may consider switching to _company-capf_
+ backend.
+
+\1f
+File: company.info, Node: Text Completion, Next: File Name Completion, Prev: Code Completion, Up: Package Backends
+
+5.3.2 Text Completion
+---------------------
+
+ -- Function: company-dabbrev
+ This backend works similarly to the built-in Emacs package
+ _dabbrev_, searching for completion candidates inside the contents
+ of the open buffer(s). It is one of the often used backends, and
+ it has several interesting options for configuration. Let’s review
+ a few of them.
+
+ -- User Option: company-dabbrev-minimum-length
+ This option sets the minimum length of a completion candidate
+ to collect from the text. The default value of ‘4’ is
+ intended to prevent potential performance issues. But in many
+ scenarios, it may be acceptable to lower this value. Note
+ that this option also affects the behavior of the
+ _company-dabbrev-code_ backend.
+
+ (setq company-dabbrev-minimum-length 2)
+
+ -- User Option: company-dabbrev-other-buffers
+ By default, _company-dabbrev_ collects completion candidates
+ from all not ignored buffers (see more on that below). This
+ behavior can be changed to collecting candidates from the
+ current buffer only (by setting the value to ‘nil’) or from
+ the buffers with the same major mode:
+
+ (setq company-dabbrev-other-buffers t)
+
+ -- User Option: company-dabbrev-ignore-buffers
+ The value of this option should be a regexp or a predicate
+ function that can be used to match a buffer name. The matched
+ buffers are omitted from the search for completion candidates.
+
+ The last two options described here relate to handling uppercase
+ and lowercase letters in completion candidates. The illustrative
+ examples given below can be reproduced in the ‘*scratch*’ buffer,
+ with the word ‘Enjoy’ typed in, and with this initial setup:
+
+ (setq-local company-backends '(company-dabbrev)
+ company-dabbrev-other-buffers nil
+ company-dabbrev-ignore-case nil
+ company-dabbrev-downcase nil)
+
+ -- User Option: company-dabbrev-ignore-case
+ This user option controls whether the case is ignored when
+ collecting completion candidates. When the option is set to
+ ‘nil’, ‘Enjoy’ is suggested as a completion candidate for the
+ typed ‘Enj’ letters, but not for ‘enj’. When the option is
+ set to ‘t’, ‘Enjoy’ is suggested as a candidate for both ‘Enj’
+ and ‘enj’ input; note that ‘enj’ prefix is “overwritten” by
+ completing with the ‘Enjoy’ candidate. The third, default,
+ type of behavior solves this issue, keeping the case of the
+ typed prefix (and still collecting candidates
+ case-insensitively):
+
+ (setq company-dabbrev-ignore-case 'keep-prefix)
+
+ Now we can type ‘enj’, complete it with the suggested ‘Enjoy’,
+ and _enjoy_ the result.
+
+ -- User Option: company-dabbrev-downcase
+ This user option controls whether completion candidates are
+ down-cased before their display. When the option is set to
+ ‘nil’, no transformation is performed; in the environment
+ described above, typing ‘Enj’ results in the candidate ‘Enjoy’
+ being suggested. When the option is set to ‘t’, the
+ down-cased candidate ‘enjoy’ is suggested. By default, this
+ option is set to ‘case-replace’, meaning taking a value of the
+ Emacs’s variable ‘case-replace’ (‘t’ is the current default).
+
+
+ -- Function: company-ispell
+ This backend returns completion candidates collected by _Ispell_, a
+ built-in Emacs package that performs spell-checking. *Note
+ Checking and Correcting Spelling: (emacs)Spelling. Note that
+ _Ispell_ uses only one dictionary at a time (combining several
+ dictionaries into one file is an accepted practice). By default,
+ _company-ispell_ suggests candidates from a dictionary specified by
+ the Emacs’s setting ‘ispell-complete-word-dict’.
+
+ -- User Option: company-ispell-dictionary
+ Optionally, set a file path for _company-ispell_ to use
+ another dictionary.
+
+\1f
+File: company.info, Node: File Name Completion, Next: Template Expansion, Prev: Text Completion, Up: Package Backends
+
+5.3.3 File Name Completion
+--------------------------
+
+ -- Function: company-files
+ This backend can be used to retrieve completion candidates for the
+ absolute and relative paths in the directory structure of an
+ operating system. The behavior of the _company-files_ backend can
+ be adjusted with the two user options.
+
+ -- User Option: company-files-exclusions
+ It may be desirable to exclude directories or files from the
+ list of suggested completion candidates. For example,
+ someone’s setup might look this way:
+
+ (setq company-files-exclusions '(".git/" ".DS_Store"))
+
+ -- User Option: company-files-chop-trailing-slash
+ This setting is enabled by default, which results in stripping
+ off a trailing slash from an inserted directory name. On
+ typing a trailing slash, the process of completion gets
+ started again, from inside the just inserted directory.
+
+ Setting ‘company-files-chop-trailing-slash’ to ‘nil’ makes
+ directory names to be inserted as is, with a trailing slash.
+ In this case, the completion process can be continued, for
+ example, either by explicitly calling _company-files_ backend
+ (*note Backends Usage Basics::) or by starting typing a name
+ of a file/directory known to be located under the inserted
+ directory.
+
+\1f
+File: company.info, Node: Template Expansion, Prev: File Name Completion, Up: Package Backends
+
+5.3.4 Template Expansion
+------------------------
+
+ -- Function: company-abbrev
+ This is a completion backend for a built-in word abbreviation mode
+ (*note (emacs)Abbrevs::), that allows completing abbreviations with
+ their expansions.
+
+ -- Function: company-tempo
+ A backend for users of Tempo
+ (https://www.lysator.liu.se/~davidk/elisp/), one more built-in
+ Emacs package for creating and inserting (expanding) templates.
+
+ -- Function: company-yasnippet
+ Used as a completion backend for the popular third-party template
+ system YASnippet (https://github.com/joaotavora/yasnippet).
+
+\1f
+File: company.info, Node: Candidates Post-Processing, Prev: Package Backends, Up: Backends
+
+5.4 Candidates Post-Processing
+==============================
+
+A list of completion candidates, supplied by a backend, can be
+additionally manipulated (reorganized, reduced, sorted, etc) before its
+output. This is done by adding a processing function name to the user
+option ‘company-transformers’ list, for example:
+
+ (setq company-transformers '(delete-consecutive-dups
+ company-sort-by-occurrence))
+
+Company is bundled with several such transformer functions. They are
+listed below.
+
+ -- Function: company-sort-by-occurrence
+ Sorts candidates using ‘company-occurrence-weight-function’
+ algorithm.
+
+ -- User Option: company-occurrence-weight-function
+ Can be set to one of ‘company-occurrence-prefer-closest-above’
+ (default) or ‘company-occurrence-prefer-any-closest’. This user
+ option defines the behavior of the ‘company-sort-by-occurrence’
+ transformer function.
+
+ -- Function: company-sort-by-backend-importance
+ Sorts candidates as two priority groups, differentiated by the
+ keyword ‘:with’ (*note Grouped Backends::). Backends positioned in
+ the backends list before the keyword ‘:with’ are treated as more
+ important.
+
+ -- Function: company-sort-prefer-same-case-prefix
+ Gives preference to the candidates that match the prefix
+ case-insensitively.
+
+\1f
+File: company.info, Node: Troubleshooting, Next: Index, Prev: Backends, Up: Top
+
+6 Troubleshooting
+*****************
+
+If something goes wrong, the first thing we recommend doing is to
+execute command ‘M-x company-diag’ and thoroughly study its output.
+
+This command outputs important details about the internal workings of
+Company at the moment of the ‘company-diag’ command execution, including
+a responsible backend and a list of completion candidates provided by
+it.
+
+Based on the value of the ‘Used backend’ in the output of the command
+‘M-x company-diag’, these possible actions may follow:
+
+ • If the used backend does not belong to the Company package, report
+ the issue to the corresponding third-party package maintainer(s).
+
+ • If the used backend is ‘company-capf’, then take a look at the line
+ starting with ‘Value of c-a-p-f:’. The issue could have been
+ caused by a function listed there. To identify to which package it
+ belongs, type ‘M-x find-function <RET> <function-name> <RET>’.
+
+If the aforementioned steps didn’t help to find the cause of the issue,
+then file a bug report to
+the Company Issue Tracker (https://github.com/company-mode/company-mode/issues),
+attaching the following information:
+
+ 1. Output of the ‘M-x company-diag’.
+
+ 2. The exact error message: you can find it in the ‘*Messages*’
+ buffer.
+
+ 3. The steps to reproduce the behavior. Ideally, if you can, starting
+ with a bare Emacs session: ‘emacs -Q’.
+
+ 4. The backtrace of the error, which you can get by running the
+ command: ‘M-x toggle-debug-on-error’ before reproducing the error.
+
+\1f
+File: company.info, Node: Index, Prev: Troubleshooting, Up: Top
+
+Index
+*****
+
+* Menu:
+
+* Key Index::
+* Variable Index::
+* Function Index::
+* Concept Index::
+
+\1f
+File: company.info, Node: Key Index, Next: Variable Index, Up: Index
+
+Key Index
+=========
+
+\0\b[index\0\b]
+* Menu:
+
+* C-g: Usage Basics. (line 20)
+* C-g <1>: Commands. (line 30)
+* C-g <2>: Candidates Search. (line 11)
+* C-g <3>: Filter Candidates. (line 14)
+* C-h: Commands. (line 34)
+* C-M-s: Filter Candidates. (line 6)
+* C-n: Usage Basics. (line 12)
+* C-n <1>: Commands. (line 11)
+* C-o: Filter Candidates. (line 14)
+* C-p: Usage Basics. (line 12)
+* C-p <1>: Commands. (line 16)
+* C-s: Candidates Search. (line 6)
+* C-w: Commands. (line 42)
+* M-<digit>: Quick Access a Candidate.
+ (line 6)
+* RET: Usage Basics. (line 15)
+* RET <1>: Commands. (line 21)
+* TAB: Usage Basics. (line 17)
+* TAB <1>: Commands. (line 25)
+
+\1f
+File: company.info, Node: Variable Index, Next: Function Index, Prev: Key Index, Up: Index
+
+Variable Index
+==============
+
+\0\b[index\0\b]
+* Menu:
+
+* company-after-completion-hook: Configuration File. (line 94)
+* company-backends: Backends. (line 12)
+* company-backends <1>: Backends Usage Basics.
+ (line 6)
+* company-backends <2>: Grouped Backends. (line 6)
+* company-completion-cancelled-hook: Configuration File. (line 90)
+* company-completion-finished-hook: Configuration File. (line 92)
+* company-completion-started-hook: Configuration File. (line 88)
+* company-dabbrev-downcase: Text Completion. (line 64)
+* company-dabbrev-ignore-buffers: Text Completion. (line 32)
+* company-dabbrev-ignore-case: Text Completion. (line 47)
+* company-dabbrev-minimum-length: Text Completion. (line 13)
+* company-dabbrev-other-buffers: Text Completion. (line 23)
+* company-dot-icons-format: Tooltip Frontends. (line 187)
+* company-echo-truncate-lines: Echo Frontends. (line 33)
+* company-files-chop-trailing-slash: File Name Completion.
+ (line 19)
+* company-files-exclusions: File Name Completion.
+ (line 12)
+* company-format-margin-function: Tooltip Frontends. (line 161)
+* company-frontends: Frontends. (line 6)
+* company-global-modes: Configuration File. (line 31)
+* company-icon-margin: Tooltip Frontends. (line 172)
+* company-icon-size: Tooltip Frontends. (line 172)
+* company-idle-delay: Configuration File. (line 17)
+* company-insertion-on-trigger: Configuration File. (line 64)
+* company-insertion-triggers: Configuration File. (line 72)
+* company-ispell-dictionary: Text Completion. (line 84)
+* company-lighter-base: Configuration File. (line 59)
+* company-minimum-prefix-length: Configuration File. (line 9)
+* company-mode: Initial Setup. (line 6)
+* company-occurrence-weight-function: Candidates Post-Processing.
+ (line 21)
+* company-require-match: Configuration File. (line 51)
+* company-search-regexp-function: Candidates Search. (line 13)
+* company-selection-wrap-around: Configuration File. (line 43)
+* company-show-quick-access: Quick Access a Candidate.
+ (line 14)
+* company-text-face-extra-attributes: Tooltip Frontends. (line 200)
+* company-text-icons-add-background: Tooltip Frontends. (line 208)
+* company-text-icons-format: Tooltip Frontends. (line 179)
+* company-text-icons-mapping: Tooltip Frontends. (line 196)
+* company-tooltip-align-annotations: Tooltip Frontends. (line 52)
+* company-tooltip-annotation-padding: Tooltip Frontends. (line 64)
+* company-tooltip-flip-when-above: Tooltip Frontends. (line 107)
+* company-tooltip-idle-delay: Tooltip Frontends. (line 22)
+* company-tooltip-limit: Tooltip Frontends. (line 72)
+* company-tooltip-margin: Tooltip Frontends. (line 141)
+* company-tooltip-maximum-width: Tooltip Frontends. (line 134)
+* company-tooltip-minimum: Tooltip Frontends. (line 92)
+* company-tooltip-minimum-width: Tooltip Frontends. (line 119)
+* company-tooltip-offset-display: Tooltip Frontends. (line 82)
+* company-tooltip-width-grow-only: Tooltip Frontends. (line 129)
+* company-transformers: Candidates Post-Processing.
+ (line 6)
+
+\1f
+File: company.info, Node: Function Index, Next: Concept Index, Prev: Variable Index, Up: Index
+
+Function Index
+==============
+
+\0\b[index\0\b]
+* Menu:
+
+* company-abbrev: Template Expansion. (line 6)
+* company-abort: Commands. (line 30)
+* company-begin-backend: Backends Usage Basics.
+ (line 23)
+* company-capf: Code Completion. (line 6)
+* company-clang: Code Completion. (line 36)
+* company-complete: Usage Basics. (line 10)
+* company-complete-common: Commands. (line 25)
+* company-complete-selection: Commands. (line 21)
+* company-dabbrev: Text Completion. (line 6)
+* company-dabbrev-code: Code Completion. (line 25)
+* company-detect-icons-margin: Tooltip Frontends. (line 217)
+* company-diag: Backends Usage Basics.
+ (line 11)
+* company-diag <1>: Troubleshooting. (line 6)
+* company-dot-icons-margin: Tooltip Frontends. (line 186)
+* company-echo-frontend: Echo Frontends. (line 21)
+* company-echo-metadata-frontend: Echo Frontends. (line 9)
+* company-echo-strip-common-frontend: Echo Frontends. (line 27)
+* company-etags: Code Completion. (line 48)
+* company-files: File Name Completion.
+ (line 6)
+* company-ispell: Text Completion. (line 75)
+* company-keywords: Code Completion. (line 31)
+* company-mode: Initial Setup. (line 6)
+* company-other-backend: Backends Usage Basics.
+ (line 14)
+* company-preview-common-frontend: Preview Frontends. (line 21)
+* company-preview-frontend: Preview Frontends. (line 17)
+* company-preview-if-just-one-frontend: Preview Frontends. (line 10)
+* company-pseudo-tooltip-frontend: Tooltip Frontends. (line 17)
+* company-pseudo-tooltip-unless-just-one-frontend: Tooltip Frontends.
+ (line 11)
+* company-pseudo-tooltip-unless-just-one-frontend-with-delay: Tooltip Frontends.
+ (line 21)
+* company-search-flex-regexp: Candidates Search. (line 26)
+* company-search-words-in-any-order-regexp: Candidates Search.
+ (line 23)
+* company-search-words-regexp: Candidates Search. (line 20)
+* company-select-next: Commands. (line 11)
+* company-select-next-or-abort: Commands. (line 11)
+* company-select-previous: Commands. (line 16)
+* company-select-previous-or-abort: Commands. (line 16)
+* company-semantic: Code Completion. (line 41)
+* company-show-doc-buffer: Commands. (line 34)
+* company-show-location: Commands. (line 42)
+* company-sort-by-backend-importance: Candidates Post-Processing.
+ (line 28)
+* company-sort-by-occurrence: Candidates Post-Processing.
+ (line 17)
+* company-sort-prefer-same-case-prefix: Candidates Post-Processing.
+ (line 34)
+* company-tempo: Template Expansion. (line 11)
+* company-text-icons-margin: Tooltip Frontends. (line 178)
+* company-tng-frontend: Structure. (line 26)
+* company-tng-mode: Structure. (line 26)
+* company-vscode-dark-icons-margin: Tooltip Frontends. (line 170)
+* company-vscode-light-icons-margin: Tooltip Frontends. (line 171)
+* company-yasnippet: Template Expansion. (line 16)
+* global-company-mode: Initial Setup. (line 18)
+
+\1f
+File: company.info, Node: Concept Index, Prev: Function Index, Up: Index
+
+Concept Index
+=============
+
+\0\b[index\0\b]
+* Menu:
+
+* abbrev: Template Expansion. (line 6)
+* abort: Usage Basics. (line 20)
+* abort <1>: Commands. (line 30)
+* activate: Initial Setup. (line 8)
+* active backend: Backends Usage Basics.
+ (line 11)
+* active backend <1>: Troubleshooting. (line 15)
+* annotation: Tooltip Frontends. (line 53)
+* auto-start: Initial Setup. (line 13)
+* backend: Structure. (line 6)
+* backend <1>: Structure. (line 10)
+* backend <2>: Backends Usage Basics.
+ (line 11)
+* backend <3>: Backends Usage Basics.
+ (line 14)
+* backend <4>: Troubleshooting. (line 15)
+* backends: Backends. (line 6)
+* backends <1>: Backends Usage Basics.
+ (line 6)
+* backends <2>: Grouped Backends. (line 6)
+* backends <3>: Package Backends. (line 6)
+* basics: Usage Basics. (line 6)
+* bug: Troubleshooting. (line 6)
+* bug <1>: Troubleshooting. (line 27)
+* bundled backends: Package Backends. (line 6)
+* cancel: Usage Basics. (line 20)
+* cancel <1>: Commands. (line 30)
+* candidate: Terminology. (line 10)
+* candidate <1>: Usage Basics. (line 12)
+* candidate <2>: Usage Basics. (line 15)
+* candidate <3>: Preview Frontends. (line 6)
+* color: Tooltip Frontends. (line 227)
+* color <1>: Quick Access a Candidate.
+ (line 37)
+* common part: Usage Basics. (line 17)
+* common part <1>: Commands. (line 25)
+* common part <2>: Preview Frontends. (line 6)
+* company-echo: Echo Frontends. (line 6)
+* company-preview: Preview Frontends. (line 6)
+* company-tng: Structure. (line 26)
+* company-tooltip: Tooltip Frontends. (line 227)
+* company-tooltip-search: Candidates Search. (line 6)
+* complete: Terminology. (line 6)
+* complete <1>: Usage Basics. (line 12)
+* complete <2>: Usage Basics. (line 15)
+* complete <3>: Usage Basics. (line 17)
+* complete <4>: Commands. (line 21)
+* complete <5>: Preview Frontends. (line 6)
+* completion: Terminology. (line 6)
+* completion <1>: Usage Basics. (line 12)
+* completion <2>: Usage Basics. (line 15)
+* completion <3>: Usage Basics. (line 17)
+* configure: Customization. (line 6)
+* configure <1>: Customization Interface.
+ (line 6)
+* configure <2>: Configuration File. (line 6)
+* configure <3>: Tooltip Frontends. (line 49)
+* configure <4>: Tooltip Frontends. (line 227)
+* configure <5>: Preview Frontends. (line 25)
+* configure <6>: Echo Frontends. (line 38)
+* configure <7>: Candidates Search. (line 30)
+* configure <8>: Quick Access a Candidate.
+ (line 28)
+* configure <9>: Quick Access a Candidate.
+ (line 37)
+* custom: Customization. (line 6)
+* custom <1>: Customization Interface.
+ (line 6)
+* custom <2>: Configuration File. (line 6)
+* custom <3>: Tooltip Frontends. (line 49)
+* custom <4>: Tooltip Frontends. (line 227)
+* custom <5>: Preview Frontends. (line 25)
+* custom <6>: Echo Frontends. (line 38)
+* custom <7>: Candidates Search. (line 30)
+* custom <8>: Quick Access a Candidate.
+ (line 28)
+* custom <9>: Quick Access a Candidate.
+ (line 37)
+* definition: Commands. (line 42)
+* distribution: Installation. (line 6)
+* doc: Commands. (line 34)
+* duplicate: Candidates Post-Processing.
+ (line 6)
+* echo: Echo Frontends. (line 6)
+* enable: Initial Setup. (line 8)
+* error: Troubleshooting. (line 6)
+* error <1>: Troubleshooting. (line 27)
+* expansion: Template Expansion. (line 6)
+* extensible: Structure. (line 6)
+* face: Tooltip Frontends. (line 227)
+* face <1>: Preview Frontends. (line 6)
+* face <2>: Preview Frontends. (line 25)
+* face <3>: Echo Frontends. (line 6)
+* face <4>: Echo Frontends. (line 38)
+* face <5>: Candidates Search. (line 6)
+* face <6>: Candidates Search. (line 30)
+* face <7>: Filter Candidates. (line 6)
+* face <8>: Quick Access a Candidate.
+ (line 37)
+* filter: Filter Candidates. (line 6)
+* finish: Usage Basics. (line 20)
+* finish <1>: Commands. (line 30)
+* font: Tooltip Frontends. (line 227)
+* font <1>: Quick Access a Candidate.
+ (line 37)
+* frontend: Structure. (line 6)
+* frontend <1>: Structure. (line 10)
+* frontends: Frontends. (line 6)
+* grouped backends: Grouped Backends. (line 6)
+* icon: Tooltip Frontends. (line 153)
+* install: Installation. (line 6)
+* interface: Tooltip Frontends. (line 49)
+* interface <1>: Tooltip Frontends. (line 227)
+* interface <2>: Preview Frontends. (line 25)
+* interface <3>: Echo Frontends. (line 38)
+* interface <4>: Candidates Search. (line 30)
+* interface <5>: Quick Access a Candidate.
+ (line 37)
+* intro: Initial Setup. (line 6)
+* issue: Troubleshooting. (line 6)
+* issue tracker: Troubleshooting. (line 27)
+* kind: Tooltip Frontends. (line 153)
+* location: Commands. (line 42)
+* manual: Initial Setup. (line 8)
+* manual <1>: Usage Basics. (line 10)
+* margin: Tooltip Frontends. (line 142)
+* margin <1>: Tooltip Frontends. (line 162)
+* minor-mode: Initial Setup. (line 6)
+* module: Structure. (line 6)
+* module <1>: Structure. (line 10)
+* navigate: Usage Basics. (line 12)
+* next backend: Backends Usage Basics.
+ (line 14)
+* non-prefix matches: Terminology. (line 10)
+* package: Installation. (line 6)
+* package backends: Package Backends. (line 6)
+* pluggable: Structure. (line 6)
+* pop-up: Tooltip Frontends. (line 6)
+* prefix matches: Terminology. (line 10)
+* preview: Preview Frontends. (line 6)
+* quick start: Initial Setup. (line 6)
+* quick-access: Quick Access a Candidate.
+ (line 6)
+* quit: Usage Basics. (line 20)
+* quit <1>: Commands. (line 30)
+* search: Candidates Search. (line 6)
+* select: Usage Basics. (line 12)
+* select <1>: Commands. (line 11)
+* select <2>: Commands. (line 16)
+* snippet: Template Expansion. (line 6)
+* sort: Candidates Post-Processing.
+ (line 6)
+* stop: Usage Basics. (line 20)
+* stop <1>: Commands. (line 30)
+* TAB: Structure. (line 26)
+* Tab and Go: Structure. (line 26)
+* template: Template Expansion. (line 6)
+* third-party: Structure. (line 10)
+* third-party <1>: Troubleshooting. (line 18)
+* tooltip: Tooltip Frontends. (line 6)
+* troubleshoot: Troubleshooting. (line 6)
+* usage: Usage Basics. (line 6)
+
+
+\1f
+Tag Table:
+Node: Top\7f571
+Node: Overview\7f1998
+Node: Terminology\7f2406
+Ref: Terminology-Footnote-1\7f3393
+Node: Structure\7f3599
+Node: Getting Started\7f5095
+Node: Installation\7f5373
+Node: Initial Setup\7f5756
+Node: Usage Basics\7f6602
+Node: Commands\7f7365
+Ref: Commands-Footnote-1\7f9800
+Node: Customization\7f9967
+Node: Customization Interface\7f10439
+Node: Configuration File\7f10972
+Node: Frontends\7f15638
+Node: Tooltip Frontends\7f16607
+Ref: Tooltip Frontends-Footnote-1\7f27374
+Node: Preview Frontends\7f27611
+Ref: Preview Frontends-Footnote-1\7f28867
+Node: Echo Frontends\7f28994
+Node: Candidates Search\7f30527
+Node: Filter Candidates\7f31861
+Node: Quick Access a Candidate\7f32641
+Node: Backends\7f34259
+Node: Backends Usage Basics\7f35357
+Ref: Backends Usage Basics-Footnote-1\7f36572
+Node: Grouped Backends\7f36656
+Node: Package Backends\7f38285
+Node: Code Completion\7f39214
+Node: Text Completion\7f41583
+Node: File Name Completion\7f46017
+Node: Template Expansion\7f47565
+Node: Candidates Post-Processing\7f48284
+Node: Troubleshooting\7f49761
+Node: Index\7f51434
+Node: Key Index\7f51597
+Node: Variable Index\7f53096
+Node: Function Index\7f57219
+Node: Concept Index\7f61700
+\1f
+End Tag Table
+
+\1f
+Local Variables:
+coding: utf-8
+End:
--- /dev/null
+This is the file .../info/dir, which contains the
+topmost node of the Info hierarchy, called (dir)Top.
+The first time you invoke Info you start off looking at this node.
+\1f
+File: dir, Node: Top This is the top of the INFO tree
+
+ This (the Directory node) gives a menu of major topics.
+ Typing "q" exits, "H" lists all Info commands, "d" returns here,
+ "h" gives a primer for first-timers,
+ "mEmacs<Return>" visits the Emacs manual, etc.
+
+ In Emacs, you can click mouse button 2 on a menu item or cross reference
+ to select it.
+
+* Menu:
+
+Emacs misc features
+* Company: (company). A modular text completion framework.
projects / emacsconfig.git / commitdiff
