+++ /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-2022 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-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 '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" "20230703.2021" "Modular text completion framework"
- '((emacs "25.1"))
- :commit "3ec40b0a0ea751b6c48f24abd58c8304deb53014" :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-2022 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-2023 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)))))
- ;; posn-col-row return value relative to the left
- (when (eq (current-bidi-paragraph-direction) 'right-to-left)
- (let ((ww (window-body-width)))
- (setq col (- ww col))))
- (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.
--- /dev/null
+;;; company-abbrev.el --- company-mode completion backend for abbrev -*- lexical-binding: t -*-
+
+;; Copyright (C) 2009-2011, 2013-2015, 2021, 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 '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 (apply
+ #'nconc
+ (mapcar (lambda (table)
+ (delete "" (all-completions arg table)))
+ (abbrev--active-tables))))
+ (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 (do not edit) -*- lexical-binding: t -*-
+;; Generated by the `loaddefs-generate' function.
+
+;; This file is part of GNU Emacs.
+
+;;; Code:
+
+(add-to-list 'load-path (or (and load-file-name (directory-file-name (file-name-directory load-file-name))) (car load-path)))
+
+
+\f
+;;; 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'.
+
+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}
+
+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 the variable `company-mode'.
+
+The mode's hook is called both when the mode is enabled and when it is
+disabled.
+
+(fn &optional ARG)" t)
+(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)
+(autoload 'company-manual-begin "company" "\
+Start the completion interface.
+
+Unlike `company-complete-selection' or `company-complete', this command
+doesn't cause any immediate changes to the buffer text." t)
+(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)
+(register-definition-prefixes "company" '("company-"))
+
+\f
+;;; Generated autoloads from company-abbrev.el
+
+(autoload 'company-abbrev "company-abbrev" "\
+`company-mode' completion backend for abbrev.
+
+(fn COMMAND &optional ARG &rest IGNORED)" t)
+(register-definition-prefixes "company-abbrev" '("company-abbrev-insert"))
+
+\f
+;;; Generated autoloads from company-bbdb.el
+
+(autoload 'company-bbdb "company-bbdb" "\
+`company-mode' completion backend for BBDB.
+
+(fn COMMAND &optional ARG &rest IGNORE)" t)
+(register-definition-prefixes "company-bbdb" '("company-bbdb-"))
+
+\f
+;;; Generated autoloads from company-capf.el
+
+(register-definition-prefixes "company-capf" '("company-"))
+
+\f
+;;; Generated autoloads from company-clang.el
+
+(register-definition-prefixes "company-clang" '("company-clang"))
+
+\f
+;;; Generated autoloads from company-cmake.el
+
+(register-definition-prefixes "company-cmake" '("company-cmake"))
+
+\f
+;;; 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)
+(register-definition-prefixes "company-css" '("company-css-"))
+
+\f
+;;; Generated autoloads from company-dabbrev.el
+
+(autoload 'company-dabbrev "company-dabbrev" "\
+dabbrev-like `company-mode' completion backend.
+
+(fn COMMAND &optional ARG &rest IGNORED)" t)
+(register-definition-prefixes "company-dabbrev" '("company-dabbrev-"))
+
+\f
+;;; 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 REST)" t)
+(register-definition-prefixes "company-dabbrev-code" '("company-dabbrev-"))
+
+\f
+;;; Generated autoloads from company-etags.el
+
+(autoload 'company-etags "company-etags" "\
+`company-mode' completion backend for etags.
+
+(fn COMMAND &optional ARG &rest REST)" t)
+(register-definition-prefixes "company-etags" '("company-etags-"))
+
+\f
+;;; 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 REST)" t)
+(register-definition-prefixes "company-files" '("company-file"))
+
+\f
+;;; 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)
+(register-definition-prefixes "company-gtags" '("company-gtags-"))
+
+\f
+;;; Generated autoloads from company-ispell.el
+
+(autoload 'company-ispell "company-ispell" "\
+`company-mode' completion backend using Ispell.
+
+(fn COMMAND &optional ARG &rest IGNORED)" t)
+(register-definition-prefixes "company-ispell" '("company-"))
+
+\f
+;;; 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)
+(register-definition-prefixes "company-keywords" '("company-keywords-"))
+
+\f
+;;; 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)
+(register-definition-prefixes "company-nxml" '("company-nxml-"))
+
+\f
+;;; 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)
+(register-definition-prefixes "company-oddmuse" '("company-oddmuse-"))
+
+\f
+;;; 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)
+(register-definition-prefixes "company-semantic" '("company-semantic-"))
+
+\f
+;;; Generated autoloads from company-template.el
+
+(register-definition-prefixes "company-template" '("company-template-"))
+
+\f
+;;; Generated autoloads from company-tempo.el
+
+(autoload 'company-tempo "company-tempo" "\
+`company-mode' completion backend for tempo.
+
+(fn COMMAND &optional ARG &rest IGNORED)" t)
+(register-definition-prefixes "company-tempo" '("company-tempo-"))
+
+\f
+;;; 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)")
+(define-obsolete-function-alias 'company-tng-configure-default 'company-tng-mode "0.10.0" "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 global 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)
+(register-definition-prefixes "company-tng" '("company-tng-"))
+
+\f
+;;; 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)
+(register-definition-prefixes "company-yasnippet" '("company-yasnippet-"))
+\f
+;;; End of scraped data
+
+(provide 'company-autoloads)
+
+;; Local Variables:
+;; version-control: never
+;; no-byte-compile: t
+;; no-update-autoloads: t
+;; no-native-compile: t
+;; coding: utf-8-emacs-unix
+;; End:
+
+;;; company-autoloads.el ends here
--- /dev/null
+;;; company-bbdb.el --- company-mode completion backend for BBDB in message-mode -*- lexical-binding: t -*-
+
+;; Copyright (C) 2013-2016, 2020, 2023 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-dwim-mail "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 `(let ((arg ,arg))
+ (bbdb-search (bbdb-records) :all-names arg :mail arg))
+ t)))
+
+;;;###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-2024 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)
+
+(defgroup company-capf nil
+ "Completion backend as adapter for `completion-at-point-functions'."
+ :group 'company)
+
+(defcustom company-capf-disabled-functions '(tags-completion-at-point-function
+ ispell-completion-at-point)
+ "List of completion functions which should be ignored in this backend.
+
+By default it contains the functions that duplicate the built-in backends
+but don't support the corresponding configuration options and/or alter the
+intended priority of the default backends' configuration."
+ :type 'hook
+ :package-version '(company . "1.0.0"))
+
+;; 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' in response to `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.")
+
+(defvar-local company-capf--current-completion-metadata nil
+ "Metadata computed with the current prefix and data above.")
+
+(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--capf-data-real ()
+ (let ((data (run-hook-wrapped 'completion-at-point-functions
+ ;; Ignore disabled and 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)
+ ;; E.g. tags-completion-at-point-function subverts company-etags in the
+ ;; default value of company-backends, where the latter comes later.
+ (unless (memq fun company-capf-disabled-functions)
+ (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--save-current-data (data metadata)
+ (setq company-capf--current-completion-data data
+ company-capf--current-completion-metadata metadata)
+ (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
+ company-capf--current-completion-metadata nil))
+
+(defvar-local company-capf--sorted nil)
+(defvar-local company-capf--current-boundaries nil)
+
+(defun company-capf (command &optional arg &rest rest)
+ "`company-mode' backend using `completion-at-point-functions'."
+ (interactive (list 'interactive))
+ (pcase command
+ (`interactive (company-begin-backend 'company-capf))
+ (`prefix
+ (company-capf--prefix))
+ (`candidates
+ (company-capf--candidates arg (car rest)))
+ (`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 (or (plist-get (nthcdr 4 company-capf--current-completion-data)
+ :company-match)
+ #'company--match-from-capf-face)))
+ (funcall f arg)))
+ (`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))
+ (`adjust-boundaries
+ (company--capf-boundaries
+ company-capf--current-boundaries))
+ (`expand-common
+ (company-capf--expand-common arg (car rest)))
+ ))
+
+(defun 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)))
+ (suffix (buffer-substring-no-properties (point) (nth 2 res))))
+ (list prefix suffix length)))))
+
+(defun company-capf--expand-common (prefix suffix)
+ (let* ((data company-capf--current-completion-data)
+ (table (nth 3 data))
+ (pred (plist-get (nthcdr 4 data) :predicate)))
+ (company--capf-expand-common prefix suffix table pred
+ company-capf--current-completion-metadata)))
+
+(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
+ company-capf--current-completion-metadata))))
+ (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 suffix)
+ (let* ((current-capf (car company-capf--current-completion-data))
+ (res (company--capf-data))
+ (table (nth 3 res))
+ (pred (plist-get (nthcdr 4 res) :predicate))
+ (meta (and res
+ (completion-metadata
+ (buffer-substring (nth 1 res) (nth 2 res))
+ table pred))))
+ (when (and res
+ (or (not current-capf)
+ (equal current-capf (car res))))
+ (let* ((interrupt (plist-get (nthcdr 4 res) :company-use-while-no-input))
+ (all-result (company-capf--candidates-1 input suffix
+ table pred
+ meta
+ (and non-essential
+ (eq interrupt t))))
+ (sortfun (cdr (assq 'display-sort-function meta)))
+ (candidates (assoc-default :completions all-result)))
+ (setq company-capf--sorted (functionp sortfun))
+ (when candidates
+ (company-capf--save-current-data res meta)
+ (setq company-capf--current-boundaries
+ (company--capf-boundaries-markers
+ (assoc-default :boundaries all-result)
+ company-capf--current-boundaries)))
+ (when sortfun
+ (setq candidates (funcall sortfun candidates)))
+ candidates))))
+
+(defun company-capf--candidates-1 (prefix suffix table pred meta interrupt-on-input)
+ (if (not interrupt-on-input)
+ (company--capf-completions prefix suffix table pred meta)
+ (let (res)
+ (and (while-no-input
+ (setq res
+ (company--capf-completions prefix suffix table pred meta))
+ nil)
+ (throw 'interrupted 'new-input))
+ res)))
+
+(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
+ ;; Follow the example of `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))
+ 'exact
+ '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-parts "\\.\\|->\\|::" 2)
+ (company-grab-symbol-parts)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(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 -*- lexical-binding: t -*-
+
+;; Copyright (C) 2013-2015, 2017-2018, 2020, 2023 Free Software Foundation, Inc.
+
+;; Author: Chen Bin <chenbin DOT sh AT gmail>
+
+;; 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 cmake-ts-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 ((pattern (format company-cmake--completion-pattern
+ (regexp-quote prefix)
+ (if (zerop (length prefix)) "+" "*")))
+ (lines (split-string content "\n"))
+ 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-2024 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. This can also be a function that takes the current buffer as
+parameter and returns a list of major modes to search. 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)
+ (function :tag "Function to return similar major-modes" group)))
+
+(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)
+
+(defcustom company-dabbrev-code-completion-styles nil
+ "Non-nil to use the completion styles for fuzzy matching."
+ :type '(choice (const :tag "Prefix matching only" nil)
+ (const :tag "Matching according to `completion-styles'" t)
+ (list :tag "Custom list of styles" symbol))
+ :package-version '(company . "1.0.0"))
+
+(defvar-local company-dabbrev--boundaries nil)
+
+(defun company-dabbrev-code--make-regexp (prefix)
+ (let ((prefix-re
+ (cond
+ ((string-empty-p prefix)
+ "\\([a-zA-Z]\\|\\s_\\)")
+ ((not company-dabbrev-code-completion-styles)
+ (regexp-quote prefix))
+ (t
+ ;; Use the cache at least after 2 chars. We could also cache
+ ;; earlier, for users who set company-min-p-l to 1 or 0.
+ (let ((prefix (if (>= (length prefix) 2)
+ (substring prefix 0 2)
+ prefix)))
+ (mapconcat #'regexp-quote
+ (mapcar #'string prefix)
+ "\\(\\sw\\|\\s_\\)*"))))))
+ (concat "\\_<" prefix-re "\\(\\sw\\|\\s_\\)*\\_>")))
+
+;;;###autoload
+(defun company-dabbrev-code (command &optional arg &rest rest)
+ "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)
+ (cl-some #'derived-mode-p company-dabbrev-code-modes))
+ (or company-dabbrev-code-everywhere
+ (not (company-in-string-or-comment)))
+ (company-grab-symbol-parts)))
+ (candidates (company-dabbrev--candidates arg (car rest)))
+ (adjust-boundaries (and company-dabbrev-code-completion-styles
+ (company--capf-boundaries
+ company-dabbrev--boundaries)))
+ (expand-common (company-dabbrev-code--expand-common arg (car rest)))
+ (kind 'text)
+ (no-cache t)
+ (ignore-case company-dabbrev-code-ignore-case)
+ (match (when company-dabbrev-code-completion-styles
+ (company--match-from-capf-face arg)))
+ (duplicates t)))
+
+(defun company-dabbrev-code--expand-common (prefix suffix)
+ (when company-dabbrev-code-completion-styles
+ (let ((completion-styles (if (listp company-dabbrev-code-completion-styles)
+ company-dabbrev-code-completion-styles
+ completion-styles)))
+ (company--capf-expand-common prefix suffix
+ (company-dabbrev-code--table prefix)))))
+
+(defun company-dabbrev--candidates (prefix suffix)
+ (let* ((case-fold-search company-dabbrev-code-ignore-case))
+ (company-dabbrev-code--filter
+ prefix suffix
+ (company-dabbrev-code--table prefix))))
+
+(defun company-dabbrev-code--table (prefix)
+ (let ((regexp (company-dabbrev-code--make-regexp prefix)))
+ (company-cache-fetch
+ 'dabbrev-code-candidates
+ (lambda ()
+ (company-dabbrev--search
+ regexp
+ company-dabbrev-code-time-limit
+ (pcase company-dabbrev-code-other-buffers
+ (`t (list major-mode))
+ (`code company-dabbrev-code-modes)
+ ((pred functionp) (funcall company-dabbrev-code-other-buffers (current-buffer)))
+ (`all `all))
+ (not company-dabbrev-code-everywhere)))
+ :expire t
+ :check-tag
+ (cons regexp company-dabbrev-code-completion-styles))))
+
+(defun company-dabbrev-code--filter (prefix suffix table)
+ (let ((completion-ignore-case company-dabbrev-code-ignore-case)
+ (completion-styles (if (listp company-dabbrev-code-completion-styles)
+ company-dabbrev-code-completion-styles
+ completion-styles))
+ res)
+ (if (not company-dabbrev-code-completion-styles)
+ (all-completions prefix table)
+ (setq res (company--capf-completions
+ prefix suffix
+ table))
+ (setq company-dabbrev--boundaries
+ (company--capf-boundaries-markers
+ (assoc-default :boundaries res)
+ company-dabbrev--boundaries))
+ (assoc-default :completions res))))
+
+(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-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 '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. This can also be a function that takes
+the current buffer as parameter and returns a list of major modes to
+search. See also `company-dabbrev-time-limit'."
+ :type '(choice (const :tag "Off" nil)
+ (const :tag "Same major mode" t)
+ (const :tag "All" all)
+ (function :tag "Function to return similar major-modes" group)))
+
+(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."
+ :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)))))
+ (puthash match t 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)
+ (make-hash-table :test 'equal)
+ 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)
+ (cl-some #'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 ()
+ ;; Emacs can't do greedy backward-search.
+ (list
+ (company-grab-line (format "\\(?:^\\| \\)[^ ]*?\\(\\(?:%s\\)*\\)"
+ company-dabbrev-char-regexp)
+ 1)
+ (and (looking-at (format "\\(?:%s\\)*" company-dabbrev-char-regexp))
+ (match-string 0))))
+
+(defun company-dabbrev--filter (prefix candidates)
+ (let* ((completion-ignore-case company-dabbrev-ignore-case)
+ (filtered (all-completions prefix candidates))
+ (lp (length prefix))
+ (downcase (if (eq company-dabbrev-downcase 'case-replace)
+ case-replace
+ company-dabbrev-downcase)))
+ (when downcase
+ (let ((ptr filtered))
+ (while ptr
+ (setcar ptr (downcase (car ptr)))
+ (setq ptr (cdr ptr)))))
+ (if (and (eq company-dabbrev-ignore-case 'keep-prefix)
+ (not (= lp 0)))
+ (company-substitute-prefix prefix filtered)
+ filtered)))
+
+(defun company-dabbrev--fetch ()
+ (company-dabbrev--search (company-dabbrev--make-regexp)
+ company-dabbrev-time-limit
+ (pcase company-dabbrev-other-buffers
+ (`t (list major-mode))
+ ((pred functionp) (funcall company-dabbrev-other-buffers (current-buffer)))
+ (`all `all))))
+
+;;;###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
+ (company-dabbrev--filter
+ arg
+ ;; FIXME: Only cache the result of non-interrupted scans?
+ (company-cache-fetch 'dabbrev-candidates #'company-dabbrev--fetch
+ :expire t)))
+ (kind 'text)
+ (no-cache t)
+ (ignore-case (and company-dabbrev-ignore-case t))
+ (duplicates t)))
+
+(provide 'company-dabbrev)
+;;; company-dabbrev.el ends here
--- /dev/null
+;;; company-etags.el --- company-mode completion backend for etags -*- lexical-binding: t -*-
+
+;; Copyright (C) 2009-2011, 2013-2015, 2018-2019, 2023-2024 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"))
+
+(defcustom company-etags-completion-styles nil
+ "Non-nil to use the completion styles for fuzzy matching."
+ :type '(choice (const :tag "Prefix matching only" nil)
+ (const :tag "Matching according to `completion-styles'" t)
+ (list :tag "Custom list of styles" symbol))
+ :package-version '(company . "1.0.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)
+(defvar-local company-etags--boundaries nil)
+
+(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 suffix)
+ (let ((completion-ignore-case company-etags-ignore-case)
+ (completion-styles (if (listp company-etags-completion-styles)
+ company-etags-completion-styles
+ completion-styles))
+ (table (company-etags--table)))
+ (and table
+ (if company-etags-completion-styles
+ (let ((res (company--capf-completions prefix suffix table)))
+ (setq company-etags--boundaries
+ (company--capf-boundaries-markers
+ (assoc-default :boundaries res)
+ company-etags--boundaries))
+ (assoc-default :completions res))
+ (all-completions prefix table)))))
+
+(defun company-etags--table ()
+ (let ((tags-table-list (company-etags-buffer-table))
+ (tags-file-name tags-file-name))
+ (and (or tags-file-name tags-table-list)
+ (fboundp 'tags-completion-table)
+ (save-excursion
+ (visit-tags-table-buffer)
+ (tags-completion-table)))))
+
+(defun company-etags--expand-common (prefix suffix)
+ (when company-etags-completion-styles
+ (let ((completion-styles (if (listp company-etags-completion-styles)
+ company-etags-completion-styles
+ completion-styles)))
+ (company--capf-expand-common prefix suffix
+ (company-etags--table)))))
+
+;;;###autoload
+(defun company-etags (command &optional arg &rest rest)
+ "`company-mode' completion backend for etags."
+ (interactive (list 'interactive))
+ (cl-case command
+ (interactive (company-begin-backend 'company-etags))
+ (prefix (and (cl-some #'derived-mode-p company-etags-modes)
+ (or (eq t company-etags-everywhere)
+ (cl-some #'derived-mode-p company-etags-everywhere)
+ (not (company-in-string-or-comment)))
+ (company-etags-buffer-table)
+ (company-grab-symbol-parts)))
+ (candidates (company-etags--candidates arg (car rest)))
+ (adjust-boundaries (and company-etags-completion-styles
+ (company--capf-boundaries
+ company-etags--boundaries)))
+ (expand-common (company-etags--expand-common arg (car rest)))
+ (no-cache company-etags-completion-styles)
+ (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))))))))
+ (match (when company-etags-completion-styles
+ (company--match-from-capf-face arg)))
+ (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 -*- lexical-binding: t -*-
+
+;; Copyright (C) 2009-2011, 2013-2024 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"))
+
+(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 (string-empty-p 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* ((full-prefix (company-files--grab-existing-name))
+ (dir (file-name-directory full-prefix))
+ (file (file-name-nondirectory full-prefix))
+ (key (list file
+ (expand-file-name dir)
+ (nth 5 (file-attributes dir))))
+ (completion-ignore-case read-file-name-completion-ignore-case))
+ (unless (or (company-file--keys-match-p key (car company-files--completion-cache))
+ (not (company-files--connected-p dir)))
+ (let* ((candidates (company-files--directory-files dir file))
+ (directories (unless (file-remote-p dir)
+ (cl-remove-if-not (lambda (f)
+ (company-files--trailing-slash-p f))
+ candidates)))
+ (children (and directories
+ (cl-mapcan (lambda (d)
+ (company-files--directory-files d ""))
+ directories))))
+ (setq company-files--completion-cache
+ (cons key (append candidates children)))))
+ (all-completions file (cdr company-files--completion-cache))))
+
+(defun company-files--prefix ()
+ (let ((existing (company-files--grab-existing-name)))
+ (when existing
+ (list existing (company-grab-suffix "[^ '\"\t\n\r/]*/?")))))
+
+(defun company-file--keys-match-p (new old)
+ (and (equal (cdr old) (cdr new))
+ (string-prefix-p (car old) (car new))))
+
+(defun company-files--adjust-boundaries (_file prefix suffix)
+ (cons
+ (file-name-nondirectory prefix)
+ suffix))
+
+;;;###autoload
+(defun company-files (command &optional arg &rest rest)
+ "`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--prefix))
+ (candidates
+ (company-files--complete arg))
+ (adjust-boundaries
+ (company-files--adjust-boundaries arg (nth 0 rest) (nth 1 rest)))
+ (location (cons (dired-noselect
+ (file-name-directory (directory-file-name arg))) 1))
+ (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 -*- lexical-binding: t -*-
+
+;; Copyright (C) 2009-2011, 2013-2021, 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-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
+ ;; 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
+ (cl-some #'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 -*- lexical-binding: t -*-
+
+;; Copyright (C) 2009-2011, 2013-2016, 2018, 2021, 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 'cl-lib)
+(require 'ispell)
+
+(defgroup company-ispell nil
+ "Completion backend using Ispell."
+ :group 'company)
+
+(defun company--set-dictionary (symbol value)
+ (set-default-toplevel-value symbol value)
+ (company-cache-delete 'ispell-candidates))
+
+(defcustom company-ispell-dictionary nil
+ "Dictionary to use for `company-ispell'.
+
+If nil, use `ispell-complete-word-dict' or `ispell-alternate-dictionary'."
+ :type '(choice (const :tag "default (nil)" nil)
+ (file :tag "dictionary" t))
+ :set #'company--set-dictionary)
+
+(defvar company-ispell-available 'unknown)
+
+(defun company-ispell-available ()
+ (when (eq company-ispell-available 'unknown)
+ (condition-case err
+ (progn
+ (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)
+
+(defun company--ispell-dict ()
+ "Determine which dictionary to use."
+ (let ((dict (or company-ispell-dictionary
+ ispell-complete-word-dict
+ ispell-alternate-dictionary)))
+ (when dict
+ (expand-file-name dict))))
+
+;;;###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)
+ (list
+ (company-grab-word)
+ (company-grab-word-suffix))))
+ (candidates
+ (let* ((dict (company--ispell-dict))
+ (all-words
+ (company-cache-fetch 'ispell-candidates
+ (lambda () (ispell-lookup-words "" dict))
+ :check-tag dict))
+ (completion-ignore-case t))
+ (if (string-empty-p arg)
+ ;; Small optimization.
+ all-words
+ (company-substitute-prefix
+ arg
+ ;; Work around issue #284.
+ (all-completions arg all-words)))))
+ (kind 'text)
+ (no-cache t)
+ (sorted t)
+ (ignore-case t)))
+
+(provide 'company-ispell)
+;;; company-ispell.el ends here
--- /dev/null
+;;; company-keywords.el --- A company backend for programming language keywords -*- lexical-binding: t -*-
+
+;; Copyright (C) 2009-2011, 2013-2018, 2020-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 '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"
+ )
+ (tuareg-mode
+ ;; ocaml, from https://v2.ocaml.org/manual/lex.html#sss:keywords
+ "and" "as" "asr" "assert" "begin" "class"
+ "constraint" "do" "done" "downto" "else" "end"
+ "exception" "external" "false" "for" "fun" "function"
+ "functor" "if" "in" "include" "inherit" "initializer"
+ "land" "lazy" "let" "lor" "lsl" "lsr"
+ "lxor" "match" "method" "mod" "module" "mutable"
+ "new" "nonrec" "object" "of" "open" "or"
+ "private" "rec" "sig" "struct" "then" "to"
+ "true" "try" "type" "val" "virtual" "when"
+ "while" "with"
+ )
+ ;; aliases
+ (caml-mode . tuareg-mode)
+ (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)
+ (php-ts-mode . php-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 -*- lexical-binding: t -*-
+
+;; Copyright (C) 2009-2011, 2013-2015, 2017-2018, 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:
+;;
+;; 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))))
+ (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 -*- lexical-binding: t -*-
+
+;; Copyright (C) 2009-2011, 2013-2016, 2022, 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 '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
+;; -*- no-byte-compile: t; lexical-binding: nil -*-
+(define-package "company" "20241210.2019"
+ "Modular text completion framework."
+ '((emacs "26.1"))
+ :url "https://github.com/company-mode/company-mode"
+ :commit "7805174a9ffae3194d5bbde16febcf26761f0ad7"
+ :revdesc "7805174a9ffa"
+ :keywords '("abbrev" "convenience" "matching")
+ :maintainers '(("Dmitry Gutov" . "dmitryNOSPAMgutov.dev")))
--- /dev/null
+;;; company-semantic.el --- company-mode completion backend using Semantic -*- lexical-binding: t -*-
+
+;; Copyright (C) 2009-2011, 2013-2018, 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)
+
+(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-parts "\\.\\|->\\|::" 2)
+ (company-grab-symbol-parts)))
+
+;;;###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 (string-empty-p 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 (string-empty-p 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 -*- lexical-binding: t -*-
+
+;; Copyright (C) 2009-2010, 2013-2017, 2019, 2023-2024 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))
+ forward-sexp-function
+ 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 -*- lexical-binding: t -*-
+
+;; Copyright (C) 2009-2011, 2013-2016, 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 '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 -*- lexical-binding: t -*-
+
+;; Copyright (C) 2017-2024 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 (car (company--boundaries)))))
+ (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.10.0"
+ "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 -*- lexical-binding: t -*-
+
+;; Copyright (C) 2014-2015, 2020-2023 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))))
+ (nreverse 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))))
+
+(defun company-yasnippet--prefix ()
+ ;; We can avoid the prefix length manipulations after GH#426 is fixed.
+ (let* ((prefix (company-grab-symbol))
+ (tables (yas--get-snippet-tables))
+ (key-prefixes (company-yasnippet--key-prefixes))
+ key-prefix)
+ (while (and key-prefixes
+ (setq key-prefix (pop key-prefixes)))
+ (when (company-yasnippet--completions-for-prefix
+ prefix key-prefix tables)
+ ;; Stop iteration.
+ (setq key-prefixes nil)))
+ (if (equal key-prefix prefix)
+ prefix
+ (cons prefix (length key-prefix)))))
+
+;;;###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
+ (and (bound-and-true-p yas-minor-mode)
+ (company-yasnippet--prefix)))
+ (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-2024 Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+;; Maintainer: Dmitry Gutov <dmitryNOSPAMgutov.dev>
+;; URL: http://company-mode.github.io/
+;; Package-Version: 20241210.2019
+;; Package-Revision: 7805174a9ffa
+;; Keywords: abbrev, convenience, matching
+;; Package-Requires: ((emacs "26.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.10.0"))
+
+(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.10.0"))
+
+(define-obsolete-face-alias
+ 'company-scrollbar-fg
+ 'company-tooltip-scrollbar-thumb
+ "0.10.0")
+
+(defface company-tooltip-scrollbar-thumb
+ '((((background light))
+ :background "indian red")
+ (((background dark))
+ :background "gray33"))
+ "Face used for the tooltip scrollbar thumb (bar).")
+
+(define-obsolete-face-alias
+ 'company-scrollbar-bg
+ 'company-tooltip-scrollbar-track
+ "0.10.0")
+
+(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.10.0"))
+
+(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-scrollbar-width 0.4
+ "Width of the scrollbar thumb, in columns."
+ :type 'number
+ :package-version '(company . "1.0.0"))
+
+(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.10.0"))
+
+(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.
+
+To debug which backend is currently in use, try `M-x company-diag'.
+
+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. Returning
+nil from this command passes control to the next backend.
+
+The expected return value looks like (PREFIX SUFFIX &optional PREFIX-LEN).
+Where PREFIX is the text to be completed before point, SUFFIX - the
+remainder after point (when e.g. inside a symbol), and PREFIX-LEN, when
+non-nil, is the number to use in place of PREFIX's length when comparing
+against `company-minimum-prefix-length'. PREFIX-LEN can also be just t,
+and in the latter case the test automatically succeeds.
+
+The return value can also be just PREFIX, in which case SUFFIX is taken to
+be an empty string.
+
+`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 in response to `no-cache') and might
+also want to handle `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.
+
+`adjust-boundaries': The second argument is prefix and the third argument
+is suffix (previously returned by the `prefix' command). Return a
+cons (NEW-PREFIX . NEW-SUFFIX) where both parts correspond to the
+completion candidate.
+
+`expand-common': The first argument is prefix and the second argument is
+suffix. Return a cons (NEW-PREFIX . NEW-SUFFIX) that denote an edit in the
+current buffer which would be performed by `company-complete-common'. It
+should try to make the combined length of the prefix and suffix longer,
+while ensuring that the completions for the new inputs are the same.
+Othewise return the original inputs. If there are no matching completions,
+return the symbol `no-match'.
+
+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 is called with the return value of the previous one.
+The first one gets passed the list of candidates, already sorted and
+without duplicates (candidates with different annotations are considered to
+be distinct)."
+ :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.10.0")
+
+(define-obsolete-variable-alias
+ 'company-auto-commit
+ 'company-insertion-on-trigger
+ "0.10.0")
+
+(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.10.0"))
+
+(define-obsolete-variable-alias
+ 'company-auto-complete-chars
+ 'company-insertion-triggers
+ "0.10.0")
+
+(define-obsolete-variable-alias
+ 'company-auto-commit-chars
+ 'company-insertion-triggers
+ "0.10.0")
+
+(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.10.0"))
+
+(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-inhibit-inside-symbols nil
+ "Non-nil to inhibit idle completion when typing in the middle of a symbol.
+The symbol is in a generalized sense, indicated by the `prefix' backend
+action returning a non-empty SUFFIX element. When this variable is
+non-nil, completion inside symbol will onlytriggered by an explicit command
+invocation, such as \\[company-complete-common]."
+ :type 'boolean
+ :package-version '(company . "1.0.0"))
+
+(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
+ complete-symbol
+ completion-help-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 upgrading from an earlier version of company, might not be.
+ (when (fboundp #'company-keymap--unbind-quick-access)
+ (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 (fboundp #'company-keymap--bind-quick-access)
+ (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.10.0"))
+
+(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.10.0"))
+
+(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.10.0")
+
+(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.10.0")
+
+(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-or-cycle)
+ (define-key keymap (kbd "TAB") 'company-complete-common-or-cycle)
+ (define-key keymap [backtab] 'company-cycle-backward)
+ (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)))
+
+(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))
+ (setq-local company-emulation-alist `((t . ,company-my-keymap)))))
+
+(defun company-uninstall-map ()
+ (kill-local-variable 'company-emulation-alist))
+
+(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-row (if (>= emacs-major-version 29)
+ (with-no-warnings ;with 2 arguments, but accepts only 1
+ (posn-col-row posn t))
+ (posn-col-row posn)))
+ (col (car col-row))
+ ;; `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.
+ col-row))))
+ ;; posn-col-row return value relative to the left
+ (when (eq (current-bidi-paragraph-direction) 'right-to-left)
+ ;; `remap' as 3rd argument to window-body-width is E30+ only :-(
+ (let ((ww (window-body-width)))
+ (setq col (- ww col))))
+ (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-suffix (regexp &optional expression)
+ (when (looking-at regexp)
+ (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 ()
+ "Return buffer substring from the beginning of the symbol until point."
+ (buffer-substring (point) (save-excursion (skip-syntax-backward "w_")
+ (point))))
+
+(defun company-grab-symbol-suffix ()
+ "Return buffer substring from point until the end of the symbol."
+ (buffer-substring (point) (save-excursion (skip-syntax-forward "w_")
+ (point))))
+
+(defun company-grab-word ()
+ "Return buffer substring from the beginning of the word until point."
+ (buffer-substring (point) (save-excursion (skip-syntax-backward "w")
+ (point))))
+
+(defun company-grab-word-suffix ()
+ "Return buffer substring from the beginning of the word until point."
+ (buffer-substring (point) (save-excursion (skip-syntax-forward "w")
+ (point))))
+
+(defun company-grab-symbol-parts (&optional idle-begin-after-re max-len)
+ "Return a list (PREFIX SUFFIX &optional OVERRIDE).
+
+IDLE-BEGIN-AFTER-RE, if non-nil, must be a regexp.
+
+Where OVERRIDE might be t is IDLE-BEGIN-AFTER-RE is non-nil and the text
+before prefix matches it. PREFIX and SUFFIX are as returned by
+`company-grab-symbol' and `company-grab-symbol-suffix'.
+MAX-LEN is how far back to try to match the IDLE-BEGIN-AFTER-RE regexp."
+ (let ((prefix (company-grab-symbol))
+ suffix override)
+ (setq suffix (company-grab-symbol-suffix))
+ (when idle-begin-after-re
+ (save-excursion
+ (forward-char (- (length prefix)))
+ (when (looking-back idle-begin-after-re (if max-len
+ (- (point) max-len)
+ (line-beginning-position)))
+ (setq override t))))
+ (list prefix suffix override)))
+
+(define-obsolete-function-alias
+ 'company-grab-symbol-cons
+ 'company-grab-symbol-parts "1.0")
+
+(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-substitute-prefix (prefix strings)
+ (let ((len (length prefix)))
+ (mapcar
+ (lambda (s)
+ (if (eq t (compare-strings prefix 0 len s 0 len))
+ s
+ (concat prefix (substring s len))))
+ strings)))
+
+(defun company--match-from-capf-face (str)
+ "Compute `match' result from a CAPF's completion fontification."
+ (let* ((match-start nil) (pos -1)
+ (prop-value nil) (faces nil)
+ (has-face-p nil) chunks
+ (limit (length str)))
+ (while (< pos limit)
+ (setq pos
+ (if (< pos 0) 0 (next-property-change pos str limit)))
+ (setq prop-value (or (get-text-property pos 'face str)
+ (get-text-property pos 'font-lock-face str))
+ 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)))
+
+(defun company--capf-completions (prefix suffix table &optional pred meta)
+ (cl-letf* ((keep-suffix t)
+ (wrapper
+ (lambda (&rest args)
+ ;; If emacs22 style is used, suffix is ignored.
+ ;; That's the only popular completion style that does this.
+ (let ((res (apply #'completion-emacs22-all-completions args)))
+ (when res (setq keep-suffix nil))
+ res)))
+ (completion-styles-alist (copy-tree completion-styles-alist))
+ ((nth 2 (assoc 'emacs22 completion-styles-alist))
+ wrapper)
+ (all (completion-all-completions (concat prefix suffix)
+ table pred
+ (length prefix)
+ meta))
+ (last (last all))
+ (base-size (or (cdr last) 0))
+ ;; base-suffix-size is not available, but it's usually simple.
+ (bounds (completion-boundaries prefix table pred suffix)))
+ (when last
+ (setcdr last nil))
+ (unless keep-suffix
+ (setcdr bounds 0))
+ `((:completions . ,all)
+ (:boundaries . ,(cons (substring prefix base-size)
+ (substring suffix 0 (cdr bounds)))))))
+
+(defun company--capf-expand-common (prefix suffix table &optional pred metadata)
+ (let* ((res
+ (completion-try-completion (concat prefix suffix)
+ table pred (length prefix) metadata)))
+ (cond
+ ((null res)
+ 'no-match)
+ ((memq res '(t nil))
+ (cons prefix suffix))
+ (t
+ (cons
+ (substring (car res) 0 (cdr res))
+ (substring (car res) (cdr res)))))))
+
+;; We store boundaries as markers because when the `unhide' frontend action is
+;; called, the completions are still being fetched. So the capf boundaries info
+;; can't be relied to be fresh by other means.
+(defun company--capf-boundaries-markers (string-pair &optional markers)
+ "STRING-PAIR is (PREFIX . SUFFIX) and MARKERS is a pair to reuse."
+ (when (or (not markers)
+ (stringp (car markers)))
+ (setq markers (cons (make-marker)
+ (make-marker))))
+ (move-marker (car markers) (- (point) (length (car string-pair))))
+ (move-marker (cdr markers) (+ (point) (length (cdr string-pair))))
+ markers)
+
+(defun company--capf-boundaries (markers)
+ (let* ((beg (car markers))
+ (end (cdr markers))
+ res)
+ (when (> (point) end) (setq end (point)))
+ (setq res (cons (buffer-substring beg (point))
+ (buffer-substring (point) end)))
+ res))
+
+(defvar company--cache (make-hash-table :test #'equal :size 10))
+
+(cl-defun company-cache-fetch (key
+ fetcher
+ &key expire check-tag)
+ "Fetch the value assigned to KEY in the cache.
+When not found, or when found to be stale, calls FETCHER to compute the
+result. When EXPIRE is non-nil, the value will be deleted at the end of
+completion. CHECK-TAG, when present, is saved as well, and the entry will
+be recomputed when this value changes."
+ ;; We could make EXPIRE accept a time value as well.
+ (let ((res (gethash key company--cache 'none))
+ value)
+ (if (and (not (eq res 'none))
+ (or (not check-tag)
+ (equal check-tag (assoc-default :check-tag res))))
+ (assoc-default :value res)
+ (setq res (list (cons :value (setq value (funcall fetcher)))))
+ (if expire (push '(:expire . t) res))
+ (if check-tag (push `(:check-tag . ,check-tag) res))
+ (puthash key res company--cache)
+ value)))
+
+(defun company-cache-delete (key)
+ "Delete KEY from cache."
+ (remhash key company--cache))
+
+(defun company-cache-expire ()
+ "Delete all keys from the cache that are set to be expired."
+ (maphash (lambda (k v)
+ (when (assoc-default :expire v)
+ (remhash k company--cache)))
+ company--cache))
+
+(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))))
+
+(defvar-local company--multi-uncached-backends nil)
+(defvar-local company--multi-min-prefix nil)
+
+(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)))
+
+ (unless (eq command 'prefix)
+ (setq backends (cl-delete-if #'keywordp backends)))
+
+ (pcase command
+ (`candidates
+ (company--multi-backend-adapter-candidates backends
+ (or company--multi-min-prefix 0)
+ separate))
+ (`set-min-prefix (setq company--multi-min-prefix (car args)))
+ (`sorted separate)
+ (`duplicates (not separate))
+ ((and `no-cache
+ (pred (lambda (_)
+ (let* (found
+ (uncached company--multi-uncached-backends))
+ (dolist (backend backends)
+ (when
+ (and (member backend uncached)
+ (company--good-prefix-p
+ (let ((company-backend backend))
+ (company-call-backend 'prefix))
+ (or company--multi-min-prefix 0)))
+ (setq found t
+ company--multi-uncached-backends
+ (delete backend
+ company--multi-uncached-backends))))
+ found))))
+ t)
+ ((or `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)))))
+ (`prefix (company--multi-prefix backends))
+ (`adjust-boundaries
+ (let ((arg (car args)))
+ (when (> (length arg) 0)
+ (let* ((backend (or (get-text-property 0 'company-backend arg)
+ (car backends)))
+ (entity (company--force-sync backend '(prefix) backend))
+ (prefix (company--prefix-str entity))
+ (suffix (company--suffix-str entity)))
+ (setq args (list arg prefix suffix))
+ (or
+ (apply backend command args)
+ (cons prefix suffix))))))
+ (`expand-common
+ (apply #'company--multi-expand-common
+ backends
+ (or company--multi-min-prefix 0)
+ args))
+ (_
+ (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-prefix (backends)
+ (let* ((backends-after-with (cdr (member :with backends)))
+ prefix suffix len)
+
+ (dolist (backend backends)
+ (let* ((entity (and
+ (not (keywordp backend))
+ (company--force-sync backend '(prefix) backend)))
+ (new-len (company--prefix-len entity)))
+ (when (stringp (company--prefix-str entity))
+ (or (not backends-after-with)
+ (unless (memq backend backends-after-with)
+ (setq backends-after-with nil)))
+ (when (or
+ (null prefix)
+ (> (length (company--prefix-str entity))
+ (length prefix)))
+ (setq prefix (company--prefix-str entity)))
+ (when (> (length (company--suffix-str entity))
+ (length suffix))
+ (setq suffix (company--suffix-str entity)))
+ (when (or (eq t new-len)
+ (and new-len
+ (not (eq t len))
+ (or (not len) (> new-len len))))
+ (setq len new-len)))))
+ (when (and prefix
+ (not backends-after-with))
+ (list prefix suffix len))))
+
+(defun company--multi-expand-common (backends min-length prefix suffix)
+ (let ((tuples
+ (cl-loop for backend in backends
+ for bp = (let ((company-backend backend))
+ (company-call-backend 'prefix))
+ for expansion =
+ (when (company--good-prefix-p bp min-length)
+ (let ((inhibit-redisplay t)
+ (company-backend backend))
+ (company--expand-common (company--prefix-str bp)
+ (company--suffix-str bp))))
+ when (consp expansion)
+ collect
+ (list backend bp expansion)))
+ replacements)
+ (dolist (tuple tuples)
+ (cl-assert (string-suffix-p (company--prefix-str (nth 1 tuple))
+ prefix))
+ (cl-assert (string-prefix-p (company--suffix-str (nth 1 tuple))
+ suffix)))
+ ;; We try to find the smallest possible edit for each backend's expansion
+ ;; (minimum prefix and suffix, beyond which the area is unchanged).
+ (setq replacements
+ (mapcar
+ (lambda (tuple)
+ (let* ((backend-prefix (company--prefix-str (nth 1 tuple)))
+ (backend-suffix (company--suffix-str (nth 1 tuple)))
+ (bplen (length backend-prefix))
+ (bslen (length backend-suffix))
+ (beg 0)
+ (end 0)
+ (rep-suffix-len (length (cdr (nth 2 tuple))))
+ (max-beg (min bplen (length (car (nth 2 tuple)))))
+ (max-end (min bslen rep-suffix-len)))
+ (while (and (< beg max-beg)
+ (= (aref backend-prefix beg)
+ (aref (car (nth 2 tuple)) beg)))
+ (cl-incf beg))
+ (while (and (< end max-end)
+ (= (aref suffix (- bslen end 1))
+ (aref (cdr (nth 2 tuple))
+ (- rep-suffix-len end 1))))
+ (cl-incf end))
+ (list (- bplen beg)
+ (substring (car (nth 2 tuple)) beg)
+ (- bslen end)
+ (substring (cdr (nth 2 tuple)) 0 (- rep-suffix-len end))
+ (nth 0 tuple))))
+ tuples))
+ (setq replacements (sort replacements
+ (lambda (t1 t2) (< (- (length (nth 1 t1)) (nth 0 t1))
+ (- (length (nth 1 t2)) (nth 0 t2))))))
+ (or
+ (let ((choice (car replacements)))
+ ;; See if every replacement is similar enough to the one we selected:
+ ;; same suffix and beg/end and a prefix that starts with the proposed.
+ ;;
+ ;; More advanced checks seem possible, but with some backends reacting to
+ ;; buffer contents (not just string arguments) it seems we'd need to
+ ;; change the buffer contents first, then fetch `candidates' for each,
+ ;; and revert at the end. Might be error-prone.
+ (and
+ choice
+ (cl-every
+ (lambda (replacement)
+ (and
+ (= (car replacement) (car choice))
+ (= (nth 2 replacement) (nth 2 choice))
+ (equal (nth 3 replacement) (nth 3 choice))
+ (string-prefix-p (nth 1 choice) (nth 1 replacement))))
+ (cdr replacements))
+ ;; Proposed edit applied to the group's prefix and suffix.
+ (cons (concat (substring prefix 0 (- (length prefix) (nth 0 choice)))
+ (nth 1 choice))
+ (concat (nth 3 choice)
+ (substring suffix (nth 2 choice))))))
+ (and (null replacements) 'no-match)
+ ;; Didn't find anything suitable - return entity parts unchanged.
+ (cons prefix suffix))))
+
+(defun company--multi-backend-adapter-candidates (backends min-length separate)
+ (let* (backend-prefix suffix
+ (pairs (cl-loop for backend in backends
+ when (let ((bp (let ((company-backend backend))
+ (company-call-backend 'prefix))))
+ ;; One might override min-length, another not.
+ (if (company--good-prefix-p bp min-length)
+ (setq backend-prefix (company--prefix-str bp)
+ suffix (company--suffix-str bp))
+ (push backend company--multi-uncached-backends)
+ nil))
+ collect (cons (funcall backend 'candidates backend-prefix suffix)
+ (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-interactively finisher))))
+ (if (not (eq :async (car-safe val)))
+ (funcall this-finisher val)
+ (let ((fetcher (cdr val)))
+ (funcall fetcher this-finisher)))))))))))
+
+(defun company--prefix-str (entity)
+ (or (car-safe entity) entity))
+
+(defun company--prefix-len (entity)
+ (let ((cdr (cdr-safe entity))
+ override)
+ (cond
+ ((consp cdr)
+ (setq override (cadr cdr)))
+ ((or (numberp cdr) (eq t cdr))
+ (setq override cdr)))
+ (or override
+ (length
+ (if (stringp entity)
+ entity
+ (car entity))))))
+
+(defun company--suffix-str (entity)
+ (if (stringp (car-safe (cdr-safe entity)))
+ (car-safe (cdr-safe entity))
+ ""))
+
+;;; completion mechanism ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defvar-local company-prefix nil)
+
+(defvar-local company-suffix 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 was performed by the user.")
+
+(defvar-local company--manual-now nil
+ "Non-nil if manual completion is being performed now.")
+
+(defvar-local company--manual-prefix nil)
+
+(defvar-local company--point-max nil)
+
+(defvar-local company-point nil)
+
+(defvar-local company-valid-point nil)
+
+(defvar company-timer nil)
+(defvar company-tooltip-timer nil)
+
+(defun company-strip-prefix (str prefix)
+ (substring str (length prefix)))
+
+(defun company--insert-candidate (candidate prefix)
+ (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 prefix))
+ (unless (equal prefix candidate)
+ (delete-region (- (point) (length 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 company-prefix)
+ (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)
+ (concat company-prefix (substring candidate (length company-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)
+ (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)
+ company-valid-point company-point)
+ (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)))
+ (and (stringp common)
+ common))
+ (car company-candidates)))))
+
+(defun company-calculate-candidates (prefix ignore-case suffix)
+ (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
+ prefix suffix)))
+ (unwind-protect
+ (setq candidates (company--preprocess-candidates
+ (company--fetch-candidates prefix suffix)))
+ ;; 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 suffix ignore-case)
+ (and candidates
+ (not (cdr candidates))
+ (eq t (compare-strings (car candidates) nil nil
+ (concat prefix suffix) nil nil ignore-case))
+ (not (eq (company-call-backend 'kind (car candidates))
+ 'snippet))))
+
+(defun company--fetch-candidates (prefix suffix)
+ (let* ((non-essential (not company--manual-now))
+ (inhibit-redisplay t)
+ ;; At least we need "fresh" completions if the current command will
+ ;; rely on the result (e.g. insert common, or finish completion).
+ (c (if company--manual-now
+ (company-call-backend 'candidates prefix suffix)
+ (company-call-backend-raw 'candidates prefix suffix))))
+ (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))
+ (let ((res-was res))
+ (setq res 'exited)
+ (if (eq 'none res-was)
+ (throw 'interrupted 'new-input)
+ res-was))))))
+
+(defun company--sneaky-refresh (prefix suffix)
+ (when company-candidates
+ (let* ((company-prefix prefix)
+ (company-suffix suffix))
+ (and prefix
+ (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
+ ;; Transparency requires Emacs 28+.
+ :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 (string-empty-p 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 ()
+ "Start the completion interface.
+
+Unlike `company-complete-selection' or `company-complete', this command
+doesn't cause any immediate changes to the buffer text."
+ (interactive)
+ (company-assert-enabled)
+ (setq company--manual-action t)
+ (unwind-protect
+ (let ((company-minimum-prefix-length 0)
+ (company--manual-now t))
+ (or (and company-candidates
+ (= company-valid-point (point)))
+ (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-p (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-valid-point (point)))
+ (ding)
+ (message "Matching input is required")
+ company-candidates)
+ (t (company-cancel))))
+
+(defun company--good-prefix-p (prefix min-length)
+ (and (stringp (company--prefix-str prefix)) ;excludes 'stop
+ (or (eq (company--prefix-len prefix) t)
+ (>= (company--prefix-len prefix)
+ min-length))))
+
+(defun company--prefix-min-length ()
+ (if company--manual-prefix
+ (if company-abort-manual-when-too-short
+ ;; Must not be less than minimum or initial length.
+ (min company-minimum-prefix-length
+ (if-let* ((mp-len-override (cdr-safe company--manual-prefix)))
+ (if (numberp mp-len-override)
+ mp-len-override
+ (length (car-safe company--manual-prefix)))
+ (length company--manual-prefix)))
+ 0)
+ 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))
+ (new-suffix (company--suffix-str new-prefix))
+ (ignore-case (company-call-backend 'ignore-case))
+ (c (catch 'interrupted
+ (when (and (company--good-prefix-p new-prefix
+ (company--prefix-min-length))
+ (setq new-prefix (company--prefix-str new-prefix))
+ (= (- (point) (length new-prefix))
+ (- company-point (length company-prefix))))
+ (company-calculate-candidates new-prefix ignore-case new-suffix)))))
+ (cond
+ ((eq c 'new-input) ; Keep the old completions, but update the rest.
+ (setq company-prefix new-prefix
+ company-suffix new-suffix
+ company-point (point))
+ t)
+ ((and company-abort-on-unique-match
+ (company--unique-match-p c new-prefix new-suffix 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-suffix new-suffix
+ company-point (point))
+ (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 ((min-prefix (company--prefix-min-length))
+ entity c)
+ (cl-dolist (backend (if company-backend
+ ;; prefer manual override
+ (list company-backend)
+ company-backends))
+ (setq entity
+ (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 entity
+ (when (and (company--good-prefix-p entity min-prefix)
+ (or (not company-inhibit-inside-symbols)
+ company--manual-action
+ (zerop (length (company--suffix-str entity)))))
+ (let ((ignore-case (company-call-backend 'ignore-case)))
+ ;; Keep this undocumented, esp. while only 1 backend needs it.
+ (company-call-backend 'set-min-prefix min-prefix)
+ (setq company-prefix (company--prefix-str entity)
+ company-suffix (company--suffix-str entity)
+ company-point (point)
+ company-backend backend
+ c (catch 'interrupted
+ (company-calculate-candidates company-prefix ignore-case
+ company-suffix)))
+ (cond
+ ((or (null c) (eq c 'new-input))
+ (when company--manual-action
+ (message "No completion found")))
+ ((and company-abort-on-unique-match
+ (company--unique-match-p c company-prefix company-suffix 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))
+ (t ;; We got completions!
+ (when company--manual-action
+ (setq company--manual-prefix entity))
+ (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-cache-expire)
+ (company--begin-new)))
+ (if (not company-candidates)
+ (setq company-backend nil)
+ (setq 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--multi-uncached-backends nil
+ company--multi-min-prefix 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)
+ (pcase-let ((`(,prefix . ,suffix) (company--boundaries result)))
+ (company--insert-candidate result (or prefix company-prefix))
+ (and (> (length suffix) 0)
+ (delete-region (point) (+ (point) (length suffix))))
+ (let ((tick (buffer-chars-modified-tick))
+ (backend company-backend))
+ ;; Call backend's `post-completion' and run other hooks, then exit.
+ (company-cancel result)
+ ;; Try restarting completion, to see if we moved into a new field.
+ ;; Most commonly, this would be after entering a dir in file completion.
+ (when (= (buffer-chars-modified-tick) tick)
+ (let (company-require-match)
+ (setq company-backend backend
+ company--manual-prefix 0)
+ (company--begin-new))
+ (unless (and company-candidates
+ (equal (company--boundaries) '("" . "")))
+ (company-cancel))))))
+
+(defsubst company-keep (command)
+ (and (symbolp command) (get command 'company-keep)))
+
+(defun company--proper-suffix-p (candidate)
+ (and
+ (>= (length candidate)
+ (+ (length company-prefix)
+ (length company-suffix)))
+ (string-suffix-p company-suffix candidate
+ (company-call-backend 'ignore-case))))
+
+(defun company--boundaries (&optional candidate)
+ (unless candidate
+ (setq candidate (nth (or company-selection 0) company-candidates)))
+ (or
+ (company-call-backend 'adjust-boundaries
+ candidate
+ company-prefix company-suffix)
+ (and
+ ;; Default to replacing the suffix only if the completion ends with it.
+ (company--proper-suffix-p candidate)
+ (cons company-prefix company-suffix))
+ (cons company-prefix "")))
+
+(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 (and (equal (point) company-point)
+ (equal (point-max) company--point-max))
+ (let (company-idle-delay) ; Against misbehavior while debugging.
+ (company--perform)))
+ (if company-candidates
+ (progn
+ (company-call-frontends 'post-command)
+ (when company-auto-update-doc
+ (condition-case nil
+ (unless (company--electric-command-p)
+ (company-show-doc-buffer))
+ (user-error nil)
+ (quit nil))))
+ (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-empty-p re))
+ company-search-filtering
+ (lambda (candidate) (string-match-p re candidate))))
+ (cc (company-calculate-candidates company-prefix
+ (company-call-backend 'ignore-case)
+ company-suffix)))
+ (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-empty-p 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-empty-p 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.
+
+Restart completion if a new field is entered. A field is indicated by
+`adjust-boundaries' as implemented in the backend. If both adjusted prefix
+and adjusted suffix are empty strings, that means a new field."
+ (interactive)
+ (when (and (company-manual-begin) company-selection)
+ (let ((result (nth company-selection company-candidates)))
+ (company-finish result))))
+
+(defun company--expand-common (prefix suffix)
+ (let ((expansion (company-call-backend 'expand-common prefix suffix)))
+ (unless expansion
+ ;; Backend doesn't implement this, try emulating.
+ (let* (;; XXX: We could also filter/group `company-candidates'.
+ (candidates (company-call-backend 'candidates prefix suffix))
+ ;; Assuming that boundaries don't vary between completions here.
+ ;; If they do, the backend should have a custom `expand-common'.
+ (boundaries-prefix (car (company--boundaries)))
+ (completion-ignore-case (company-call-backend 'ignore-case))
+ (trycmp (try-completion boundaries-prefix candidates))
+ (common (if (eq trycmp t) (car candidates) trycmp))
+ (max-len (when (and common
+ (cl-every (lambda (s) (string-suffix-p
+ suffix s
+ completion-ignore-case))
+ candidates))
+ (-
+ (apply #'min
+ (mapcar #'length candidates))
+ (length suffix))))
+ (common (if max-len
+ (substring common 0
+ (min max-len (length common)))
+ common)))
+ (setq expansion
+ (cond
+ ((null candidates)
+ 'no-match)
+ ((string-prefix-p boundaries-prefix common t)
+ (cons (concat
+ (substring prefix
+ 0
+ (- (length prefix)
+ (length boundaries-prefix)))
+ common)
+ suffix))
+ (t (cons prefix suffix))))))
+ expansion))
+
+(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)
+ (let ((expansion (company--expand-common company-prefix
+ company-suffix)))
+ (when (eq expansion 'no-match)
+ (user-error "No matches for the current input"))
+ (unless (equal (car expansion) company-prefix)
+ (if (eq (company-call-backend 'ignore-case) 'keep-prefix)
+ (insert (substring (car expansion) (length company-prefix)))
+ (delete-region (- (point) (length company-prefix)) (point))
+ (insert (car expansion))))
+ (unless (equal (cdr expansion) company-suffix)
+ (save-excursion
+ (delete-region (point) (+ (point) (length company-suffix)))
+ (insert (cdr expansion))))))))
+
+(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-cycle-backward (&optional arg)
+ (interactive "p")
+ (let ((company-selection-wrap-around t))
+ (company-select-previous arg)))
+
+(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)))
+ this-command))
+
+(define-obsolete-function-alias
+ 'company-complete-number
+ 'company-complete-tooltip-row
+ "0.10.0")
+
+(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 ?\ )))
+
+;; XXX: This is really a hack, but one that we could really get rid of only by
+;; moving to the one-overlay-per-line scheme.
+(defmacro company--with-face-remappings (&rest body)
+ `(let ((fra-local (and (local-variable-p 'face-remapping-alist)
+ face-remapping-alist))
+ (bdt-local (and (local-variable-p 'buffer-display-table)
+ buffer-display-table))
+ (bufs (list (get-buffer-create " *string-pixel-width*")
+ (get-buffer-create " *company-sps*"))))
+ (unwind-protect
+ (progn
+ (dolist (buf bufs)
+ (with-current-buffer buf
+ (when (bound-and-true-p display-line-numbers)
+ ;; Workaround for debbugs#67248.
+ (setq-local display-line-numbers nil))
+ (when fra-local
+ (setq-local face-remapping-alist fra-local))
+ (when bdt-local
+ (setq-local buffer-display-table bdt-local))))
+ ,@body)
+ (dolist (buf bufs)
+ (and (buffer-live-p buf)
+ (with-current-buffer buf
+ (kill-local-variable 'face-remapping-alist)
+ (kill-local-variable 'buffer-display-table)))))))
+
+(declare-function buffer-text-pixel-size "xdisp.c")
+
+(defun company--string-pixel-width (string)
+ (if (zerop (length string))
+ 0
+ ;; Keeping a work buffer around is more efficient than creating a
+ ;; new temporary buffer.
+ (with-current-buffer (get-buffer-create " *string-pixel-width*")
+ ;; `display-line-numbers-mode' is enabled in internal buffers
+ ;; that breaks width calculation, so need to disable (bug#59311)
+ (when (bound-and-true-p display-line-numbers-mode)
+ (with-no-warnings ;; Emacs 25
+ (display-line-numbers-mode -1)))
+ (delete-region (point-min) (point-max))
+ (insert string)
+ (if (fboundp #'buffer-text-pixel-size)
+ ;; Emacs 29.1+
+ (car (buffer-text-pixel-size nil nil t))
+ (let ((wb (window-buffer))
+ (hscroll (window-hscroll))
+ (dedicated (window-dedicated-p))
+ buffer-list-update-hook)
+ (unwind-protect
+ (progn
+ (when dedicated
+ (set-window-dedicated-p nil nil))
+ (set-window-buffer nil (current-buffer))
+ (car
+ (window-text-pixel-size nil nil nil 55555)))
+ (set-window-buffer nil wb)
+ (set-window-hscroll nil hscroll)
+ (when dedicated
+ (set-window-dedicated-p nil dedicated))))))))
+
+(defun company--string-width (str)
+ (if (display-graphic-p)
+ (ceiling (/ (company--string-pixel-width str)
+ (float (default-font-width))))
+ (string-width str)))
+
+;; TODO: Add more tests!
+(defun company-safe-pixel-substring (str from &optional to)
+ (let ((from-chars 0)
+ (to-chars 0)
+ spw-from spw-to
+ spw-to-prev
+ front back
+ (orig-buf (window-buffer))
+ (bis buffer-invisibility-spec)
+ (inhibit-read-only t)
+ (inhibit-modification-hooks t)
+ (dedicated (window-dedicated-p))
+ (hscroll (window-hscroll))
+ window-configuration-change-hook
+ buffer-list-update-hook)
+ (with-current-buffer (get-buffer-create " *company-sps*")
+ (unwind-protect
+ (progn
+ (delete-region (point-min) (point-max))
+ (insert str)
+ (setq-local buffer-invisibility-spec bis)
+ (when dedicated (set-window-dedicated-p nil nil))
+ (set-window-buffer nil (current-buffer) t)
+
+ (vertical-motion (cons (/ from (frame-char-width)) 0))
+ (setq from-chars (point))
+ (setq spw-from
+ (if (bobp) 0
+ (car (window-text-pixel-size nil (point-min) (point) 55555))))
+ (while (and (< spw-from from)
+ (not (eolp)))
+ (forward-char 1)
+ (setq spw-from
+ (car (window-text-pixel-size nil (point-min) (point) 55555)))
+ (setq from-chars (point)))
+
+ (if (= from-chars (point-max))
+ (if (and to (> to from))
+ (propertize " " 'display `(space . (:width (,(- to from)))))
+ "")
+ (if (not to)
+ (setq to-chars (point-max))
+ (vertical-motion (cons (/ to (frame-char-width)) 0))
+ (setq to-chars (point))
+ (setq spw-to
+ (if (bobp) 0
+ (car (window-text-pixel-size nil (point-min) (point) 55555))))
+ (while (and (< spw-to to)
+ (not (eolp)))
+ (setq spw-to-prev spw-to)
+ (forward-char 1)
+ (setq spw-to
+ (car (window-text-pixel-size nil (point-min) (point) 55555)))
+ (when (<= spw-to to)
+ (setq to-chars (point)))))
+
+ (unless spw-to-prev (setq spw-to-prev spw-to))
+
+ (when (> spw-from from)
+ (setq front (propertize " " 'display
+ `(space . (:width (,(- spw-from from)))))))
+ (when (and to (/= spw-to to))
+ (setq back (propertize
+ " " 'display
+ `(space . (:width (,(- to
+ (if (< spw-to to)
+ spw-to
+ spw-to-prev))))))))
+ (concat front (buffer-substring from-chars to-chars) back)))
+ (set-window-buffer nil orig-buf t)
+ (set-window-hscroll nil hscroll)
+ (when dedicated
+ (set-window-dedicated-p nil dedicated))))))
+
+(defun company-safe-substring (str from &optional to)
+ (let ((ll (length str)))
+ (if (> from ll)
+ ""
+ (if to
+ (concat (substring str from (min to ll))
+ (company-space-string (max 0 (- to ll))))
+ (substring str from)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(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-command-p ()
+ (memq this-command company--electric-commands))
+
+(defun company--electric-restore-window-configuration ()
+ "Restore window configuration (after electric commands)."
+ (when (and company--electric-saved-window-configuration
+ (not (company--electric-command-p)))
+ (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-candidates
+ (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)
+ (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)))
+ (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)
+ (company--suffix-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 (stringp 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 &optional suffix)
+ (let ((matches (company-call-backend 'match value)))
+ (when (integerp matches)
+ (setq matches `((0 . ,matches))))
+ (or matches
+ (and company-common `((0 . ,(length company-common))
+ ,@(list
+ (cons
+ (- (length value)
+ (length (or suffix
+ (cdr (company--boundaries value)))))
+ (length value)))))
+ nil)))
+
+(defun company-fill-propertize (value annotation width selected left right)
+ (let* ((margin (length left))
+ (common (company--common-or-matches value))
+ (_ (setq value
+ (company--clean-string
+ (company-reformat (company--pre-render value)))
+ annotation (and annotation
+ (company--clean-string
+ (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-empty-p 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)
+ (let* ((add-pixels 0)
+ (add-length 0)
+ (new-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"
+ (if (equal match "\n")
+ (propertize "\\\\n" 'face 'font-lock-escape-face)
+ "?")
+ )
+ ((match-beginning 2)
+ ;; Zero-width non-breakable space.
+ "")
+ (t
+ ;; FIXME: Maybe move that counting later to a non-replacement loop.
+ (let ((msw (company--string-width match)))
+ (cl-incf add-pixels
+ (- (* (default-font-width)
+ msw)
+ (company--string-pixel-width match)))
+ (cl-incf add-length (- msw (length match)))
+ match
+ ))
+ ))
+ str)))
+ (if (>= 0 add-length)
+ new-str
+ (concat new-str
+ (propertize
+ (make-string add-length ?\ufeff)
+ 'display `(space . (:width (,add-pixels))))))))
+
+;;; 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)
+ (if (not new)
+ ;; Avoid modifying OLD, e.g. to avoid "blinking" with half-spaces for
+ ;; double-width (or usually fractional) characters.
+ old
+ (concat (company-safe-pixel-substring old 0 offset)
+ new
+ (company-safe-pixel-substring old (+ offset (company--string-pixel-width 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.10.0")
+
+(defsubst company--window-height ()
+ (if (fboundp 'window-screen-lines)
+ (floor (window-screen-lines))
+ (window-body-height)))
+
+(defun company--window-width (&optional pixelwise)
+ (let ((ww (window-body-width nil pixelwise)))
+ ;; Account for the line continuation column.
+ (when (zerop (cadr (window-fringes)))
+ (cl-decf ww (if pixelwise (company--string-pixel-width ">") 1)))
+ (when (bound-and-true-p display-line-numbers)
+ (cl-decf ww
+ (if pixelwise
+ (line-number-display-width t)
+ (+ 2 (line-number-display-width)))))
+ ;; whitespace-mode with newline-mark
+ (when (and buffer-display-table
+ (aref buffer-display-table ?\n))
+ (cl-decf ww
+ (if pixelwise
+ (company--string-pixel-width "\n")
+ (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* ((px-width (company--string-pixel-width (car lines)))
+ ;; The (display (space :width (..))) spec is only applied to the
+ ;; visible part of the buffer (past hscroll), so subtracting
+ ;; window-scroll here is a good idea. But then we also need to slice
+ ;; the "old" strings so the hidden contents don't get shown.
+ ;; XXX: `auto-hscroll-mode' set to `current-line' is not supported.
+ (px-col (* (- column (window-hscroll)) (default-font-width)))
+ (remaining-px (- (company--window-width t) px-col))
+ (hscroll-space (when (> (window-hscroll) 0)
+ (company-space-string (window-hscroll))))
+ new)
+ (when (> px-width remaining-px)
+ (cl-decf px-col (- px-width remaining-px)))
+ (when hscroll-space
+ (setq old (mapcar (lambda (s) (company-safe-substring s (window-hscroll)))
+ old)))
+ (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) px-col)
+ new))
+ ;; Append whole new lines.
+ (while lines
+ (push (concat (company-safe-pixel-substring "" 0 px-col) (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 hscroll-space 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
+ right-margin
+ 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)
+ right-margin (company--right-margin limit len)
+ 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))))
+ (when 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 (+ (company--string-width value)
+ (if annotation
+ (+ (company--string-width annotation)
+ company-tooltip-annotation-padding)
+ 0))
+ 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 right-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 (company--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)
+ (let* ((scroll-width (ceiling (* (default-font-width)
+ company-tooltip-scrollbar-width))))
+ (propertize " "
+ 'display `(space . (:width (,scroll-width)))
+ 'face
+ (if (and (>= i (car bounds)) (<= i (cdr bounds)))
+ 'company-tooltip-scrollbar-thumb
+ 'company-tooltip-scrollbar-track))))
+
+(defun company--right-margin (limit length)
+ (if (or (not (eq company-tooltip-offset-display 'scrollbar))
+ (not (display-graphic-p))
+ (= company-tooltip-scrollbar-width 1)
+ (<= length limit))
+ (company-space-string company-tooltip-margin)
+ (let* ((scroll-width (ceiling (* (default-font-width)
+ company-tooltip-scrollbar-width)))
+ (rest-width (- (* (default-font-width) company-tooltip-margin)
+ scroll-width)))
+ (propertize
+ (company-space-string company-tooltip-margin)
+ 'display `(space . (:width (,rest-width)))))))
+
+(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))
+ ;; HACK: Very specific to the log-edit buffer. Could alternatively
+ ;; look up the `display-line-numbers-disable' property, but with
+ ;; larger consequences.
+ (when (and (not nl) (> height 0))
+ (while (eq (get-char-property (point) 'face)
+ 'log-edit-headers-separator)
+ (vertical-motion 1)))
+ (setq beg (point)
+ end (save-excursion
+ (vertical-motion (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 (company--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--with-face-remappings
+ (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
+ (company--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 (prefix)
+ (list
+ (- (point) (length prefix))
+ (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 (and ov (> (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
+ (let ((prefix (car (company--boundaries)))
+ guard)
+ (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 (setq guard (company-pseudo-tooltip-guard prefix))
+ (overlay-get ov 'company-guard)))))
+ ;; Redraw needed.
+ (company-pseudo-tooltip-show-at-point (point)
+ (length prefix))
+ (overlay-put company-pseudo-tooltip-overlay
+ 'company-guard (or guard
+ (company-pseudo-tooltip-guard prefix)))))
+ (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--with-face-remappings
+ (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 &optional boundaries)
+ (company-preview-hide)
+
+ (let* ((boundaries (or boundaries (company--boundaries completion)))
+ (prefix (car boundaries))
+ (suffix (cdr boundaries))
+ (company-common (and company-common
+ (string-prefix-p prefix company-common)
+ company-common))
+ (common (company--common-or-matches completion suffix)))
+ (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 prefix completion
+ (eq (company-call-backend 'ignore-case)
+ 'keep-prefix))
+ (company-strip-prefix completion prefix)
+ completion))
+
+ (when (string-prefix-p "\n" completion)
+ (setq completion (concat (propertize " " 'face 'company-preview) "\n"
+ (substring completion 1))))
+
+ (and (equal pos (point))
+ (not (string-empty-p 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))))
+ (end pos))
+ ;; 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)))
+
+ (when (string-suffix-p suffix completion)
+ (cl-incf end (length suffix)))
+
+ (setq company-preview-overlay (make-overlay beg end))
+
+ (let ((ov company-preview-overlay))
+ (overlay-put ov (if (> end beg) '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-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 ()
+ (let* ((boundaries (and company-candidates (company--boundaries)))
+ (prefix (car boundaries))
+ (suffix (cdr boundaries))
+ (ignore-case (company-call-backend 'ignore-case))
+ (candidate (car company-candidates)))
+ (and (not (cdr company-candidates))
+ company-common
+ (not (eq t (compare-strings prefix nil nil
+ candidate nil nil
+ t)))
+ (string-suffix-p suffix candidate ignore-case)
+ (or (eq ignore-case 'keep-prefix)
+ (string-prefix-p 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 (company--string-width (or company-common ""))))
+ (when (< numbered qa-keys-len)
+ (let ((qa-hint
+ (format "%s: " (funcall
+ company-quick-access-hint-function
+ numbered))))
+ (setq beg (company--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) company-prefix)
+ 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 (company--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 (string-empty-p 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.8 from
+company.texi.
+
+This user manual is for Company version 1.0.3-snapshot
+(7 December 2024).
+
+Copyright © 2021-2024 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 1.0.3-snapshot
+(7 December 2024).
+
+Copyright © 2021-2024 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 intelligently 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 of a candidate (“non-prefix matches”).
+Which matching method is used, depends on the current _backend_ (*note
+Structure::). ‘company-capf’ is an example of a backend that supports a
+number of particular non-prefix matching algorithms which are
+configurable through the user option ‘completion-styles’, which see.
+For illustrations on how Company visualizes the matches, *note
+Frontends::.
+
+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.
+
+\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 displayed 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 for particular needs, 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 the 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 the 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 the user types 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 expand the “common part” of all completions. Exactly
+ what that means, can vary by backend. In the simplest case it’s
+ the longest string that all completion start with, but when a
+ backend returns _non-prefix matches_, it can implement the same
+ kind of expansion logic for the input string.
+
+ • 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’).
+ Restart completion if a new field is entered.
+
+‘TAB’
+‘<tab>’
+ Insert the _common part_ of all completion candidates or — if no
+ _common part_ is present — select the next candidate
+ (‘company-complete-common-or-cycle’). In the latter case,
+ wraparound is implicitly enabled (*note
+ company-selection-wrap-around::).
+
+‘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)
+ (define-key company-active-map (kbd "C-M-/") #'company-complete-common))
+
+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 its overall behavior.
+
+ -- 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-inhibit-inside-symbols
+ You can set this option to ‘t’ to disable the auto-start behavior
+ when in the middle of a symbol.
+
+ -- 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 the user
+ invokes completion manually 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
+ 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
+ vertically 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 the 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. The 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 the
+user’s 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 suggests how users 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 the 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.) Firing such
+an engine with a command causes the production of material for Company
+to work on. Typically, that means showing that output to the 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 the full description of what a backend is
+and how to implement one. So we suggest reading the output of ‘C-h v
+company-backends’ for more details. 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 first one that reports itself applicable
+in the current context (usually based on the value of ‘major-mode’ and
+the text around point), is used for completion.
+
+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), if the current
+applicable backend returned no completions, the ones after it in the
+list are not invoked. If you do want to query the next one, use the
+command ‘company-other-backend’: either by calling it with ‘M-x’ or by
+binding the command to the keys of your choice, like:
+
+ (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.
+
+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
+ The current trend in the Emacs’s world is to delegate completion
+ logic to the hook ‘completion-at-point-functions’ (CAPF) assigned
+ to by the major or minor modes. It supports a common subset of
+ features which is well-supported across different completion UIs.
+ [Among other things, this is what the most popular Emacs clients
+ for the language server protocol (LSP) also rely on.]
+
+ For that reason, it is probably the most 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::.
+
+ -- User Option: company-capf-disabled-functions
+ List of completion functions which should be ignored by this
+ backend. By default it contains the functions that duplicate the
+ built-in backends but don’t support the corresponding configuration
+ options and/or alter the intended priority of the default backends’
+ configuration.
+
+ -- 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, it reuses code from the other
+ backend, ‘company-dabbrev’ (*note Text Completion::).
+
+ -- User Option: company-dabbrev-code-modes
+ This variable lists the modes that use ‘company-dabbrev-code’. The
+ backend will only perform completion in these major modes and their
+ derivatives. Otherwise it passes control to other backends. Value
+ t means complete in all modes.
+
+ -- User Option: company-dabbrev-code-other-buffers
+ This variable determined whether ‘company-dabbrev-code’ will search
+ other buffers for completions. If ‘all’, it will search all other
+ buffers except the ignored ones (names starting with a space). If
+ ‘t’, it will search buffers with the same major mode. If ‘code’,
+ it will search buffers with major modes in
+ ‘company-dabbrev-code-modes’ or derived from one of them. This can
+ also be a function that takes the current buffer as parameter and
+ returns a list of major modes to search.
+
+ -- User Option: company-dabbrev-code-everywhere
+ This is a boolean option which determines whether this backend will
+ perform completion in strings and comments as well. The default
+ value ‘nil’ means it will pass on control to other backends in such
+ contexts.
+
+ -- User Option: company-dabbrev-code-completion-styles
+ Non-nil to use ‘completion-styles’ for matching completions in this
+ backend. It can be set to ‘t’ to use the global value of
+ ‘completion-styles’, or to a list of symbols to use specific
+ completion styles with this backend. The default value is nil.
+
+ -- 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_. It uses the command-line
+ interface of the program ‘clang’, but without any advanced caching
+ across calls, or automatic detection of the project structure.
+ Which makes it more suitable for small to medium projects,
+ especially if you’re willing to customize
+ ‘company-clang-arguments’. Otherwise we recommend using one of the
+ LSP clients available for Emacs, together with the backend
+ ‘company-capf’.
+
+ -- User Option: company-clang-arguments
+ This option can be set to a list of strings which will be passed to
+ _clang_ during completion. These can include elements like ‘"-I"
+ "path/to/includes/dir"’ to indicate the header directories and
+ other compiler options.
+
+ -- 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 the user may consider enabling _company-capf_ backend
+ instead.
+
+ -- Function: company-etags
+ This backend uses tags tables as produced by the built-in Emacs
+ program _etags_, *note (emacs)Tags Tables::.
+
+ -- User Option: company-etags-ignore-case
+ Non-nil to ignore case in this backend’s completions.
+
+ -- User Option: company-etags-everywhere
+ Non-nil to offer completions in comments and strings. It can also
+ be set to ‘t’ or a list of major modes in which this would happen.
+
+ -- User Option: company-etags-completion-styles
+ Non-nil to use ‘completion-styles’ for matching completions in this
+ backend. It can be set to ‘t’ to use the global value of
+ ‘completion-styles’, or to a list of symbols to use specific
+ completion styles with this backend. The default value is nil.
+
+\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 backends can be manipulated
+before output: reorganized, reduced, sorted, etc. To apply adjustments,
+add a processing function name to the user option ‘company-transformers’
+list.
+
+The transformer functions are called in a sequence, each with the return
+value of the previous one. The first function receives a sorted list of
+distinct completion candidates. Note that the default sorting behavior
+may be overridden by backends and influenced by the use of the keyword
+‘:separate’ in the grouped backends list (*note Grouped Backends::).
+
+Since Company does not treat candidates with differing annotations as
+duplicates, it may sometimes be desirable to condense completion lists
+containing such entries. In the example below, post-processing begins
+with their removal. Then, the weighted ordering of the candidates is
+performed.
+
+ ;; Set grouped backends.
+ (setq company-backends '((company-capf company-dabbrev-code)))
+
+ ;; Apply post-processing.
+ (setq company-transformers '(delete-consecutive-dups
+ company-sort-by-occurrence))
+
+If a grouped backend contains the keyword ‘:separate’, you can use the
+‘delete-dups’ function instead.
+
+ ;; Set grouped backends.
+ (setq company-backends
+ '((:separate company-capf company-dabbrev-code)))
+
+ ;; Apply post-processing.
+ (setq company-transformers '(delete-dups
+ company-sort-by-occurrence))
+
+Company is bundled with several transformer functions.
+
+ -- 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 23)
+* C-g <1>: Commands. (line 34)
+* C-g <2>: Candidates Search. (line 11)
+* C-g <3>: Filter Candidates. (line 14)
+* C-h: Commands. (line 38)
+* 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 45)
+* 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 26)
+
+\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 98)
+* company-backends: Backends. (line 12)
+* company-backends <1>: Backends Usage Basics.
+ (line 6)
+* company-backends <2>: Grouped Backends. (line 6)
+* company-capf-disabled-functions: Code Completion. (line 26)
+* company-clang-arguments: Code Completion. (line 84)
+* company-completion-cancelled-hook: Configuration File. (line 94)
+* company-completion-finished-hook: Configuration File. (line 96)
+* company-completion-started-hook: Configuration File. (line 92)
+* company-dabbrev-code-completion-styles: Code Completion. (line 61)
+* company-dabbrev-code-everywhere: Code Completion. (line 55)
+* company-dabbrev-code-modes: Code Completion. (line 39)
+* company-dabbrev-code-other-buffers: Code Completion. (line 45)
+* 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 183)
+* company-echo-truncate-lines: Echo Frontends. (line 33)
+* company-etags-completion-styles: Code Completion. (line 109)
+* company-etags-everywhere: Code Completion. (line 105)
+* company-etags-ignore-case: Code Completion. (line 102)
+* 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 158)
+* company-frontends: Frontends. (line 6)
+* company-global-modes: Configuration File. (line 35)
+* company-icon-margin: Tooltip Frontends. (line 169)
+* company-icon-size: Tooltip Frontends. (line 169)
+* company-idle-delay: Configuration File. (line 17)
+* company-inhibit-inside-symbols: Configuration File. (line 31)
+* company-insertion-on-trigger: Configuration File. (line 68)
+* company-insertion-triggers: Configuration File. (line 76)
+* company-ispell-dictionary: Text Completion. (line 84)
+* company-lighter-base: Configuration File. (line 63)
+* company-minimum-prefix-length: Configuration File. (line 9)
+* company-mode: Initial Setup. (line 6)
+* company-occurrence-weight-function: Candidates Post-Processing.
+ (line 47)
+* company-require-match: Configuration File. (line 55)
+* company-search-regexp-function: Candidates Search. (line 13)
+* company-selection-wrap-around: Configuration File. (line 47)
+* company-show-quick-access: Quick Access a Candidate.
+ (line 12)
+* company-text-face-extra-attributes: Tooltip Frontends. (line 196)
+* company-text-icons-add-background: Tooltip Frontends. (line 204)
+* company-text-icons-format: Tooltip Frontends. (line 176)
+* company-text-icons-mapping: Tooltip Frontends. (line 192)
+* company-tooltip-align-annotations: Tooltip Frontends. (line 51)
+* company-tooltip-annotation-padding: Tooltip Frontends. (line 63)
+* company-tooltip-flip-when-above: Tooltip Frontends. (line 106)
+* company-tooltip-idle-delay: Tooltip Frontends. (line 21)
+* company-tooltip-limit: Tooltip Frontends. (line 71)
+* company-tooltip-margin: Tooltip Frontends. (line 139)
+* company-tooltip-maximum-width: Tooltip Frontends. (line 132)
+* company-tooltip-minimum: Tooltip Frontends. (line 91)
+* company-tooltip-minimum-width: Tooltip Frontends. (line 117)
+* company-tooltip-offset-display: Tooltip Frontends. (line 81)
+* company-tooltip-width-grow-only: Tooltip Frontends. (line 127)
+* 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 34)
+* company-begin-backend: Backends Usage Basics.
+ (line 24)
+* company-capf: Code Completion. (line 6)
+* company-clang: Code Completion. (line 72)
+* company-complete: Usage Basics. (line 10)
+* company-complete <1>: Commands. (line 51)
+* company-complete-common: Commands. (line 51)
+* company-complete-common-or-cycle: Commands. (line 26)
+* company-complete-selection: Commands. (line 21)
+* company-dabbrev: Text Completion. (line 6)
+* company-dabbrev-code: Code Completion. (line 33)
+* company-detect-icons-margin: Tooltip Frontends. (line 213)
+* company-diag: Backends Usage Basics.
+ (line 13)
+* company-diag <1>: Troubleshooting. (line 6)
+* company-dot-icons-margin: Tooltip Frontends. (line 182)
+* 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 98)
+* company-files: File Name Completion.
+ (line 6)
+* company-indent-or-complete-common: Commands. (line 51)
+* company-ispell: Text Completion. (line 75)
+* company-keywords: Code Completion. (line 67)
+* company-mode: Initial Setup. (line 6)
+* company-other-backend: Backends Usage Basics.
+ (line 16)
+* 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 16)
+* company-pseudo-tooltip-unless-just-one-frontend: Tooltip Frontends.
+ (line 10)
+* company-pseudo-tooltip-unless-just-one-frontend-with-delay: Tooltip Frontends.
+ (line 20)
+* 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 90)
+* company-show-doc-buffer: Commands. (line 38)
+* company-show-location: Commands. (line 45)
+* company-sort-by-backend-importance: Candidates Post-Processing.
+ (line 53)
+* company-sort-by-occurrence: Candidates Post-Processing.
+ (line 43)
+* company-sort-prefer-same-case-prefix: Candidates Post-Processing.
+ (line 59)
+* company-tempo: Template Expansion. (line 11)
+* company-text-icons-margin: Tooltip Frontends. (line 175)
+* company-tng-frontend: Structure. (line 26)
+* company-tng-mode: Structure. (line 26)
+* company-vscode-dark-icons-margin: Tooltip Frontends. (line 167)
+* company-vscode-light-icons-margin: Tooltip Frontends. (line 168)
+* 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:
+
+* :separate: Grouped Backends. (line 14)
+* :separate <1>: Candidates Post-Processing.
+ (line 11)
+* :separate <2>: Candidates Post-Processing.
+ (line 30)
+* :with: Grouped Backends. (line 25)
+* abbrev: Template Expansion. (line 6)
+* abort: Usage Basics. (line 23)
+* abort <1>: Commands. (line 34)
+* activate: Initial Setup. (line 8)
+* active backend: Backends Usage Basics.
+ (line 13)
+* active backend <1>: Troubleshooting. (line 14)
+* annotation: Tooltip Frontends. (line 52)
+* annotation <1>: Candidates Post-Processing.
+ (line 17)
+* auto-start: Initial Setup. (line 13)
+* backend: Structure. (line 6)
+* backend <1>: Structure. (line 10)
+* backend <2>: Backends Usage Basics.
+ (line 13)
+* backend <3>: Backends Usage Basics.
+ (line 16)
+* backend <4>: Troubleshooting. (line 14)
+* backends: Backends. (line 6)
+* backends <1>: Backends Usage Basics.
+ (line 6)
+* backends <2>: Grouped Backends. (line 6)
+* backends <3>: Package Backends. (line 6)
+* backends <4>: Candidates Post-Processing.
+ (line 11)
+* basics: Usage Basics. (line 6)
+* bug: Troubleshooting. (line 6)
+* bug <1>: Troubleshooting. (line 25)
+* bundled backends: Package Backends. (line 6)
+* cancel: Usage Basics. (line 23)
+* cancel <1>: Commands. (line 34)
+* 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 222)
+* color <1>: Quick Access a Candidate.
+ (line 34)
+* common part: Usage Basics. (line 17)
+* common part <1>: Commands. (line 26)
+* 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 222)
+* 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 48)
+* configure <4>: Tooltip Frontends. (line 222)
+* 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 25)
+* configure <9>: Quick Access a Candidate.
+ (line 34)
+* custom: Customization. (line 6)
+* custom <1>: Customization Interface.
+ (line 6)
+* custom <2>: Configuration File. (line 6)
+* custom <3>: Tooltip Frontends. (line 48)
+* custom <4>: Tooltip Frontends. (line 222)
+* 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 25)
+* custom <9>: Quick Access a Candidate.
+ (line 34)
+* definition: Commands. (line 45)
+* distribution: Installation. (line 6)
+* doc: Commands. (line 38)
+* duplicates: Candidates Post-Processing.
+ (line 17)
+* duplicates <1>: Candidates Post-Processing.
+ (line 30)
+* echo: Echo Frontends. (line 6)
+* enable: Initial Setup. (line 8)
+* error: Troubleshooting. (line 6)
+* error <1>: Troubleshooting. (line 25)
+* expansion: Template Expansion. (line 6)
+* extensible: Structure. (line 6)
+* face: Tooltip Frontends. (line 222)
+* 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 34)
+* filter: Filter Candidates. (line 6)
+* finish: Usage Basics. (line 23)
+* finish <1>: Commands. (line 34)
+* font: Tooltip Frontends. (line 222)
+* font <1>: Quick Access a Candidate.
+ (line 34)
+* frontend: Structure. (line 6)
+* frontend <1>: Structure. (line 10)
+* frontends: Frontends. (line 6)
+* grouped backends: Grouped Backends. (line 6)
+* grouped backends <1>: Candidates Post-Processing.
+ (line 11)
+* icon: Tooltip Frontends. (line 151)
+* install: Installation. (line 6)
+* interface: Tooltip Frontends. (line 48)
+* interface <1>: Tooltip Frontends. (line 222)
+* 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 34)
+* intro: Initial Setup. (line 6)
+* issue: Troubleshooting. (line 6)
+* issue tracker: Troubleshooting. (line 25)
+* kind: Tooltip Frontends. (line 151)
+* location: Commands. (line 45)
+* manual: Initial Setup. (line 8)
+* manual <1>: Usage Basics. (line 10)
+* margin: Tooltip Frontends. (line 140)
+* margin <1>: Tooltip Frontends. (line 159)
+* 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 16)
+* 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)
+* post-processing: Candidates Post-Processing.
+ (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 23)
+* quit <1>: Commands. (line 34)
+* 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 23)
+* stop <1>: Commands. (line 34)
+* 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 17)
+* tooltip: Tooltip Frontends. (line 6)
+* troubleshoot: Troubleshooting. (line 6)
+* usage: Usage Basics. (line 6)
+
+
+\1f
+Tag Table:
+Node: Top\7f573
+Node: Overview\7f2002
+Node: Terminology\7f2410
+Node: Structure\7f3717
+Node: Getting Started\7f5208
+Node: Installation\7f5486
+Node: Initial Setup\7f5869
+Node: Usage Basics\7f6717
+Node: Commands\7f7695
+Ref: Commands-Footnote-1\7f10093
+Node: Customization\7f10260
+Node: Customization Interface\7f10732
+Node: Configuration File\7f11265
+Ref: company-selection-wrap-around\7f13579
+Node: Frontends\7f16072
+Node: Tooltip Frontends\7f17041
+Ref: Tooltip Frontends-Footnote-1\7f27755
+Node: Preview Frontends\7f27992
+Ref: Preview Frontends-Footnote-1\7f29250
+Node: Echo Frontends\7f29377
+Node: Candidates Search\7f30910
+Node: Filter Candidates\7f32244
+Node: Quick Access a Candidate\7f33024
+Node: Backends\7f34642
+Node: Backends Usage Basics\7f35672
+Ref: Backends Usage Basics-Footnote-1\7f37104
+Node: Grouped Backends\7f37188
+Node: Package Backends\7f38699
+Node: Code Completion\7f39628
+Node: Text Completion\7f45155
+Node: File Name Completion\7f49589
+Node: Template Expansion\7f51137
+Node: Candidates Post-Processing\7f51856
+Node: Troubleshooting\7f54433
+Node: Index\7f56106
+Node: Key Index\7f56269
+Node: Variable Index\7f57768
+Node: Function Index\7f62621
+Node: Concept Index\7f67321
+\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
