commit - 85f35f709ae68a3c91a0fff511963caef8af59c6
commit + 952c767e64b60723ca97250ee2138ba1e8c971d3
blob - cb6545fa687c04507887b68e7171e8a88b3c76e8
blob + 5392a22dc6b285604655465f7daddad4c65d82e9
--- .gitignore
+++ .gitignore
org-roam.db
private.el
projects
+semanticdb
tramp
transient
url
blob - 24ec3b775d61b85e3748faac8f646435247d30c7 (mode 644)
blob + /dev/null
--- elpa/company-0.9.13/company-abbrev.el
+++ /dev/null
-;;; company-abbrev.el --- company-mode completion backend for abbrev
-
-;; Copyright (C) 2009-2011, 2015 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 <http://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))))
- (meta (abbrev-expansion arg))))
-
-(provide 'company-abbrev)
-;;; company-abbrev.el ends here
blob - d33c299792c9315b44c8b9801ca9082984d07fd0 (mode 644)
blob + /dev/null
Binary files elpa/company-0.9.13/company-abbrev.elc and /dev/null differ
blob - 3a864d6975dd783d8e83871371270e7902a2b61c (mode 644)
blob + /dev/null
--- elpa/company-0.9.13/company-autoloads.el
+++ /dev/null
-;;; company-autoloads.el --- automatically extracted autoloads
-;;
-;;; Code:
-
-(add-to-list 'load-path (directory-file-name
- (or (file-name-directory #$) (car load-path))))
-
-
-;;;### (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'.
-
-If called interactively, enable Company mode if ARG is positive,
-and disable it if ARG is zero or negative. If called from Lisp,
-also enable the mode if ARG is omitted or nil, and toggle it if
-ARG is `toggle'; disable the mode otherwise.
-
-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, enable the mode if
-ARG is omitted or nil.
-
-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)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company" '("company-")))
-
-;;;***
-
-;;;### (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)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-abbrev" '("company-abbrev-insert")))
-
-;;;***
-
-;;;### (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)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-bbdb" '("company-bbdb-")))
-
-;;;***
-
-;;;### (autoloads nil "company-capf" "company-capf.el" (0 0 0 0))
-;;; Generated autoloads from company-capf.el
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-capf" '("company-")))
-
-;;;***
-
-;;;### (autoloads nil "company-clang" "company-clang.el" (0 0 0 0))
-;;; Generated autoloads from company-clang.el
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-clang" '("company-clang")))
-
-;;;***
-
-;;;### (autoloads nil "company-cmake" "company-cmake.el" (0 0 0 0))
-;;; Generated autoloads from company-cmake.el
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-cmake" '("company-cmake")))
-
-;;;***
-
-;;;### (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)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-css" '("company-css-")))
-
-;;;***
-
-;;;### (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)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-dabbrev" '("company-dabbrev-")))
-
-;;;***
-
-;;;### (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)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-dabbrev-code" '("company-dabbrev-code-")))
-
-;;;***
-
-;;;### (autoloads nil "company-eclim" "company-eclim.el" (0 0 0 0))
-;;; Generated autoloads from company-eclim.el
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-eclim" '("company-eclim")))
-
-;;;***
-
-;;;### (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)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-elisp" '("company-elisp-")))
-
-;;;***
-
-;;;### (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)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-etags" '("company-etags-")))
-
-;;;***
-
-;;;### (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)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-files" '("company-file")))
-
-;;;***
-
-;;;### (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)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-gtags" '("company-gtags-")))
-
-;;;***
-
-;;;### (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)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-ispell" '("company-ispell-")))
-
-;;;***
-
-;;;### (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)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-keywords" '("company-keywords-")))
-
-;;;***
-
-;;;### (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)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-nxml" '("company-nxml-")))
-
-;;;***
-
-;;;### (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)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-oddmuse" '("company-oddmuse-")))
-
-;;;***
-
-;;;### (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)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-semantic" '("company-semantic-")))
-
-;;;***
-
-;;;### (autoloads nil "company-template" "company-template.el" (0
-;;;;;; 0 0 0))
-;;; Generated autoloads from company-template.el
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-template" '("company-template-")))
-
-;;;***
-
-;;;### (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)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-tempo" '("company-tempo-")))
-
-;;;***
-
-;;;### (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)
-
-(autoload 'company-tng-configure-default "company-tng" "\
-Applies the default configuration to enable company-tng." nil nil)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-tng" '("company-tng--")))
-
-;;;***
-
-;;;### (autoloads nil "company-xcode" "company-xcode.el" (0 0 0 0))
-;;; Generated autoloads from company-xcode.el
-
-(autoload 'company-xcode "company-xcode" "\
-`company-mode' completion backend for Xcode projects.
-
-\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-xcode" '("company-xcode-")))
-
-;;;***
-
-;;;### (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)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-yasnippet" '("company-yasnippet-")))
-
-;;;***
-
-;;;### (autoloads nil nil ("company-pkg.el") (0 0 0 0))
-
-;;;***
-
-;; Local Variables:
-;; version-control: never
-;; no-byte-compile: t
-;; no-update-autoloads: t
-;; coding: utf-8
-;; End:
-;;; company-autoloads.el ends here
blob - a68c34ec2d94dfde48fecb7206c3783f33a3b575 (mode 644)
blob + /dev/null
--- elpa/company-0.9.13/company-bbdb.el
+++ /dev/null
-;;; company-bbdb.el --- company-mode completion backend for BBDB in message-mode
-
-;; Copyright (C) 2013-2014, 2016 Free Software Foundation, Inc.
-
-;; Author: Jan Tatarik <jan.tatarik@gmail.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 <http://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
blob - 420f1611027af791e4e3997ac2408d4bfdb69363 (mode 644)
blob + /dev/null
Binary files elpa/company-0.9.13/company-bbdb.elc and /dev/null differ
blob - cb30a8012d2c1bf2c060653988f0371cc7a510a5 (mode 644)
blob + /dev/null
--- elpa/company-0.9.13/company-capf.el
+++ /dev/null
-;;; company-capf.el --- company-mode completion-at-point-functions backend -*- lexical-binding: t -*-
-
-;; Copyright (C) 2013-2019 Free Software Foundation, Inc.
-
-;; Author: Stefan Monnier <monnier@iro.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 <http://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--capf-data-real ()
- (cl-letf* (((default-value 'completion-at-point-functions)
- ;; 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)))
- (completion-at-point-functions (company--capf-workaround))
- (data (run-hook-wrapped 'completion-at-point-functions
- ;; Ignore misbehaving functions.
- #'completion--capf-wrapper 'optimist)))
- (when (and (consp (cdr data)) (integer-or-marker-p (nth 1 data))) data)))
-
-(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
- (let ((f (plist-get (nthcdr 4 company-capf--current-completion-data)
- :annotation-function)))
- (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--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
blob - 02454460cfd492fc85e935a0a488a7ee3205fdbf (mode 644)
blob + /dev/null
Binary files elpa/company-0.9.13/company-capf.elc and /dev/null differ
blob - 1460e092b246474f587fc1b985a6ae2550c4b51b (mode 644)
blob + /dev/null
--- elpa/company-0.9.13/company-clang.el
+++ /dev/null
-;;; company-clang.el --- company-mode completion backend for Clang -*- lexical-binding: t -*-
-
-;; Copyright (C) 2009, 2011, 2013-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 <http://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, 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-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
- "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 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-;; TODO: Handle Pattern (syntactic hints would be neat).
-;; Do we ever see OVERLOAD (or OVERRIDE)?
-(defconst company-clang--completion-pattern
- "^COMPLETION: \\_<\\(%s[a-zA-Z0-9_:]*\\)\\(?:\\(?: (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)
- lines match)
- (while (re-search-forward pattern nil t)
- (setq match (match-string-no-properties 1))
- (unless (equal match "Pattern")
- (save-match-data
- (when (string-match ":" match)
- (setq match (substring match 0 (match-beginning 0)))))
- (let ((meta (match-string-no-properties 2)))
- (when (and meta (not (string= match meta)))
- (put-text-property 0 1 'meta
- (company-clang--strip-formatting meta)
- match)))
- (push match lines)))
- lines))
-
-(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)))))
-
-(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.
- (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 company-clang--version
- (`(apple . ,ver) (>= ver apple-min))
- (`(normal . ,ver) (>= ver min))
- (_ (error "pcase-exhaustive is not in Emacs 24.3!"))))
-
-(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))
- (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))))))))
-
-(provide 'company-clang)
-;;; company-clang.el ends here
blob - 725bd100a863c206e45382661ee3f37906158e6f (mode 644)
blob + /dev/null
Binary files elpa/company-0.9.13/company-clang.elc and /dev/null differ
blob - 1bfb20bae5472fe4369aac83fc7276820d843f58 (mode 644)
blob + /dev/null
--- elpa/company-0.9.13/company-cmake.el
+++ /dev/null
-;;; company-cmake.el --- company-mode completion backend for CMake
-
-;; Copyright (C) 2013-2014, 2017-2018 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 <http://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-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
blob - c2272dfd3b092d5812f92a94753321e5286dab1a (mode 644)
blob + /dev/null
Binary files elpa/company-0.9.13/company-cmake.elc and /dev/null differ
blob - d3ece74dc528d889eb64e01fa5a72bfcb4a6e931 (mode 644)
blob + /dev/null
--- elpa/company-0.9.13/company-css.el
+++ /dev/null
-;;; company-css.el --- company-mode completion backend for css-mode -*- lexical-binding: t -*-
-
-;; Copyright (C) 2009, 2011, 2014, 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 <http://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
blob - 115607bfbb1255352514dbfb6528ae2eb9726419 (mode 644)
blob + /dev/null
Binary files elpa/company-0.9.13/company-css.elc and /dev/null differ
blob - 37f287c5208e3ac478b39a9951cf0c5219e23187 (mode 644)
blob + /dev/null
--- elpa/company-0.9.13/company-dabbrev-code.el
+++ /dev/null
-;;; company-dabbrev-code.el --- dabbrev-like company-mode backend for code -*- lexical-binding: t -*-
-
-;; Copyright (C) 2009, 2011, 2014 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 <http://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))))
- (ignore-case company-dabbrev-code-ignore-case)
- (duplicates t)))
-
-(provide 'company-dabbrev-code)
-;;; company-dabbrev-code.el ends here
blob - 3943abd0a4ce1c714fd1b9bf813bbf8ea1a48b2b (mode 644)
blob + /dev/null
Binary files elpa/company-0.9.13/company-dabbrev-code.elc and /dev/null differ
blob - 5d2f31867575f67144eb2ae6692b63f054ee85e0 (mode 644)
blob + /dev/null
--- elpa/company-0.9.13/company-dabbrev.el
+++ /dev/null
-;;; company-dabbrev.el --- dabbrev-like company-mode completion backend -*- lexical-binding: t -*-
-
-;; Copyright (C) 2009, 2011, 2014, 2015, 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 <http://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)))
- (ignore-case company-dabbrev-ignore-case)
- (duplicates t)))
-
-(provide 'company-dabbrev)
-;;; company-dabbrev.el ends here
blob - d4a5e1f71908d674c55065adc928dcae1e9d6196 (mode 644)
blob + /dev/null
Binary files elpa/company-0.9.13/company-dabbrev.elc and /dev/null differ
blob - b37f75602e01fadc1a9110805b0e08fee47f6659 (mode 644)
blob + /dev/null
--- elpa/company-0.9.13/company-eclim.el
+++ /dev/null
-;;; company-eclim.el --- company-mode completion backend for Eclim
-
-;; Copyright (C) 2009, 2011, 2013, 2015 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 <http://www.gnu.org/licenses/>.
-
-;;; Commentary:
-;;
-;; Using `emacs-eclim' together with (or instead of) this backend is
-;; recommended, as it allows you to use other Eclim features.
-;;
-;; The alternative backend provided by `emacs-eclim' uses `yasnippet'
-;; instead of `company-template' to expand function calls, and it supports
-;; some languages other than Java.
-
-;;; Code:
-
-(require 'company)
-(require 'company-template)
-(require 'cl-lib)
-
-(defgroup company-eclim nil
- "Completion backend for Eclim."
- :group 'company)
-
-(defun company-eclim-executable-find ()
- (let (file)
- (cl-dolist (eclipse-root '("/Applications/eclipse" "/usr/lib/eclipse"
- "/usr/local/lib/eclipse"))
- (and (file-exists-p (setq file (expand-file-name "plugins" eclipse-root)))
- (setq file (car (last (directory-files file t "^org.eclim_"))))
- (file-exists-p (setq file (expand-file-name "bin/eclim" file)))
- (cl-return file)))))
-
-(defcustom company-eclim-executable
- (or (bound-and-true-p eclim-executable)
- (executable-find "eclim")
- (company-eclim-executable-find))
- "Location of eclim executable."
- :type 'file)
-
-(defcustom company-eclim-auto-save t
- "Determines whether to save the buffer when retrieving completions.
-eclim can only complete correctly when the buffer has been saved."
- :type '(choice (const :tag "Off" nil)
- (const :tag "On" t)))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defvar-local company-eclim--project-dir 'unknown)
-
-(defvar-local company-eclim--project-name nil)
-
-(declare-function json-read "json")
-(defvar json-array-type)
-
-(defun company-eclim--call-process (&rest args)
- (let ((coding-system-for-read 'utf-8)
- res)
- (require 'json)
- (with-temp-buffer
- (if (= 0 (setq res (apply 'call-process company-eclim-executable nil t nil
- "-command" args)))
- (let ((json-array-type 'list))
- (goto-char (point-min))
- (unless (eobp)
- (json-read)))
- (message "Company-eclim command failed with error %d:\n%s" res
- (buffer-substring (point-min) (point-max)))
- nil))))
-
-(defun company-eclim--project-list ()
- (company-eclim--call-process "project_list"))
-
-(defun company-eclim--project-dir ()
- (if (eq company-eclim--project-dir 'unknown)
- (let ((dir (locate-dominating-file buffer-file-name ".project")))
- (when dir
- (setq company-eclim--project-dir
- (directory-file-name
- (expand-file-name dir)))))
- company-eclim--project-dir))
-
-(defun company-eclim--project-name ()
- (or company-eclim--project-name
- (let ((dir (company-eclim--project-dir)))
- (when dir
- (setq company-eclim--project-name
- (cl-loop for project in (company-eclim--project-list)
- when (equal (cdr (assoc 'path project)) dir)
- return (cdr (assoc 'name project))))))))
-
-(defun company-eclim--candidates (prefix)
- (interactive "d")
- (let ((project-file (file-relative-name buffer-file-name
- (company-eclim--project-dir)))
- completions)
- (when company-eclim-auto-save
- (when (buffer-modified-p)
- (basic-save-buffer))
- ;; FIXME: Sometimes this isn't finished when we complete.
- (company-eclim--call-process "java_src_update"
- "-p" (company-eclim--project-name)
- "-f" project-file))
- (dolist (item (cdr (assoc 'completions
- (company-eclim--call-process
- "java_complete" "-p" (company-eclim--project-name)
- "-f" project-file
- "-o" (number-to-string
- (company-eclim--search-point prefix))
- "-e" "utf-8"
- "-l" "standard"))))
- (let* ((meta (cdr (assoc 'info item)))
- (completion meta))
- (when (string-match " ?[(:-]" completion)
- (setq completion (substring completion 0 (match-beginning 0))))
- (put-text-property 0 1 'meta meta completion)
- (push completion completions)))
- (let ((completion-ignore-case nil))
- (all-completions prefix completions))))
-
-(defun company-eclim--search-point (prefix)
- (if (or (cl-plusp (length prefix)) (eq (char-before) ?.))
- (1- (point))
- (point)))
-
-(defun company-eclim--meta (candidate)
- (get-text-property 0 'meta candidate))
-
-(defun company-eclim--annotation (candidate)
- (let ((meta (company-eclim--meta candidate)))
- (when (string-match "\\(([^-]*\\) -" meta)
- (substring meta (match-beginning 1) (match-end 1)))))
-
-(defun company-eclim--prefix ()
- (let ((prefix (company-grab-symbol)))
- (when prefix
- ;; Completion candidates for annotations don't include '@'.
- (when (eq ?@ (string-to-char prefix))
- (setq prefix (substring prefix 1)))
- prefix)))
-
-(defun company-eclim (command &optional arg &rest ignored)
- "`company-mode' completion backend for Eclim.
-Eclim provides access to Eclipse Java IDE features for other editors.
-
-Eclim version 1.7.13 or newer (?) is required.
-
-Completions only work correctly when the buffer has been saved.
-`company-eclim-auto-save' determines whether to do this automatically."
- (interactive (list 'interactive))
- (cl-case command
- (interactive (company-begin-backend 'company-eclim))
- (prefix (and (derived-mode-p 'java-mode 'jde-mode)
- buffer-file-name
- company-eclim-executable
- (company-eclim--project-name)
- (not (company-in-string-or-comment))
- (or (company-eclim--prefix) 'stop)))
- (candidates (company-eclim--candidates arg))
- (meta (company-eclim--meta arg))
- ;; because "" doesn't return everything
- (no-cache (equal arg ""))
- (annotation (company-eclim--annotation arg))
- (post-completion (let ((anno (company-eclim--annotation arg)))
- (when anno
- (insert anno)
- (company-template-c-like-templatify anno))))))
-
-(provide 'company-eclim)
-;;; company-eclim.el ends here
blob - 612bd90adcf8d1d35725d691ab6696458f5cb84a (mode 644)
blob + /dev/null
Binary files elpa/company-0.9.13/company-eclim.elc and /dev/null differ
blob - db1653da18968c974400b12b114fdf7db8a85b05 (mode 644)
blob + /dev/null
--- elpa/company-0.9.13/company-elisp.el
+++ /dev/null
-;;; company-elisp.el --- company-mode completion backend for Emacs Lisp -*- lexical-binding: t -*-
-
-;; Copyright (C) 2009, 2011-2013, 2017 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 <http://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
blob - 531685d18b27cbf3f63ceda1fe96204d7975f7be (mode 644)
blob + /dev/null
Binary files elpa/company-0.9.13/company-elisp.elc and /dev/null differ
blob - d0c27c9c3c9cee5c8bf689459dbdfc30d27cc41e (mode 644)
blob + /dev/null
--- elpa/company-0.9.13/company-etags.el
+++ /dev/null
-;;; company-etags.el --- company-mode completion backend for etags
-
-;; Copyright (C) 2009-2011, 2014 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 <http://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
blob - 5c5bb671aa8e388b60ed36e5d3da1f137efa73f5 (mode 644)
blob + /dev/null
Binary files elpa/company-0.9.13/company-etags.elc and /dev/null differ
blob - 8859266f1d13a30392c51db23611dc6663fcef8e (mode 644)
blob + /dev/null
--- elpa/company-0.9.13/company-files.el
+++ /dev/null
-;;; company-files.el --- company-mode completion backend for file names
-
-;; Copyright (C) 2009-2011, 2014-2015 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 <http://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
- "File name extensions and directory names to ignore.
-The values should use the same format as `completion-ignored-extensions'."
- :type '(const string)
- :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 (equal prefix "")
- (delete "../" (delete "./" comp))
- comp))
- (file-error nil)))
-
-(defun company-files--exclusions-filtered (completions)
- (let* ((dir-exclusions (cl-delete-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 (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))
- (sorted t)
- (no-cache t)))
-
-(provide 'company-files)
-;;; company-files.el ends here
blob - 5c4466d6e8e0ecf3a9171b57fb02073710886c6e (mode 644)
blob + /dev/null
Binary files elpa/company-0.9.13/company-files.elc and /dev/null differ
blob - 598ba60f162ead4d0e0625a6ec55295ddb84f609 (mode 644)
blob + /dev/null
--- elpa/company-0.9.13/company-gtags.el
+++ /dev/null
-;;; company-gtags.el --- company-mode completion backend for GNU Global
-
-;; Copyright (C) 2009-2011, 2014-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 <http://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)
-
-(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))
-
-(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)
- (match-string 1 meta))))
-
-;;;###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
blob - f08bbe92813d5691436f71a83f00b2c41fcb165c (mode 644)
blob + /dev/null
Binary files elpa/company-0.9.13/company-gtags.elc and /dev/null differ
blob - ed658f2ff118847eb97f54551f588d95ff961cd9 (mode 644)
blob + /dev/null
--- elpa/company-0.9.13/company-ispell.el
+++ /dev/null
-;;; company-ispell.el --- company-mode completion backend using Ispell
-
-;; 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 <http://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))))
- (sorted t)
- (ignore-case 'keep-prefix)))
-
-(provide 'company-ispell)
-;;; company-ispell.el ends here
blob - 23782d58ce3b1c73582674fe3115f07e1b02fe26 (mode 644)
blob + /dev/null
Binary files elpa/company-0.9.13/company-ispell.elc and /dev/null differ
blob - 7cafb4cd4b8c85558a02cf3a4599dde9c7abc421 (mode 644)
blob + /dev/null
--- elpa/company-0.9.13/company-keywords.el
+++ /dev/null
-;;; company-keywords.el --- A company backend for programming language keywords
-
-;; Copyright (C) 2009-2011, 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 <http://www.gnu.org/licenses/>.
-
-
-;;; Commentary:
-;;
-
-;;; Code:
-
-(require 'company)
-(require 'cl-lib)
-
-(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" "_Generic" "_Imaginary"
- "_Noreturn" "_Static_assert" "_Thread_local"
- "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")
- (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")
- (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")
- (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
- "__CLASS__" "__DIR__" "__FILE__" "__FUNCTION__" "__LINE__" "__METHOD__"
- "__NAMESPACE__" "_once" "abstract" "and" "array" "as" "break" "case"
- "catch" "cfunction" "class" "clone" "const" "continue" "declare"
- "default" "die" "do" "echo" "else" "elseif" "empty" "enddeclare"
- "endfor" "endforeach" "endif" "endswitch" "endwhile" "eval" "exception"
- "exit" "extends" "final" "for" "foreach" "function" "global"
- "goto" "if" "implements" "include" "instanceof" "interface"
- "isset" "list" "namespace" "new" "old_function" "or" "php_user_filter"
- "print" "private" "protected" "public" "require" "require_once" "return"
- "static" "switch" "this" "throw" "try" "unset" "use" "var" "while" "xor")
- (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")
- (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)
- (enh-ruby-mode . ruby-mode))
- "Alist mapping major-modes to sorted keywords for `company-keywords'.")
-
-;;;###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 nil)
- (symbols (cdr (assq major-mode company-keywords-alist))))
- (all-completions arg (if (consp symbols)
- symbols
- (cdr (assq symbols company-keywords-alist))))))
- (sorted t)))
-
-(provide 'company-keywords)
-;;; company-keywords.el ends here
blob - fd5a2557ad4aea303ba6b3ce606b3b685b285855 (mode 644)
blob + /dev/null
Binary files elpa/company-0.9.13/company-keywords.elc and /dev/null differ
blob - 36ff1cebd6faa1fbb616e7917dee3cfb741df022 (mode 644)
blob + /dev/null
--- elpa/company-0.9.13/company-nxml.el
+++ /dev/null
-;;; company-nxml.el --- company-mode completion backend for nxml-mode
-
-;; 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 <http://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
blob - e59a28a24ccdad6f6581246826ff8568064cbf44 (mode 644)
blob + /dev/null
Binary files elpa/company-0.9.13/company-nxml.elc and /dev/null differ
blob - 1b6895093eadbcf91313c7f873968899a9ea7101 (mode 644)
blob + /dev/null
--- elpa/company-0.9.13/company-oddmuse.el
+++ /dev/null
-;;; company-oddmuse.el --- company-mode completion backend for oddmuse-mode
-
-;; Copyright (C) 2009-2011, 2014 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 <http://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 (point-at-bol))
- (or (match-string 1)
- (match-string 2)))))
- (candidates (all-completions arg (company-oddmuse-get-page-table)))))
-
-(provide 'company-oddmuse)
-;;; company-oddmuse.el ends here
blob - 079469dfa18475766053be97a537b3f660177074 (mode 644)
blob + /dev/null
Binary files elpa/company-0.9.13/company-oddmuse.elc and /dev/null differ
blob - 17281929cf7e55fd9782d717021d70ed7c507b63 (mode 644)
blob + /dev/null
--- elpa/company-0.9.13/company-pkg.el
+++ /dev/null
-(define-package "company" "0.9.13" "Modular text completion framework"
- '((emacs "24.3"))
- :commit "656ad10670512e135a0a5881f127bb7a789ef8ca" :authors
- '(("Nikolaj Schumacher"))
- :maintainer
- '("Dmitry Gutov" . "dgutov@yandex.ru")
- :keywords
- '("abbrev" "convenience" "matching")
- :url "http://company-mode.github.io/")
-;; Local Variables:
-;; no-byte-compile: t
-;; End:
blob - 2f6fe2afbc9e65618342a16865bef8e9be08f481 (mode 644)
blob + /dev/null
--- elpa/company-0.9.13/company-semantic.el
+++ /dev/null
-;;; company-semantic.el --- company-mode completion backend using Semantic
-
-;; 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 <http://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
blob - 0f4e9e91c5949523dff9b3998f7aece2461d9377 (mode 644)
blob + /dev/null
Binary files elpa/company-0.9.13/company-semantic.elc and /dev/null differ
blob - be4c41f13630cd6e5f2baee9607adf1ee6d873be (mode 644)
blob + /dev/null
--- elpa/company-0.9.13/company-template.el
+++ /dev/null
-;;; company-template.el --- utility library for template expansion
-
-;; Copyright (C) 2009, 2010, 2014-2017 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 <http://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
blob - 58936fee1c90ebd6b863305328171bb637f0dcf1 (mode 644)
blob + /dev/null
Binary files elpa/company-0.9.13/company-template.elc and /dev/null differ
blob - cba42c3e36e1f7d7e29edcfe130b326136f6aa08 (mode 644)
blob + /dev/null
--- elpa/company-0.9.13/company-tempo.el
+++ /dev/null
-;;; company-tempo.el --- company-mode completion backend for tempo
-
-;; Copyright (C) 2009-2011, 2015 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 <http://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)))
- (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
blob - 18e5dff9f44d443f8a4b4e90179985bc76c71782 (mode 644)
blob + /dev/null
Binary files elpa/company-0.9.13/company-tempo.elc and /dev/null differ
blob - 404d436ecbb0e079cd7d8ebb38a437f344e8e5d6 (mode 644)
blob + /dev/null
--- elpa/company-0.9.13/company-tng.el
+++ /dev/null
-;;; company-tng.el --- company-mode configuration for single-button interaction
-
-;; Copyright (C) 2017-2020 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 <http://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:
-;;
-;; To apply the default configuration for company-tng call
-;; `company-tng-configure-default' from your init script.
-;;
-;; You can also configure company-tng manually:
-;;
-;; Add `company-tng-frontend' to `company-frontends':
-;;
-;; (add-to-list 'company-frontends 'company-tng-frontend)
-;;
-;; 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-configure-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))
- (advice-add 'company-select-next :before-until 'company-tng--allow-unselected)
- (advice-add 'company-fill-propertize :filter-args 'company-tng--adjust-tooltip-highlight))
- (update
- (let ((ov company-tng--overlay)
- (selected (nth company-selection company-candidates))
- (prefix (length company-prefix)))
- (move-overlay ov (- (point) prefix) (point))
- (overlay-put ov
- (if (= prefix 0) 'after-string 'display)
- (and company-selection-changed selected))))
- (hide
- (when company-tng--overlay
- (delete-overlay company-tng--overlay)
- (kill-local-variable 'company-tng--overlay))
- (advice-remove 'company-select-next 'company-tng--allow-unselected)
- (advice-remove 'company-fill-propertize 'company-tng--adjust-tooltip-highlight))
- (pre-command
- (when (and company-selection-changed
- (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)
-
-;;;###autoload
-(defun company-tng-configure-default ()
- "Applies the default configuration to enable company-tng."
- (setq company-require-match nil)
- (setq company-frontends '(company-tng-frontend
- company-pseudo-tooltip-frontend
- company-echo-metadata-frontend))
- (setq 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)
- (let ((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)))
-
-(defun company-tng--allow-unselected (&optional arg)
- "Advice `company-select-next' to allow for an 'unselected'
-state. Unselected means that no user interaction took place on the
-completion candidates and it's marked by setting
-`company-selection-changed' to nil. This advice will call the underlying
-`company-select-next' unless we need to transition to or from an unselected
-state.
-
-Possible state transitions:
-- (arg > 0) unselected -> first candidate selected
-- (arg < 0) first candidate selected -> unselected
-- (arg < 0 wrap-round) unselected -> last candidate selected
-- (arg < 0 no wrap-round) unselected -> unselected
-
-There is no need to advice `company-select-previous' because it calls
-`company-select-next' internally."
- (cond
- ;; Selecting next
- ((or (not arg) (> arg 0))
- (unless company-selection-changed
- (company-set-selection (1- (or arg 1)) 'force-update)
- t))
- ;; Selecting previous
- ((< arg 0)
- (when (and company-selection-changed
- (< (+ company-selection arg) 0))
- (company-set-selection 0)
- (setq company-selection-changed nil)
- (company-call-frontends 'update)
- t)
- )))
-
-(defun company-tng--adjust-tooltip-highlight (args)
- "Prevent the tooltip from highlighting the current selection if it wasn't
-made explicitly (i.e. `company-selection-changed' is true)"
- (unless company-selection-changed
- ;; The 4th arg of `company-fill-propertize' is selected
- (setf (nth 3 args) nil))
- args)
-
-(provide 'company-tng)
-;;; company-tng.el ends here
blob - b69ed12ef5a81e23eac9356ddd3ce2a866ee66b8 (mode 644)
blob + /dev/null
Binary files elpa/company-0.9.13/company-tng.elc and /dev/null differ
blob - 56da19890b2d5d453d91f3b56a8431c869161431 (mode 644)
blob + /dev/null
--- elpa/company-0.9.13/company-xcode.el
+++ /dev/null
-;;; company-xcode.el --- company-mode completion backend for Xcode projects
-
-;; Copyright (C) 2009-2011, 2014 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 <http://www.gnu.org/licenses/>.
-
-
-;;; Commentary:
-;;
-
-;;; Code:
-
-(require 'company)
-(require 'cl-lib)
-
-(defgroup company-xcode nil
- "Completion backend for Xcode projects."
- :group 'company)
-
-(defcustom company-xcode-xcodeindex-executable (executable-find "xcodeindex")
- "Location of xcodeindex executable."
- :type 'file)
-
-(defvar company-xcode-tags nil)
-
-(defun company-xcode-reset ()
- "Reset the cached tags."
- (interactive)
- (setq company-xcode-tags nil))
-
-(defcustom company-xcode-types
- '("Class" "Constant" "Enum" "Macro" "Modeled Class" "Structure"
- "Type" "Union" "Function")
- "The types of symbols offered by `company-xcode'.
-No context-enabled completion is available. Types like methods will be
-offered regardless of whether the class supports them. The defaults should be
-valid in most contexts."
- :set (lambda (variable value)
- (set variable value)
- (company-xcode-reset))
- :type '(set (const "Category") (const "Class") (const "Class Method")
- (const "Class Variable") (const "Constant") (const "Enum")
- (const "Field") (const "Instance Method")
- (const "Instance Variable") (const "Macro")
- (const "Modeled Class") (const "Modeled Method")
- (const "Modeled Property") (const "Property") (const "Protocol")
- (const "Structure") (const "Type") (const "Union")
- (const "Variable") (const "Function")))
-
-(defvar-local company-xcode-project 'unknown)
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defun company-xcode-fetch (project-bundle)
- (setq project-bundle (directory-file-name project-bundle))
- (message "Retrieving dump from %s..." project-bundle)
- (with-temp-buffer
- (let ((default-directory (file-name-directory project-bundle)))
- (call-process company-xcode-xcodeindex-executable nil (current-buffer)
- nil "dump" "-project"
- (file-name-nondirectory project-bundle) "-quiet")
- (goto-char (point-min))
- (let ((regexp (concat "^\\([^\t\n]*\\)\t[^\t\n]*\t"
- (regexp-opt company-xcode-types)
- "\t[^\t\n]*\t[^\t\n]*"))
- candidates)
- (while (re-search-forward regexp nil t)
- (cl-pushnew (match-string 1) candidates :test #'equal))
- (message "Retrieving dump from %s...done" project-bundle)
- candidates))))
-
-(defun company-xcode-find-project ()
- (let ((dir (if buffer-file-name
- (file-name-directory buffer-file-name)
- (expand-file-name default-directory)))
- (prev-dir nil)
- file)
- (while (not (or file (equal dir prev-dir)))
- (setq file (car (directory-files dir t ".xcodeproj\\'" t))
- prev-dir dir
- dir (file-name-directory (directory-file-name dir))))
- file))
-
-(defun company-xcode-tags ()
- (when (eq company-xcode-project 'unknown)
- (setq company-xcode-project (company-xcode-find-project)))
- (when company-xcode-project
- (cdr (or (assoc company-xcode-project company-xcode-tags)
- (car (push (cons company-xcode-project
- (company-xcode-fetch company-xcode-project))
- company-xcode-tags))))))
-;;;###autoload
-(defun company-xcode (command &optional arg &rest ignored)
- "`company-mode' completion backend for Xcode projects."
- (interactive (list 'interactive))
- (cl-case command
- (interactive (company-begin-backend 'company-xcode))
- (prefix (and company-xcode-xcodeindex-executable
- (company-xcode-tags)
- (not (company-in-string-or-comment))
- (or (company-grab-symbol) 'stop)))
- (candidates (let ((completion-ignore-case nil))
- (company-xcode-tags)
- (all-completions arg (company-xcode-tags))))))
-
-
-(provide 'company-xcode)
-;;; company-xcode.el ends here
blob - e9411e757c4953c85be15cbb587c45776c6de9d1 (mode 644)
blob + /dev/null
Binary files elpa/company-0.9.13/company-xcode.elc and /dev/null differ
blob - c2c26886103d80537de527b77e4c6d0d34f8e032 (mode 644)
blob + /dev/null
--- elpa/company-0.9.13/company-yasnippet.el
+++ /dev/null
-;;; company-yasnippet.el --- company-mode completion backend for Yasnippet
-
-;; Copyright (C) 2014, 2015, 2020 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 <http://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")
-
-(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))
- res)
- (when keyhash
- (maphash
- (lambda (key value)
- (when (and (stringp key)
- (string-prefix-p key-prefix key))
- (maphash
- (lambda (name template)
- (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)))
- (with-current-buffer (company-doc-buffer)
- (let ((buffer-file-name file-name))
- (yas-minor-mode 1)
- (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)
- (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
blob - 7412edb3de734959e39355235c8b10a1d91a13ed (mode 644)
blob + /dev/null
Binary files elpa/company-0.9.13/company-yasnippet.elc and /dev/null differ
blob - d460b88a2ebd4b35842ef24338fbe285ae10b2c4 (mode 644)
blob + /dev/null
--- elpa/company-0.9.13/company.el
+++ /dev/null
-;;; company.el --- Modular text completion framework -*- lexical-binding: t -*-
-
-;; Copyright (C) 2009-2020 Free Software Foundation, Inc.
-
-;; Author: Nikolaj Schumacher
-;; Maintainer: Dmitry Gutov <dgutov@yandex.ru>
-;; URL: http://company-mode.github.io/
-;; Version: 0.9.13
-;; Keywords: abbrev, convenience, matching
-;; Package-Requires: ((emacs "24.3"))
-
-;; 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 <http://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 'newcomment)
-(require 'pcase)
-
-;;; Compatibility
-(eval-and-compile
- ;; Defined in Emacs 24.4
- (unless (fboundp 'string-suffix-p)
- (defun string-suffix-p (suffix string &optional ignore-case)
- "Return non-nil if SUFFIX is a suffix of STRING.
-If IGNORE-CASE is non-nil, the comparison is done without paying
-attention to case differences."
- (let ((start-pos (- (length string) (length suffix))))
- (and (>= start-pos 0)
- (eq t (compare-strings suffix nil nil
- string start-pos nil ignore-case)))))))
-
-(defgroup company nil
- "Extensible inline text completion mechanism."
- :group 'abbrev
- :group 'convenience
- :group 'matching)
-
-(defgroup company-faces nil
- "Faces used by Company."
- :group 'company
- :group 'faces)
-
-(defface company-tooltip
- '((default :foreground "black")
- (((class color) (min-colors 88) (background light))
- (:background "cornsilk"))
- (((class color) (min-colors 88) (background dark))
- (:background "yellow"))
- (t
- (: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 "orange1"))
- (t (:background "green")))
- "Face used for the selection in the tooltip.")
-
-(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 "red"))
- "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 "red4"))
- "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-scrollbar-fg
- '((((background light))
- :background "darkred")
- (((background dark))
- :background "red"))
- "Face used for the tooltip scrollbar thumb.")
-
-(defface company-scrollbar-bg
- '((((background light))
- :background "wheat")
- (((background dark))
- :background "gold"))
- "Face used for the tooltip scrollbar background.")
-
-(defface company-preview
- '((((background light))
- :inherit (company-tooltip-selection company-tooltip))
- (((background dark))
- :background "blue4"
- :foreground "wheat"))
- "Face used for the completion preview.")
-
-(defface company-preview-common
- '((((background light))
- :inherit company-tooltip-common-selection)
- (((background dark))
- :inherit company-preview
- :foreground "red"))
- "Face used for the common part of the completion preview.")
-
-(defface company-preview-search
- '((((background light))
- :inherit company-tooltip-common-selection)
- (((background dark))
- :inherit company-preview
- :background "blue1"))
- "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 dark)) (:foreground "firebrick1"))
- (((background light)) (:background "firebrick4")))
- "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.
-
-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
- "The minimum height of the tooltip.
-If this many lines are not available, prefer to display the tooltip above."
- :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-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"))
-
-(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")
- (company-dabbrev . "dabbrev for plain text")
- (company-dabbrev-code . "dabbrev for code")
- (company-eclim . "Eclim (an Eclipse interface)")
- (company-elisp . "Emacs Lisp")
- (company-etags . "etags")
- (company-files . "Files")
- (company-gtags . "GNU Global")
- (company-ispell . "Ispell")
- (company-keywords . "Programming language keywords")
- (company-nxml . "nxml")
- (company-oddmuse . "Oddmuse")
- (company-semantic . "Semantic")
- (company-tempo . "Tempo templates")
- (company-xcode . "Xcode")))
-(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 `(,@(unless (version< "24.3.51" emacs-version)
- (list 'company-elisp))
- company-bbdb
- ,@(unless (version<= "26" emacs-version)
- (list 'company-nxml))
- ,@(unless (version<= "26" emacs-version)
- (list 'company-css))
- company-eclim company-semantic company-clang
- company-xcode company-cmake
- company-capf
- 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.
-
-`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.
-
-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-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-auto-complete' 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)))
-
-(defcustom company-auto-complete nil
- "Determines when to auto-complete.
-If this is enabled, all characters from `company-auto-complete-chars'
-trigger insertion of the selected completion candidate.
-This can also be a function."
- :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)))
-
-(defcustom company-auto-complete-chars '(?\ ?\) ?.)
- "Determines which characters trigger auto-completion.
-See `company-auto-complete'. If this is a string, each string character
-triggers auto-completion. If it is a list of syntax description characters (see
-`modify-syntax-entry'), all characters with that syntax auto-complete.
-
-This can also be a function, which is called with the new input and should
-return non-nil if company should auto-complete.
-
-A character that is part of a valid candidate never triggers auto-completion."
- :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")))
-
-(defcustom company-idle-delay .5
- "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)))
-
-(defcustom company-show-numbers nil
- "If enabled, show quick-access numbers for the first ten candidates."
- :type '(choice (const :tag "off" nil)
- (const :tag "left" 'left)
- (const :tag "on" 't)))
-
-(defcustom company-show-numbers-function #'company--show-numbers
- "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)
-
-(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)))
-
-(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)
- (define-key keymap (kbd "M-p") 'company-select-previous)
- (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)
- (dotimes (i 10)
- (define-key keymap (read-kbd-macro (format "M-%d" i)) 'company-complete-number))
- keymap)
- "Keymap that is enabled during an active completion.")
-
-(defvar company--disabled-backends nil)
-
-(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)
- (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}"
- nil company-lighter company-mode-map
- (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))))
-
-;; Hack:
-;; Emacs calculates the active keymaps before reading the event. That means we
-;; cannot change the keymap from a timer. So we send a bogus command.
-;; XXX: Seems not to be needed anymore in Emacs 24.4
-;; Apparently, starting with emacs-mirror/emacs@99d0d6dc23.
-(defun company-ignore ()
- (interactive)
- (setq this-command last-command))
-
-(global-set-key '[company-dummy-event] 'company-ignore)
-
-(defun company-input-noop ()
- (push 'company-dummy-event unread-command-events))
-
-;; To avoid warnings in Emacs < 26.
-(declare-function line-number-display-width "indent.c")
-
-(defun company--posn-col-row (posn)
- (let ((col (car (posn-col-row posn)))
- ;; `posn-col-row' doesn't work well with lines of different height.
- ;; `posn-actual-col-row' doesn't handle multiple-width characters.
- (row (cdr (or (posn-actual-col-row posn)
- ;; When position is non-visible for some reason.
- (posn-col-row posn)))))
- (when (and header-line-format (version< emacs-version "24.3.93.3"))
- ;; http://debbugs.gnu.org/18384
- (cl-decf row))
- (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 (point-at-bol))))
-
-(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))
- (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-local company-selection 0)
-
-(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 company--auto-completion nil
- "Non-nil when current candidate is being inserted automatically.
-Controlled by `company-auto-complete'.")
-
-(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)))))))
-
-(defun company-call-frontends (command)
- (dolist (frontend company-frontends)
- (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)
- (setq selection
- (if company-selection-wrap-around
- (mod selection company-candidates-length)
- (max 0 (min (1- company-candidates-length) selection))))
- (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 (nth company-selection company-candidates)))
- (setq company-selection 0
- company-candidates candidates)
- (when selected
- (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 0
- company-selection-changed nil))))
- (setq company-selection 0
- 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)))))
- (progn
- ;; No cache match, call the backend.
- (setq candidates (company--preprocess-candidates
- (company--fetch-candidates prefix)))
- ;; 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))))
-
-(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--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)
- (annos 'unk))
- (while c2
- (setcdr c2
- (let ((str (pop c2)))
- (while (let ((str2 (car c2)))
- (if (not (equal str str2))
- (progn
- (setq annos 'unk)
- nil)
- (when (eq annos 'unk)
- (setq annos (list (company-call-backend
- 'annotation str))))
- (let ((anno2 (company-call-backend
- 'annotation str2)))
- (if (member anno2 annos)
- t
- (push anno2 annos)
- 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)))
-
-(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)
- (when (catch 'done
- (goto-char w-start)
- (while (search-forward candidate w-end t)
- (when (and (not (eq (point) start-point))
- (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))
- (when (company-auto-begin)
- (when (version< emacs-version "24.3.50")
- (company-input-noop))
- (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-auto-complete-p (input)
- "Return non-nil if INPUT should trigger auto-completion."
- (and (if (functionp company-auto-complete)
- (funcall company-auto-complete)
- company-auto-complete)
- (if (functionp company-auto-complete-chars)
- (funcall company-auto-complete-chars input)
- (if (consp company-auto-complete-chars)
- (memq (char-syntax (string-to-char input))
- company-auto-complete-chars)
- (string-match (regexp-quote (substring input 0 1))
- company-auto-complete-chars)))))
-
-(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
- ((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-auto-complete-p (string last-command-event)))
- ;; auto-complete
- (save-excursion
- (goto-char company-point)
- (let ((company--auto-completion t))
- (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--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 0
- 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-number)
- "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)
- (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 (length company-prefix))
- (cl-return i))
- (cl-incf i))))
-
-(defun company-search-keypad ()
- (interactive)
- (let* ((name (symbol-name last-command-event))
- (last-command-event (aref name (1- (length name)))))
- (company-search-printing-char)))
-
-(defun company-search-printing-char ()
- (interactive)
- (company--search-assert-enabled)
- (let ((ss (concat company-search-string (string last-command-event))))
- (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* ((pos (company--search new (nthcdr company-selection company-candidates))))
- (if (null pos)
- (ding)
- (setq company-search-string new)
- (company-set-selection (+ company-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 ((pos (company--search company-search-string
- (cdr (nthcdr company-selection
- company-candidates)))))
- (if (null pos)
- (ding)
- (company-set-selection (+ company-selection pos 1) t))))
-
-(defun company-search-repeat-backward ()
- "Repeat the incremental search in completion candidates backwards."
- (interactive)
- (company--search-assert-input)
- (let ((pos (company--search company-search-string
- (nthcdr (- company-candidates-length
- company-selection)
- (reverse company-candidates)))))
- (if (null pos)
- (ding)
- (company-set-selection (- company-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 (read (format "[kp-%s]" i)) 'company-search-keypad))
- (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 "M-n") 'company-select-next)
- (define-key keymap (kbd "M-p") 'company-select-previous)
- (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)
- (dotimes (i 10)
- (define-key keymap (read-kbd-macro (format "M-%d" i)) 'company-complete-number))
- 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'."
- nil company-search-lighter nil
- (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))
-
-(defvar company-filter-map
- (let ((keymap (make-keymap)))
- (define-key keymap [remap company-search-printing-char]
- 'company-filter-printing-char)
- (set-keymap-parent keymap company-search-map)
- keymap)
- "Keymap used for incrementally searching the completion candidates.")
-
-(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."
- (interactive "p")
- (when (company-manual-begin)
- (company-set-selection (+ (or arg 1) company-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 (> 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-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))))))
-
-(defvar company-pseudo-tooltip-overlay)
-
-(defvar company-tooltip-offset)
-
-(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--event-col-row (event)
- (company--posn-col-row (event-start event)))
-
-(defun company-select-mouse (event)
- "Select the candidate picked by the mouse."
- (interactive "e")
- (let ((event-col-row (company--event-col-row event))
- (ovl-row (company--row))
- (ovl-height (and company-pseudo-tooltip-overlay
- (min (overlay-get company-pseudo-tooltip-overlay
- 'company-height)
- company-candidates-length))))
- (if (and ovl-height
- (company--inside-tooltip-p event-col-row ovl-row ovl-height))
- (progn
- (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)
- (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 (company-manual-begin)
- (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-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)))))
-
-(defun company-complete-number (n)
- "Insert the Nth candidate visible in the tooltip.
-To show the number next to the candidates in some backends, enable
-`company-show-numbers'. When called interactively, uses the last typed
-character, stripping the modifiers. That character must be a digit."
- (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))))))
- (n (- char ?0)))
- (if (zerop n) 10 n))))
- (when (company-manual-begin)
- (and (or (< n 1) (> n (- company-candidates-length
- company-tooltip-offset)))
- (user-error "No candidate number %d" n))
- (cl-decf n)
- (company-finish (nth (+ n 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 company-selection 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 ()
- "Temporarily show the documentation buffer for the selection."
- (interactive)
- (let (other-window-scroll-buffer)
- (company--electric-do
- (let* ((selected (nth company-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))))))))
-(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))))
- 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 completion-at-point-functions)))
- (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-pseudo-tooltip-overlay nil)
-
-(defvar-local company-tooltip-offset 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
-
-(defsubst 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-fill-propertize (value annotation width selected left right)
- (let* ((margin (length left))
- (common (or (company-call-backend 'match value)
- (if company-common
- (string-width company-common)
- 0)))
- (_ (setq value (company-reformat (company--pre-render value))
- annotation (and annotation (company--pre-render annotation t))))
- (ann-ralign company-tooltip-align-annotations)
- (ann-truncate (< width
- (+ (length value) (length annotation)
- (if ann-ralign 1 0))))
- (ann-start (+ margin
- (if ann-ralign
- (if ann-truncate
- (1+ (length value))
- (- width (length annotation)))
- (length value))))
- (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 (and annotation ann-ralign) " ")
- annotation)
- 0 width)
- (concat
- (company-safe-substring value 0
- (- width (length annotation)))
- annotation))
- right)))
- (setq width (+ width margin (length right)))
-
- ;; TODO: Use add-face-text-property in Emacs 24.4
- (font-lock-append-text-property 0 width 'mouse-face
- 'company-tooltip-mouse
- line)
- (when (< ann-start ann-end)
- (font-lock-append-text-property ann-start ann-end 'face
- (if selected
- 'company-tooltip-annotation-selection
- 'company-tooltip-annotation)
- line))
- (cl-loop
- with width = (- width (length right))
- for (comp-beg . comp-end) in (if (integerp common) `((0 . ,common)) common)
- for inline-beg = (+ margin comp-beg)
- for inline-end = (min (+ margin comp-end) width)
- when (< inline-beg width)
- do (font-lock-prepend-text-property inline-beg inline-end 'face
- (if selected
- 'company-tooltip-common-selection
- 'company-tooltip-common)
- line))
- (when (let ((re (funcall company-search-regexp-function
- company-search-string)))
- (and (not (string= re ""))
- (string-match re value (length company-prefix))))
- (pcase-dolist (`(,mbeg . ,mend) (company--search-chunks))
- (let ((beg (+ margin mbeg))
- (end (+ margin mend))
- (width (- width (length right))))
- (when (< beg width)
- (font-lock-prepend-text-property beg (min end width) 'face
- (if selected
- 'company-tooltip-search-selection
- 'company-tooltip-search)
- line)))))
- (when selected
- (font-lock-append-text-property 0 width 'face
- 'company-tooltip-selection
- line))
- (font-lock-append-text-property 0 width 'face
- 'company-tooltip
- 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.
- "\u2017")
- ((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 " %d" (mod numbered 10)))
-
-(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))))
- (unless (or (display-graphic-p)
- (version< "24.3.1" emacs-version))
- ;; Emacs 24.3 and earlier included margins
- ;; in window-width when in TTY.
- (cl-decf ww
- (let ((margins (window-margins)))
- (+ (or (car margins) 0)
- (or (cdr margins) 0)))))
- (when (and word-wrap
- (version< emacs-version "24.4.51.5"))
- ;; http://debbugs.gnu.org/19300
- (cl-decf ww))
- ;; 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--replacement-string (lines old column nl &optional align-top)
- (cl-decf column company-tooltip-margin)
-
- (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 ((offset (and (< column 0) (- column)))
- new)
- (when offset
- (setq column 0))
- (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)
- (company--offset-line (pop lines) offset)
- column)
- new))
- ;; Append whole new lines.
- (while lines
- (push (concat (company-space-string column)
- (company--offset-line (pop lines) offset))
- new))
-
- (let ((str (concat (when nl " \n")
- (mapconcat 'identity (nreverse new) "\n")
- "\n")))
- (when nl (put-text-property 0 1 'cursor t str))
- str)))
-
-(defun company--offset-line (line offset)
- (if (and offset line)
- (substring line offset)
- line))
-
-(defun company--create-lines (selection limit)
- (let ((len company-candidates-length)
- (window-width (company--window-width))
- lines
- width
- lines-copy
- items
- previous
- remainder
- scrollbar-bounds)
-
- ;; Maybe clear old offset.
- (when (< len (+ company-tooltip-offset limit))
- (setq company-tooltip-offset 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))))))
-
- (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)
-
- (cl-decf window-width (* 2 company-tooltip-margin))
- (when scrollbar-bounds (cl-decf window-width))
-
- (dotimes (_ len)
- (let* ((value (pop lines-copy))
- (annotation (company-call-backend 'annotation value)))
- (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 (comment-string-strip annotation t nil))))
- (push (cons value annotation) items)
- (setq width (max (+ (length value)
- (if (and annotation company-tooltip-align-annotations)
- (1+ (length annotation))
- (length annotation)))
- width))))
-
- (setq width (min window-width
- company-tooltip-maximum-width
- (max company-tooltip-minimum-width
- (if company-show-numbers
- (+ 2 width)
- width))))
-
- (let ((items (nreverse items))
- (numbered (if company-show-numbers 0 99999))
- new)
- (when previous
- (push (company--scrollpos-line previous width) new))
-
- (dotimes (i len)
- (let* ((item (pop items))
- (str (car item))
- (annotation (cdr item))
- (margin (company-space-string company-tooltip-margin))
- (left margin)
- (right margin)
- (width width))
- (when (< numbered 10)
- (cl-decf width 2)
- (cl-incf numbered)
- (setf (if (eq company-show-numbers 'left) left right)
- (concat (funcall company-show-numbers-function numbered)
- margin)))
- (push (concat
- (company-fill-propertize str annotation
- width (equal i selection)
- left
- right)
- (when scrollbar-bounds
- (company--scrollbar i scrollbar-bounds)))
- new)))
-
- (when remainder
- (push (company--scrollpos-line remainder width) new))
-
- (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-scrollbar-fg
- 'company-scrollbar-bg)))
-
-(defun company--scrollpos-line (text width)
- (propertize (concat (company-space-string company-tooltip-margin)
- (company-safe-substring text 0 width)
- (company-space-string company-tooltip-margin))
- 'face 'company-tooltip))
-
-;; show
-
-(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))
-
- (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 (company--create-lines selection (abs height))))
- (overlay-put ov 'company-display
- (apply 'company--replacement-string lines 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 (company--create-lines selection (abs height))))
- (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
- (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 'after-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)
- ;; No (extra) prefix for the first line.
- (overlay-put ov 'line-prefix "")
- ;; `display' is better
- ;; (http://debbugs.gnu.org/18285, http://debbugs.gnu.org/20847),
- ;; but it doesn't work on 0-length overlays.
- (if (< (overlay-start ov) (overlay-end ov))
- (overlay-put ov 'display disp)
- (overlay-put ov 'after-string disp)
- (overlay-put ov 'invisible t))
- (overlay-put ov 'face 'default)
- (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))
- (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))
- (hide (company-pseudo-tooltip-hide)
- (setq company-tooltip-offset 0))
- (update (when (overlayp company-pseudo-tooltip-overlay)
- (company-pseudo-tooltip-edit company-selection)))))
-
-(defun company-pseudo-tooltip-unless-just-one-frontend (command)
- "`company-pseudo-tooltip-frontend', but not shown for single candidates."
- (unless (and (eq command 'post-command)
- (company--show-inline-p))
- (company-pseudo-tooltip-frontend 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-unless-just-one-frontend-with-delay
- 'post-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)
-
- (setq completion (copy-sequence (company--pre-render completion)))
- (font-lock-append-text-property 0 (length completion)
- 'face 'company-preview
- completion)
- (font-lock-prepend-text-property 0 (length company-common)
- 'face 'company-preview-common
- completion)
-
- ;; Add search string
- (and (string-match (funcall company-search-regexp-function
- company-search-string)
- completion)
- (pcase-dolist (`(,mbeg . ,mend) (company--search-chunks))
- (font-lock-prepend-text-property mbeg mend
- 'face 'company-preview-search
- completion)))
-
- (setq completion (company-strip-prefix completion))
-
- (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))
- (`post-command (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 (eq command 'post-command))
- (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 (eq command 'post-command))
- (company-preview-common--show-p))
- (pcase command
- (`pre-command (company-preview-hide))
- (`post-command (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)
- (when getter
- (setq company-echo-last-msg (funcall getter)))
- (let ((message-log-max nil)
- (message-truncate-lines company-echo-truncate-lines))
- (if company-echo-last-msg
- (message "%s" company-echo-last-msg)
- (message ""))))
-
-(defun company-echo-show-soon (&optional getter)
- (company-echo-cancel)
- (setq company-echo-timer (run-with-timer 0 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-show-when-idle (&optional getter)
- (company-echo-cancel)
- (setq company-echo-timer
- (run-with-idle-timer company-echo-delay nil 'company-echo-show getter)))
-
-(defun company-echo-format ()
-
- (let ((limit (window-body-width (minibuffer-window)))
- (len -1)
- ;; Roll to selection.
- (candidates (nthcdr company-selection company-candidates))
- (i (if company-show-numbers company-selection 99999))
- comp msg)
-
- (while candidates
- (setq comp (company-reformat (company--clean-string (pop candidates)))
- len (+ len 1 (length comp)))
- (if (< i 10)
- ;; Add number.
- (progn
- (setq comp (propertize (format "%d: %s" i comp)
- 'face 'company-echo))
- (cl-incf len 3)
- (cl-incf i)
- (add-text-properties 3 (+ 3 (string-width company-common))
- '(face company-echo-common) comp))
- (setq comp (propertize comp 'face 'company-echo))
- (add-text-properties 0 (string-width company-common)
- '(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 ((limit (window-body-width (minibuffer-window)))
- (len (+ (length company-prefix) 2))
- ;; Roll to selection.
- (candidates (nthcdr company-selection company-candidates))
- (i (if company-show-numbers company-selection 99999))
- msg comp)
-
- (while candidates
- (setq comp (company-strip-prefix (pop candidates))
- len (+ len 2 (length comp)))
- (when (< i 10)
- ;; Add number.
- (setq comp (format "%s (%d)" comp i))
- (cl-incf len 4)
- (cl-incf i))
- (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))
- (`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))
- (`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-when-idle 'company-fetch-metadata))
- (`hide (company-echo-hide))))
-
-(provide 'company)
-;;; company.el ends here
blob - c8e32cafd924c88445fd941371b614a990d764d7 (mode 644)
blob + /dev/null
Binary files elpa/company-0.9.13/company.elc and /dev/null differ
blob - 7e58682fe2f293359edc5c662d7e4ad6149941c6 (mode 644)
blob + /dev/null
--- elpa/company-prescient-5.1/company-prescient-autoloads.el
+++ /dev/null
-;;; company-prescient-autoloads.el --- automatically extracted autoloads
-;;
-;;; Code:
-
-(add-to-list 'load-path (directory-file-name
- (or (file-name-directory #$) (car load-path))))
-
-
-;;;### (autoloads nil "company-prescient" "company-prescient.el"
-;;;;;; (0 0 0 0))
-;;; Generated autoloads from company-prescient.el
-
-(defvar company-prescient-mode nil "\
-Non-nil if Company-Prescient mode is enabled.
-See the `company-prescient-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-prescient-mode'.")
-
-(custom-autoload 'company-prescient-mode "company-prescient" nil)
-
-(autoload 'company-prescient-mode "company-prescient" "\
-Minor mode to use prescient.el in Company completions.
-
-If called interactively, enable Company-Prescient mode if ARG is
-positive, and disable it if ARG is zero or negative. If called
-from Lisp, also enable the mode if ARG is omitted or nil, and
-toggle it if ARG is `toggle'; disable the mode otherwise.
-
-\(fn &optional ARG)" t nil)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-prescient" '("company-prescient-")))
-
-;;;***
-
-;; Local Variables:
-;; version-control: never
-;; no-byte-compile: t
-;; no-update-autoloads: t
-;; coding: utf-8
-;; End:
-;;; company-prescient-autoloads.el ends here
blob - c277cbc2ad7f4d59e4253ace826a67ee3860605c (mode 644)
blob + /dev/null
--- elpa/company-prescient-5.1/company-prescient-pkg.el
+++ /dev/null
-;;; Generated package description from company-prescient.el -*- no-byte-compile: t -*-
-(define-package "company-prescient" "5.1" "prescient.el + Company" '((emacs "25.1") (prescient "5.1") (company "0.9.6")) :commit "2c0e9fc061ab723ec532428f312974ca7d8def12" :authors '(("Radon Rosborough" . "radon.neon@gmail.com")) :maintainer '("Radon Rosborough" . "radon.neon@gmail.com") :keywords '("extensions") :url "https://github.com/raxod502/prescient.el")
blob - c52b8154a7db085a18799f019963d50003209d77 (mode 644)
blob + /dev/null
--- elpa/company-prescient-5.1/company-prescient.el
+++ /dev/null
-;;; company-prescient.el --- prescient.el + Company -*- lexical-binding: t -*-
-
-;; Copyright (C) 2018 Radon Rosborough
-
-;; Author: Radon Rosborough <radon.neon@gmail.com>
-;; Homepage: https://github.com/raxod502/prescient.el
-;; Keywords: extensions
-;; Package-Version: 5.1
-;; Package-Commit: 2c0e9fc061ab723ec532428f312974ca7d8def12
-;; Created: 7 May 2018
-;; Package-Requires: ((emacs "25.1") (prescient "5.1") (company "0.9.6"))
-;; SPDX-License-Identifier: MIT
-;; Version: 5.1
-
-;;; Commentary:
-
-;; company-prescient.el provides an interface for using prescient.el
-;; to sort Company completions. To enable its functionality, turn on
-;; `company-prescient-mode' in your init-file or interactively.
-
-;; Note that company-prescient.el does not change the filtering
-;; behavior of Company. This is because that can't be done without
-;; updating each Company backend individually.
-
-;; For more information, see https://github.com/raxod502/prescient.el.
-
-;;; Code:
-
-;;;; Libraries
-
-(require 'company)
-(require 'prescient)
-
-;;;; User options
-
-(defcustom company-prescient-sort-length-enable :default
- "Whether to sort candidates by length in Company.
-The value of `prescient-sort-length-enable' is bound to the value
-of this variable when sorting Company candidates. If the value of
-this variable is `:default', then this binding is skipped."
- :group 'prescient
- :type 'boolean)
-
-;;;; Minor mode
-
-(defun company-prescient-transformer (candidates)
- "Candidate transformer function that uses prescient.el to sort CANDIDATES.
-This is for use in `company-transformers'."
- (let ((prescient-sort-length-enable
- (if (eq company-prescient-sort-length-enable :default)
- prescient-sort-length-enable
- company-prescient-sort-length-enable)))
- (prescient-sort candidates)))
-
-(defalias 'company-prescient-completion-finished #'prescient-remember
- "Hook function to remember selected Company candidate.
-This is for use on `company-completion-finished-hook'.")
-
-;;;###autoload
-(define-minor-mode company-prescient-mode
- "Minor mode to use prescient.el in Company completions."
- :global t
- :group 'prescient
- (if company-prescient-mode
- (progn
- (company-prescient-mode -1)
- (setq company-prescient-mode t)
- (add-to-list 'company-transformers #'company-prescient-transformer)
- (add-hook 'company-completion-finished-hook
- #'company-prescient-completion-finished))
- (setq company-transformers
- (delq #'company-prescient-transformer company-transformers))
- (remove-hook 'company-completion-finished-hook
- #'company-prescient-completion-finished)))
-
-;;;; Closing remarks
-
-(provide 'company-prescient)
-
-;;; company-prescient.el ends here
-
-;; Local Variables:
-;; checkdoc-verb-check-experimental-flag: nil
-;; outline-regexp: ";;;;* "
-;; End:
blob - a7eb55e2d4007d440db2bc336f97f812f15c9555 (mode 644)
blob + /dev/null
Binary files elpa/company-prescient-5.1/company-prescient.elc and /dev/null differ
blob - /dev/null
blob + 94a9ed024d3859793618152ea559a168bbcbb5e2 (mode 644)
--- /dev/null
+++ elpa/corfu-0.16/LICENSE
+ GNU GENERAL PUBLIC LICENSE
+ Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+ The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works. By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users. We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors. You can apply it to
+your programs, too.
+
+ When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+ To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights. Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+ For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received. You must make sure that they, too, receive
+or can get the source code. And you must show them these terms so they
+know their rights.
+
+ Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+ For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software. For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+ Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so. This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software. The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable. Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products. If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+ Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary. To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+ The precise terms and conditions for copying, distribution and
+modification follow.
+
+ TERMS AND CONDITIONS
+
+ 0. Definitions.
+
+ "This License" refers to version 3 of the GNU General Public License.
+
+ "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+ "The Program" refers to any copyrightable work licensed under this
+License. Each licensee is addressed as "you". "Licensees" and
+"recipients" may be individuals or organizations.
+
+ To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy. The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+ A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+ To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy. Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+ To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies. Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+ An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License. If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+ 1. Source Code.
+
+ The "source code" for a work means the preferred form of the work
+for making modifications to it. "Object code" means any non-source
+form of a work.
+
+ A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+ The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form. A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+ The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities. However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work. For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+ The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+ The Corresponding Source for a work in source code form is that
+same work.
+
+ 2. Basic Permissions.
+
+ All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met. This License explicitly affirms your unlimited
+permission to run the unmodified Program. The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work. This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+ You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force. You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright. Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+ Conveying under any other circumstances is permitted solely under
+the conditions stated below. Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+ 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+ No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+ When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+ 4. Conveying Verbatim Copies.
+
+ You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+ You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+ 5. Conveying Modified Source Versions.
+
+ You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+ a) The work must carry prominent notices stating that you modified
+ it, and giving a relevant date.
+
+ b) The work must carry prominent notices stating that it is
+ released under this License and any conditions added under section
+ 7. This requirement modifies the requirement in section 4 to
+ "keep intact all notices".
+
+ c) You must license the entire work, as a whole, under this
+ License to anyone who comes into possession of a copy. This
+ License will therefore apply, along with any applicable section 7
+ additional terms, to the whole of the work, and all its parts,
+ regardless of how they are packaged. This License gives no
+ permission to license the work in any other way, but it does not
+ invalidate such permission if you have separately received it.
+
+ d) If the work has interactive user interfaces, each must display
+ Appropriate Legal Notices; however, if the Program has interactive
+ interfaces that do not display Appropriate Legal Notices, your
+ work need not make them do so.
+
+ A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit. Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+ 6. Conveying Non-Source Forms.
+
+ You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+ a) Convey the object code in, or embodied in, a physical product
+ (including a physical distribution medium), accompanied by the
+ Corresponding Source fixed on a durable physical medium
+ customarily used for software interchange.
+
+ b) Convey the object code in, or embodied in, a physical product
+ (including a physical distribution medium), accompanied by a
+ written offer, valid for at least three years and valid for as
+ long as you offer spare parts or customer support for that product
+ model, to give anyone who possesses the object code either (1) a
+ copy of the Corresponding Source for all the software in the
+ product that is covered by this License, on a durable physical
+ medium customarily used for software interchange, for a price no
+ more than your reasonable cost of physically performing this
+ conveying of source, or (2) access to copy the
+ Corresponding Source from a network server at no charge.
+
+ c) Convey individual copies of the object code with a copy of the
+ written offer to provide the Corresponding Source. This
+ alternative is allowed only occasionally and noncommercially, and
+ only if you received the object code with such an offer, in accord
+ with subsection 6b.
+
+ d) Convey the object code by offering access from a designated
+ place (gratis or for a charge), and offer equivalent access to the
+ Corresponding Source in the same way through the same place at no
+ further charge. You need not require recipients to copy the
+ Corresponding Source along with the object code. If the place to
+ copy the object code is a network server, the Corresponding Source
+ may be on a different server (operated by you or a third party)
+ that supports equivalent copying facilities, provided you maintain
+ clear directions next to the object code saying where to find the
+ Corresponding Source. Regardless of what server hosts the
+ Corresponding Source, you remain obligated to ensure that it is
+ available for as long as needed to satisfy these requirements.
+
+ e) Convey the object code using peer-to-peer transmission, provided
+ you inform other peers where the object code and Corresponding
+ Source of the work are being offered to the general public at no
+ charge under subsection 6d.
+
+ A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+ A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling. In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage. For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product. A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+ "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source. The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+ If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information. But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+ The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed. Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+ Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+ 7. Additional Terms.
+
+ "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law. If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+ When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it. (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.) You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+ Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+ a) Disclaiming warranty or limiting liability differently from the
+ terms of sections 15 and 16 of this License; or
+
+ b) Requiring preservation of specified reasonable legal notices or
+ author attributions in that material or in the Appropriate Legal
+ Notices displayed by works containing it; or
+
+ c) Prohibiting misrepresentation of the origin of that material, or
+ requiring that modified versions of such material be marked in
+ reasonable ways as different from the original version; or
+
+ d) Limiting the use for publicity purposes of names of licensors or
+ authors of the material; or
+
+ e) Declining to grant rights under trademark law for use of some
+ trade names, trademarks, or service marks; or
+
+ f) Requiring indemnification of licensors and authors of that
+ material by anyone who conveys the material (or modified versions of
+ it) with contractual assumptions of liability to the recipient, for
+ any liability that these contractual assumptions directly impose on
+ those licensors and authors.
+
+ All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10. If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term. If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+ If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+ Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+ 8. Termination.
+
+ You may not propagate or modify a covered work except as expressly
+provided under this License. Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+ However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+ Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+ Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License. If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+ 9. Acceptance Not Required for Having Copies.
+
+ You are not required to accept this License in order to receive or
+run a copy of the Program. Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance. However,
+nothing other than this License grants you permission to propagate or
+modify any covered work. These actions infringe copyright if you do
+not accept this License. Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+ 10. Automatic Licensing of Downstream Recipients.
+
+ Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License. You are not responsible
+for enforcing compliance by third parties with this License.
+
+ An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations. If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+ You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License. For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+ 11. Patents.
+
+ A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based. The
+work thus licensed is called the contributor's "contributor version".
+
+ A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version. For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+ Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+ In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement). To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+ If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients. "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+ If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+ A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License. You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+ Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+ 12. No Surrender of Others' Freedom.
+
+ If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all. For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+ 13. Use with the GNU Affero General Public License.
+
+ Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work. The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+ 14. Revised Versions of this License.
+
+ The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+ Each version is given a distinguishing version number. If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation. If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+ If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+ Later license versions may give you additional or different
+permissions. However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+ 15. Disclaimer of Warranty.
+
+ THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+ 16. Limitation of Liability.
+
+ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+ 17. Interpretation of Sections 15 and 16.
+
+ If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Programs
+
+ If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+ To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the program's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ 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 <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+ If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+ <program> Copyright (C) <year> <name of author>
+ This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+ This is free software, and you are welcome to redistribute it
+ under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License. Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+ You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+ The GNU General Public License does not permit incorporating your program
+into proprietary programs. If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library. If this is what you want to do, use the GNU Lesser General
+Public License instead of this License. But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
blob - /dev/null
blob + f26d5e8524d63aa16b057a20d432fd56aff722f3 (mode 644)
--- /dev/null
+++ elpa/corfu-0.16/README.org
+#+title: corfu.el - Completion Overlay Region FUnction
+#+author: Daniel Mendler
+#+language: en
+#+export_file_name: corfu.texi
+#+texinfo_dir_category: Emacs
+#+texinfo_dir_title: Corfu: (corfu).
+#+texinfo_dir_desc: Completion Overlay Region FUnction
+
+#+html: <a href="https://www.gnu.org/software/emacs/"><img alt="GNU Emacs" src="https://github.com/minad/corfu/blob/screenshots/emacs.svg?raw=true"/></a>
+#+html: <a href="http://elpa.gnu.org/packages/corfu.html"><img alt="GNU ELPA" src="https://elpa.gnu.org/packages/corfu.svg"/></a>
+#+html: <a href="http://elpa.gnu.org/devel/corfu.html"><img alt="GNU-devel ELPA" src="https://elpa.gnu.org/devel/corfu.svg"/></a>
+
+* Introduction
+
+ Corfu enhances the default completion in region function with a completion
+ overlay. The current candidates are shown in a popup below or above the point.
+ Corfu is the minimalistic ~completion-in-region~ counterpart of the [[https://github.com/minad/vertico][Vertico]]
+ minibuffer UI.
+
+ Corfu is a minimal package, which relies on the Emacs completion facilities and
+ concentrates on providing a polished completion UI. Completions are either
+ provided by commands like ~dabbrev-completion~ or by pluggable backends
+ (~completion-at-point-functions~, Capfs). Most programming language major modes
+ implement a Capf. Furthermore the language server packages, [[https://github.com/joaotavora/eglot][Eglot]] and [[https://github.com/emacs-lsp/lsp-mode][Lsp-mode]],
+ both use Capfs which talk to the LSP server to retrieve the completions.
+
+ Corfu does not include custom completion backends. In contrast, the complex
+ Company package includes custom completion backends, which deviate from the
+ Emacs completion infrastructure. The Emacs built-in Capfs are mostly
+ sufficient, but a few additional Capfs and completion functions are provided
+ by the [[https://github.com/minad/cape][Cape]] package.
+
+ *NOTE*: Corfu uses child frames to show the popup; on non-graphical displays it
+ will fall back to the default setting of the ~completion-in-region-function~.
+
+ [[https://github.com/minad/corfu/blob/screenshots/light.png?raw=true]]
+
+ [[https://github.com/minad/corfu/blob/screenshots/dark.png?raw=true]]
+
+* Features
+
+ - Timer-based auto-completions (/off/ by default, set ~corfu-auto~).
+ - Popup display with scrollbar indicator and arrow key navigation.
+ - The popup can be summoned explicitly by pressing =TAB= at any time.
+ - The current candidate is inserted with =TAB= and selected with =RET=.
+ - Candidates sorting by prefix, string length and alphabetically.
+ - The selected candidate is previewed (configuable via ~corfu-preview-current~).
+ - The selected candidate automatically committed on further input by default
+ (configurable via ~corfu-commit-predicate~).
+ - The [[https://github.com/oantolin/orderless][Orderless]] completion style is supported. The filter string can contain
+ arbitrary characters, including spaces, if ~corfu-quit-at-boundary~ is nil.
+ - Deferred completion style highlighting for performance.
+ - Jumping to location/documentation of current candidate.
+ - Show candidate documentation/signature string in the echo area.
+ - Deprecated candidates are crossed out in the display.
+ - Support for annotations (~annotation-function~, ~affixation-function~).
+ - Icons can be provided by an external package via margin formatter functions.
+
+* Installation and Configuration
+
+ Corfu is available from [[http://elpa.gnu.org/packages/corfu.html][GNU ELPA]], such that it can be installed directly via
+ ~package-install~. After installation, the global minor mode can be enabled with
+ =M-x corfu-global-mode=. In order to configure Corfu and other packages in your
+ init.el, you may want to use ~use-package~.
+
+ Corfu is highly flexible and customizable via ~corfu-*~ customization variables.
+ For filtering I recommend to give Orderless completion a try, which is
+ different from the familiar prefix TAB completion. Corfu can be used with the
+ default completion styles, the use of Orderless is not a necessity. See also
+ the [[https://github.com/minad/corfu/wiki][Corfu Wiki]] for additional configuration tips. In particular the Lsp-mode
+ configuration is documented in the Wiki.
+
+ Here is an example configuration:
+
+ #+begin_src emacs-lisp
+ (use-package corfu
+ ;; Optional customizations
+ ;; :custom
+ ;; (corfu-cycle t) ;; Enable cycling for `corfu-next/previous'
+ ;; (corfu-auto t) ;; Enable auto completion
+ ;; (corfu-commit-predicate nil) ;; Do not commit selected candidates on next input
+ ;; (corfu-quit-at-boundary t) ;; Automatically quit at word boundary
+ ;; (corfu-quit-no-match t) ;; Automatically quit if there is no match
+ ;; (corfu-preview-current nil) ;; Disable current candidate preview
+ ;; (corfu-preselect-first nil) ;; Disable candidate preselection
+ ;; (corfu-echo-documentation nil) ;; Disable documentation in the echo area
+ ;; (corfu-scroll-margin 5) ;; Use scroll margin
+
+ ;; You may want to enable Corfu only for certain modes.
+ ;; :hook ((prog-mode . corfu-mode)
+ ;; (shell-mode . corfu-mode)
+ ;; (eshell-mode . corfu-mode))
+
+ ;; Recommended: Enable Corfu globally.
+ ;; This is recommended since dabbrev can be used globally (M-/).
+ :init
+ (corfu-global-mode))
+
+ ;; Optionally use the `orderless' completion style. See `+orderless-dispatch'
+ ;; in the Consult wiki for an advanced Orderless style dispatcher.
+ ;; Enable `partial-completion' for files to allow path expansion.
+ ;; You may prefer to use `initials' instead of `partial-completion'.
+ (use-package orderless
+ :init
+ ;; Configure a custom style dispatcher (see the Consult wiki)
+ ;; (setq orderless-style-dispatchers '(+orderless-dispatch)
+ ;; orderless-component-separator #'orderless-escapable-split-on-space)
+ (setq completion-styles '(orderless)
+ completion-category-defaults nil
+ completion-category-overrides '((file (styles . (partial-completion))))))
+
+ ;; Use dabbrev with Corfu!
+ (use-package dabbrev
+ ;; Swap M-/ and C-M-/
+ :bind (("M-/" . dabbrev-completion)
+ ("C-M-/" . dabbrev-expand)))
+
+ ;; A few more useful configurations...
+ (use-package emacs
+ :init
+ ;; TAB cycle if there are only few candidates
+ (setq completion-cycle-threshold 3)
+
+ ;; Emacs 28: Hide commands in M-x which do not apply to the current mode.
+ ;; Corfu commands are hidden, since they are not supposed to be used via M-x.
+ ;; (setq read-extended-command-predicate
+ ;; #'command-completion-default-include-p)
+
+ ;; Enable indentation+completion using the TAB key.
+ ;; `completion-at-point' is often bound to M-TAB.
+ (setq tab-always-indent 'complete))
+ #+end_src
+
+** TAB-and-Go completion
+
+You may be interested in configuring Corfu in TAB-and-Go style. Pressing TAB
+moves to the next candidate and further input will then commit the selection.
+
+#+begin_src emacs-lisp
+ (use-package corfu
+ ;; TAB-and-Go customizations
+ :custom
+ (corfu-cycle t) ;; Enable cycling for `corfu-next/previous'
+ (corfu-preselect-first nil) ;; Disable candidate preselection
+
+ ;; Use TAB for cycling, default is `corfu-complete'.
+ :bind
+ (:map corfu-map
+ ("TAB" . corfu-next)
+ ([tab] . corfu-next)
+ ("S-TAB" . corfu-previous)
+ ([backtab] . corfu-previous))
+
+ :init
+ (corfu-global-mode))
+#+end_src
+
+* Key bindings
+
+ Corfu uses a transient keymap ~corfu-map~ which is active while the popup is shown.
+ The keymap defines the following remappings and bindings:
+
+ - ~beginning-of-buffer~ -> ~corfu-first~
+ - ~end-of-buffer~ -> ~corfu-last~
+ - ~scroll-down-command~ -> ~corfu-scroll-down~
+ - ~scroll-up-command~ -> ~corfu-scroll-up~
+ - ~next-line~, =down=, =M-n= -> ~corfu-next~
+ - ~previous-line~, =up=, =M-p= -> ~corfu-previous~
+ - ~completion-at-point~, =TAB= -> ~corfu-complete~
+ - =RET= -> ~corfu-insert~
+ - =M-g= -> ~corfu-show-location~
+ - =M-h= -> ~corfu-show-documentation~
+ - =C-g= -> ~corfu-quit~
+ - ~keyboard-escape-quit~ -> ~corfu-reset~
+
+* Complementary packages
+
+ Corfu works well together with all packages providing code completion via the
+ ~completion-at-point-functions~. Furthermore it supports completion styles,
+ including the advanced [[https://github.com/oantolin/orderless][Orderless]] completion style, where the filtering
+ expressions are separated by spaces (see ~corfu-quit-at-boundary~).
+
+ I collect additional Capf backends and =completion-in-region= commands in my
+ small [[https://github.com/minad/cape][Cape]] package. For example the package provides a file name and a dabbrev
+ completion backend.
+
+ Icons are supported by Corfu via an external package. For example the
+ [[https://github.com/jdtsmith/kind-icon][kind-icon]] package provides beautifully styled SVG icons based on monochromatic
+ icon sets like material design.
+
+ You may also want to look into my [[https://github.com/minad/vertico][Vertico]] package. Vertico is the minibuffer
+ counterpart of Corfu.
+
+* Caveats
+
+ Corfu is robust in most scenarios. There are a few known technical caveats.
+
+ - Corfu falls back to the default Completion buffer on non-graphical displays,
+ since Corfu requires child frames.
+ - No sorting by history, since ~completion-at-point~ does not
+ maintain a history (See branch =history= for a possible solution).
+ - There is currently no equivalent for =company-quickhelp=. Documentation and source
+ can be opened manually in a separate buffer.
+ - Company has the ability to merge/group the candidates of multiple backends
+ in some scenarios. This feature is implemented by the function
+ ~cape-super-capf~ of the [[https://github.com/minad/cape][Cape]] package.
+
+* Contributions
+
+ Since this package is part of [[http://elpa.gnu.org/packages/corfu.html][GNU ELPA]] contributions require a copyright
+ assignment to the FSF.
blob - /dev/null
blob + 9647171fd7f5289e93cabc3f89da8486b9da225c (mode 644)
--- /dev/null
+++ elpa/corfu-0.16/corfu-autoloads.el
+;;; corfu-autoloads.el --- automatically extracted autoloads
+;;
+;;; Code:
+
+(add-to-list 'load-path (directory-file-name
+ (or (file-name-directory #$) (car load-path))))
+
+
+;;;### (autoloads nil "corfu" "corfu.el" (0 0 0 0))
+;;; Generated autoloads from corfu.el
+
+(autoload 'corfu-mode "corfu" "\
+Completion Overlay Region FUnction
+
+If called interactively, enable Corfu mode if ARG is positive,
+and disable it if ARG is zero or negative. If called from Lisp,
+also enable the mode if ARG is omitted or nil, and toggle it if
+ARG is `toggle'; disable the mode otherwise.
+
+\(fn &optional ARG)" t nil)
+
+(put 'corfu-global-mode 'globalized-minor-mode t)
+
+(defvar corfu-global-mode nil "\
+Non-nil if Corfu-Global mode is enabled.
+See the `corfu-global-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 `corfu-global-mode'.")
+
+(custom-autoload 'corfu-global-mode "corfu" nil)
+
+(autoload 'corfu-global-mode "corfu" "\
+Toggle Corfu mode in all buffers.
+With prefix ARG, enable Corfu-Global mode if ARG is positive;
+otherwise, disable it. If called from Lisp, enable the mode if
+ARG is omitted or nil.
+
+Corfu mode is enabled in all buffers where
+`corfu--on' would do it.
+See `corfu-mode' for more information on Corfu mode.
+
+\(fn &optional ARG)" t nil)
+
+(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "corfu" '("corfu-")))
+
+;;;***
+
+;;;### (autoloads nil nil ("corfu-pkg.el") (0 0 0 0))
+
+;;;***
+
+;; Local Variables:
+;; version-control: never
+;; no-byte-compile: t
+;; no-update-autoloads: t
+;; coding: utf-8
+;; End:
+;;; corfu-autoloads.el ends here
blob - /dev/null
blob + 8fef72b0ba5984685dc5a000ea1617763bac9b13 (mode 644)
--- /dev/null
+++ elpa/corfu-0.16/corfu-pkg.el
+;; Generated package description from corfu.el -*- no-byte-compile: t -*-
+(define-package "corfu" "0.16" "Completion Overlay Region FUnction" '((emacs "27.1")) :authors '(("Daniel Mendler" . "mail@daniel-mendler.de")) :maintainer '("Daniel Mendler" . "mail@daniel-mendler.de") :url "https://github.com/minad/corfu")
blob - /dev/null
blob + 8e4b3cdbfc5ed2f6a2debba570fd95c9396897c9 (mode 644)
--- /dev/null
+++ elpa/corfu-0.16/corfu.el
+;;; corfu.el --- Completion Overlay Region FUnction -*- lexical-binding: t -*-
+
+;; Copyright (C) 2021 Free Software Foundation, Inc.
+
+;; Author: Daniel Mendler <mail@daniel-mendler.de>
+;; Maintainer: Daniel Mendler <mail@daniel-mendler.de>
+;; Created: 2021
+;; Version: 0.16
+;; Package-Requires: ((emacs "27.1"))
+;; Homepage: https://github.com/minad/corfu
+
+;; This file is part of GNU Emacs.
+
+;; 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 <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Corfu enhances the default completion in region function with a
+;; completion overlay. The current candidates are shown in a popup
+;; below or above the point. Corfu can be considered the minimalistic
+;; completion-in-region counterpart of Vertico.
+
+;;; Code:
+
+(require 'seq)
+(eval-when-compile
+ (require 'cl-lib)
+ (require 'subr-x))
+
+(defgroup corfu nil
+ "Completion Overlay Region FUnction."
+ :group 'convenience
+ :prefix "corfu-")
+
+(defcustom corfu-count 10
+ "Maximal number of candidates to show."
+ :type 'integer)
+
+(defcustom corfu-scroll-margin 2
+ "Number of lines at the top and bottom when scrolling.
+The value should lie between 0 and corfu-count/2."
+ :type 'integer)
+
+(defcustom corfu-min-width 15
+ "Popup minimum width in characters."
+ :type 'integer)
+
+(defcustom corfu-max-width 100
+ "Popup maximum width in characters."
+ :type 'integer)
+
+(defcustom corfu-cycle nil
+ "Enable cycling for `corfu-next' and `corfu-previous'."
+ :type 'boolean)
+
+(defcustom corfu-continue-commands
+ ;; nil is undefined command
+ '(nil ignore completion-at-point universal-argument universal-argument-more digit-argument
+ "\\`corfu-" "\\`scroll-other-window")
+ "Continue Corfu completion after executing these commands."
+ :type '(repeat (choice regexp symbol)))
+
+(defcustom corfu-commit-predicate #'corfu-candidate-previewed-p
+ "Automatically commit if the predicate returns t."
+ :type '(choice (const nil) function))
+
+(defcustom corfu-preview-current t
+ "Preview currently selected candidate."
+ :type 'boolean)
+
+(defcustom corfu-preselect-first t
+ "Preselect first candidate."
+ :type 'boolean)
+
+(defcustom corfu-quit-at-boundary nil
+ "Automatically quit at completion field/word boundary.
+If automatic quitting is disabled, Orderless filter strings with spaces
+are allowed."
+ :type 'boolean)
+
+(defcustom corfu-quit-no-match 1.0
+ "Automatically quit if no matching candidate is found.
+If a floating point number, quit on no match only if the auto-started
+completion began less than that number of seconds ago."
+ :type '(choice boolean float))
+
+(defcustom corfu-excluded-modes nil
+ "List of modes excluded by `corfu-global-mode'."
+ :type '(repeat symbol))
+
+(defcustom corfu-left-margin-width 0.5
+ "Width of the left margin in units of the character width."
+ :type 'float)
+
+(defcustom corfu-right-margin-width 0.5
+ "Width of the right margin in units of the character width."
+ :type 'float)
+
+(defcustom corfu-bar-width 0.2
+ "Width of the bar in units of the character width."
+ :type 'float)
+
+(defcustom corfu-echo-documentation 0.5
+ "Show documentation string in the echo area after that number of seconds."
+ :type '(choice boolean float))
+
+(defcustom corfu-margin-formatters nil
+ "Registry for margin formatter functions.
+Each function of the list is called with the completion metadata as
+argument until an appropriate formatter is found. The function should
+return a formatter function, which takes the candidate string and must
+return a string, possibly an icon."
+ :type 'hook)
+
+(defcustom corfu-sort-function #'corfu-sort-length-alpha
+ "Default sorting function, used if no `display-sort-function' is specified."
+ :type `(choice
+ (const :tag "No sorting" nil)
+ (const :tag "By length and alpha" ,#'corfu-sort-length-alpha)
+ (function :tag "Custom function")))
+
+(defcustom corfu-auto-prefix 3
+ "Minimum length of prefix for auto completion.
+The completion backend can override this with
+:company-prefix-length."
+ :type 'integer)
+
+(defcustom corfu-auto-delay 0.2
+ "Delay for auto completion."
+ :type 'float)
+
+(defcustom corfu-auto-commands
+ '("self-insert-command\\'")
+ "Commands which initiate auto completion."
+ :type '(repeat (choice regexp symbol)))
+
+(defcustom corfu-auto nil
+ "Enable auto completion."
+ :type 'boolean)
+
+(defgroup corfu-faces nil
+ "Faces used by Corfu."
+ :group 'corfu
+ :group 'faces)
+
+(defface corfu-default
+ '((((class color) (min-colors 88) (background dark)) :background "#191a1b")
+ (((class color) (min-colors 88) (background light)) :background "#f0f0f0")
+ (t :background "gray"))
+ "Default face used for the popup, in particular the background and foreground color.")
+
+(defface corfu-current
+ '((((class color) (min-colors 88) (background dark))
+ :background "#00415e" :foreground "white")
+ (((class color) (min-colors 88) (background light))
+ :background "#c0efff" :foreground "black")
+ (t :background "blue" :foreground "white"))
+ "Face used to highlight the currently selected candidate.")
+
+(defface corfu-bar
+ '((((class color) (min-colors 88) (background dark)) :background "#a8a8a8")
+ (((class color) (min-colors 88) (background light)) :background "#505050")
+ (t :background "gray"))
+ "The background color is used for the scrollbar indicator.")
+
+(defface corfu-border
+ '((((class color) (min-colors 88) (background dark)) :background "#323232")
+ (((class color) (min-colors 88) (background light)) :background "#d7d7d7")
+ (t :background "gray"))
+ "The background color used for the thin border.")
+
+(defface corfu-echo
+ '((t :inherit completions-annotations))
+ "Face used for echo area messages.")
+
+(defface corfu-annotations
+ '((t :inherit completions-annotations))
+ "Face used for annotations.")
+
+(defface corfu-deprecated
+ '((t :inherit shadow :strike-through t))
+ "Face used for deprecated candidates.")
+
+(defvar corfu-map
+ (let ((map (make-sparse-keymap)))
+ (define-key map [remap beginning-of-buffer] #'corfu-first)
+ (define-key map [remap end-of-buffer] #'corfu-last)
+ (define-key map [remap scroll-down-command] #'corfu-scroll-down)
+ (define-key map [remap scroll-up-command] #'corfu-scroll-up)
+ (define-key map [remap next-line] #'corfu-next)
+ (define-key map [remap previous-line] #'corfu-previous)
+ (define-key map [remap completion-at-point] #'corfu-complete)
+ (define-key map [down] #'corfu-next)
+ (define-key map [up] #'corfu-previous)
+ (define-key map [remap keyboard-escape-quit] #'corfu-reset)
+ ;; XXX [tab] is bound because of org-mode
+ ;; The binding should be removed from org-mode-map.
+ (define-key map [tab] #'corfu-complete)
+ (define-key map "\en" #'corfu-next)
+ (define-key map "\ep" #'corfu-previous)
+ (define-key map "\C-g" #'corfu-quit)
+ (define-key map "\r" #'corfu-insert)
+ (define-key map "\t" #'corfu-complete)
+ (define-key map "\eg" #'corfu-show-location)
+ (define-key map "\eh" #'corfu-show-documentation)
+ map)
+ "Corfu keymap used when popup is shown.")
+
+(defvar corfu--auto-timer nil
+ "Auto completion timer.")
+
+(defvar-local corfu--candidates nil
+ "List of candidates.")
+
+(defvar-local corfu--metadata nil
+ "Completion metadata.")
+
+(defvar-local corfu--base 0
+ "Size of the base string, which is concatenated with the candidate.")
+
+(defvar-local corfu--total 0
+ "Length of the candidate list `corfu--candidates'.")
+
+(defvar-local corfu--highlight #'identity
+ "Deferred candidate highlighting function.")
+
+(defvar-local corfu--index -1
+ "Index of current candidate or negative for prompt selection.")
+
+(defvar-local corfu--preselect -1
+ "Index of preselected candidate, negative for prompt selection.")
+
+(defvar-local corfu--scroll 0
+ "Scroll position.")
+
+(defvar-local corfu--input nil
+ "Cons of last prompt contents and point or t.")
+
+(defvar-local corfu--preview-ov nil
+ "Current candidate overlay.")
+
+(defvar-local corfu--extra nil
+ "Extra completion properties.")
+
+(defvar-local corfu--change-group nil
+ "Undo change group.")
+
+(defvar-local corfu--auto-start nil
+ "Auto completion start time.")
+
+(defvar-local corfu--echo-timer nil
+ "Echo area message timer.")
+
+(defvar-local corfu--echo-message nil
+ "Last echo message.")
+
+(defvar corfu--frame nil
+ "Popup frame.")
+
+(defconst corfu--state-vars
+ '(corfu--base
+ corfu--candidates
+ corfu--highlight
+ corfu--index
+ corfu--preselect
+ corfu--scroll
+ corfu--input
+ corfu--total
+ corfu--preview-ov
+ corfu--extra
+ corfu--auto-start
+ corfu--echo-timer
+ corfu--echo-message
+ corfu--change-group
+ corfu--metadata)
+ "Buffer-local state variables used by Corfu.")
+
+(defvar corfu--frame-parameters
+ '((no-accept-focus . t)
+ (no-focus-on-map . t)
+ (min-width . t)
+ (min-height . t)
+ (width . 0)
+ (height . 0)
+ (border-width . 0)
+ (child-frame-border-width . 1)
+ (left-fringe . 0)
+ (right-fringe . 0)
+ (vertical-scroll-bars . nil)
+ (horizontal-scroll-bars . nil)
+ (menu-bar-lines . 0)
+ (tool-bar-lines . 0)
+ (tab-bar-lines . 0)
+ (no-other-frame . t)
+ (no-other-window . t)
+ (no-delete-other-windows . t)
+ (unsplittable . t)
+ (undecorated . t)
+ (cursor-type . nil)
+ (visibility . nil)
+ (no-special-glyphs . t)
+ (desktop-dont-save . t))
+ "Default child frame parameters.")
+
+(defvar corfu--buffer-parameters
+ '((mode-line-format . nil)
+ (header-line-format . nil)
+ (tab-line-format . nil)
+ (tab-bar-format . nil) ;; Emacs 28 tab-bar-format
+ (frame-title-format . "")
+ (truncate-lines . t)
+ (cursor-in-non-selected-windows . nil)
+ (cursor-type . nil)
+ (show-trailing-whitespace . nil)
+ (display-line-numbers . nil)
+ (left-fringe-width . nil)
+ (right-fringe-width . nil)
+ (left-margin-width . 0)
+ (right-margin-width . 0)
+ (fringes-outside-margins . 0)
+ (buffer-read-only . t))
+ "Default child frame buffer parameters.")
+
+(defvar corfu--mouse-ignore-map
+ (let ((map (make-sparse-keymap)))
+ (dotimes (i 7)
+ (dolist (k '(mouse down-mouse drag-mouse double-mouse triple-mouse))
+ (define-key map (vector (intern (format "%s-%s" k (1+ i)))) #'ignore)))
+ map)
+ "Ignore all mouse clicks.")
+
+(defun corfu--popup-redirect-focus ()
+ "Redirect focus from popup."
+ (redirect-frame-focus corfu--frame (frame-parent corfu--frame)))
+
+(defun corfu--make-buffer (content)
+ "Create corfu buffer with CONTENT."
+ (let ((fr face-remapping-alist)
+ (buffer (get-buffer-create " *corfu*")))
+ (with-current-buffer buffer
+ ;;; XXX HACK install redirect focus hook
+ (add-hook 'pre-command-hook #'corfu--popup-redirect-focus nil 'local)
+ ;;; XXX HACK install mouse ignore map
+ (use-local-map corfu--mouse-ignore-map)
+ (dolist (var corfu--buffer-parameters)
+ (set (make-local-variable (car var)) (cdr var)))
+ (setq-local face-remapping-alist (copy-tree fr))
+ (cl-pushnew 'corfu-default (alist-get 'default face-remapping-alist))
+ (let ((inhibit-modification-hooks t)
+ (inhibit-read-only t))
+ (erase-buffer)
+ (insert content)
+ (goto-char (point-min))))
+ buffer))
+
+;; Function adapted from posframe.el by tumashu
+(defun corfu--make-frame (x y width height content)
+ "Show child frame at X/Y with WIDTH/HEIGHT and CONTENT."
+ (let* ((window-min-height 1)
+ (window-min-width 1)
+ (x-gtk-resize-child-frames
+ (let ((case-fold-search t))
+ (and
+ ;; XXX HACK to fix resizing on gtk3/gnome taken from posframe.el
+ ;; More information:
+ ;; * https://github.com/minad/corfu/issues/17
+ ;; * https://gitlab.gnome.org/GNOME/mutter/-/issues/840
+ ;; * https://lists.gnu.org/archive/html/emacs-devel/2020-02/msg00001.html
+ (string-match-p "gtk3" system-configuration-features)
+ (string-match-p "gnome\\|cinnamon" (or (getenv "XDG_CURRENT_DESKTOP")
+ (getenv "DESKTOP_SESSION") ""))
+ 'resize-mode)))
+ (after-make-frame-functions)
+ (edge (window-inside-pixel-edges))
+ (lh (default-line-height))
+ (x (max 0 (min (+ (car edge) x
+ (- (alist-get 'child-frame-border-width corfu--frame-parameters)))
+ (- (frame-pixel-width) width))))
+ (yb (+ (cadr edge) (window-tab-line-height) y lh))
+ (y (if (> (+ yb height lh lh) (frame-pixel-height))
+ (- yb height lh 1)
+ yb))
+ (buffer (corfu--make-buffer content)))
+ (unless (and (frame-live-p corfu--frame)
+ (eq (frame-parent corfu--frame) (window-frame)))
+ (when corfu--frame (delete-frame corfu--frame))
+ (setq corfu--frame (make-frame
+ `((parent-frame . ,(window-frame))
+ (minibuffer . ,(minibuffer-window (window-frame)))
+ (line-spacing . ,line-spacing)
+ ;; Set `internal-border-width' for Emacs 27
+ (internal-border-width
+ . ,(alist-get 'child-frame-border-width corfu--frame-parameters))
+ ,@corfu--frame-parameters))))
+ ;; XXX HACK Setting the same frame-parameter/face-background is not a nop (BUG!).
+ ;; Check explicitly before applying the setting.
+ ;; Without the check, the frame flickers on Mac.
+ ;; XXX HACK We have to apply the face background before adjusting the frame parameter,
+ ;; otherwise the border is not updated (BUG!).
+ (let* ((face (if (facep 'child-frame-border) 'child-frame-border 'internal-border))
+ (new (face-attribute 'corfu-border :background nil 'default)))
+ (unless (equal (face-attribute face :background corfu--frame 'default) new)
+ (set-face-background face new corfu--frame)))
+ (let ((new (face-attribute 'corfu-default :background nil 'default)))
+ (unless (equal (frame-parameter corfu--frame 'background-color) new)
+ (set-frame-parameter corfu--frame 'background-color new)))
+ (let ((win (frame-root-window corfu--frame)))
+ (set-window-buffer win buffer)
+ ;; Mark window as dedicated to prevent frame reuse (#60)
+ (set-window-dedicated-p win t))
+ ;; XXX HACK Make the frame invisible before moving the popup in order to avoid flicker.
+ (unless (eq (cdr (frame-position corfu--frame)) y)
+ (make-frame-invisible corfu--frame))
+ (set-frame-position corfu--frame x y)
+ (set-frame-size corfu--frame width height t)
+ (make-frame-visible corfu--frame)))
+
+(defun corfu--popup-show (pos off width lines &optional curr lo bar)
+ "Show LINES as popup at POS - OFF.
+WIDTH is the width of the popup.
+The current candidate CURR is highlighted.
+A scroll bar is displayed from LO to LO+BAR."
+ (let* ((ch (default-line-height))
+ (cw (default-font-width))
+ (lm (ceiling (* cw corfu-left-margin-width)))
+ (rm (ceiling (* cw corfu-right-margin-width)))
+ (bw (ceiling (min rm (* cw corfu-bar-width))))
+ (lmargin (and (> lm 0) (propertize " " 'display `(space :width (,lm)))))
+ (rmargin (and (> rm 0) (propertize " " 'display `(space :align-to right))))
+ (sbar (when (> bw 0)
+ (concat (propertize " " 'display `(space :align-to (- right (,rm))))
+ (propertize " " 'display `(space :width (,(- rm bw))))
+ (propertize " " 'face 'corfu-bar 'display `(space :width (,bw))))))
+ (row 0)
+ (pos (posn-x-y (posn-at-point pos)))
+ (x (or (car pos) 0))
+ (y (or (cdr pos) 0)))
+ (corfu--make-frame
+ (- x lm (* cw off)) y
+ (+ (* width cw) lm rm) (* (length lines) ch)
+ (mapconcat (lambda (line)
+ (let ((str (concat lmargin line
+ (if (and lo (<= lo row (+ lo bar))) sbar rmargin))))
+ (when (eq row curr)
+ (add-face-text-property
+ 0 (length str) 'corfu-current 'append str))
+ (setq row (1+ row))
+ str))
+ lines "\n"))))
+
+(defun corfu--popup-hide ()
+ "Hide Corfu popup."
+ (when (frame-live-p corfu--frame)
+ (make-frame-invisible corfu--frame)
+ (with-current-buffer (window-buffer (frame-root-window corfu--frame))
+ (let ((inhibit-read-only t))
+ (erase-buffer)))))
+
+(defun corfu--move-to-front (elem list)
+ "Move ELEM to front of LIST."
+ (if-let (found (member elem list))
+ (let ((head (list (car found))))
+ (nconc head (delq (setcar found nil) list)))
+ list))
+
+;; bug#47711: Deferred highlighting for `completion-all-completions'
+;; XXX There is one complication: `completion--twq-all' already adds `completions-common-part'.
+(defun corfu--all-completions (&rest args)
+ "Compute all completions for ARGS with deferred highlighting."
+ (cl-letf* ((orig-pcm (symbol-function #'completion-pcm--hilit-commonality))
+ (orig-flex (symbol-function #'completion-flex-all-completions))
+ ((symbol-function #'completion-flex-all-completions)
+ (lambda (&rest args)
+ ;; Unfortunately for flex we have to undo the deferred highlighting, since flex uses
+ ;; the completion-score for sorting, which is applied during highlighting.
+ (cl-letf (((symbol-function #'completion-pcm--hilit-commonality) orig-pcm))
+ (apply orig-flex args))))
+ ;; Defer the following highlighting functions
+ (hl #'identity)
+ ((symbol-function #'completion-hilit-commonality)
+ (lambda (cands prefix &optional base)
+ (setq hl (lambda (x) (nconc (completion-hilit-commonality x prefix base) nil)))
+ (and cands (nconc cands base))))
+ ((symbol-function #'completion-pcm--hilit-commonality)
+ (lambda (pattern cands)
+ (setq hl (lambda (x)
+ ;; `completion-pcm--hilit-commonality' sometimes throws an internal error
+ ;; for example when entering "/sudo:://u".
+ (condition-case nil
+ (completion-pcm--hilit-commonality pattern x)
+ (t x))))
+ cands)))
+ ;; Only advise orderless after it has been loaded to avoid load order issues
+ (if (and (fboundp 'orderless-highlight-matches) (fboundp 'orderless-pattern-compiler))
+ (cl-letf (((symbol-function 'orderless-highlight-matches)
+ (lambda (pattern cands)
+ (let ((regexps (orderless-pattern-compiler pattern)))
+ (setq hl (lambda (x) (orderless-highlight-matches regexps x))))
+ cands)))
+ (cons (apply #'completion-all-completions args) hl))
+ (cons (apply #'completion-all-completions args) hl))))
+
+(defun corfu--sort-predicate (x y)
+ "Sorting predicate which compares X and Y."
+ (or (< (length x) (length y)) (and (= (length x) (length y)) (string< x y))))
+
+(defun corfu-sort-length-alpha (list)
+ "Sort LIST by length and alphabetically."
+ (sort list #'corfu--sort-predicate))
+
+(defmacro corfu--partition! (list form)
+ "Evaluate FORM for every element and partition LIST."
+ (let ((head1 (make-symbol "head1"))
+ (head2 (make-symbol "head2"))
+ (tail1 (make-symbol "tail1"))
+ (tail2 (make-symbol "tail2")))
+ `(let* ((,head1 (cons nil nil))
+ (,head2 (cons nil nil))
+ (,tail1 ,head1)
+ (,tail2 ,head2))
+ (while ,list
+ (if (let ((it (car ,list))) ,form)
+ (progn
+ (setcdr ,tail1 ,list)
+ (pop ,tail1))
+ (setcdr ,tail2 ,list)
+ (pop ,tail2))
+ (pop ,list))
+ (setcdr ,tail1 (cdr ,head2))
+ (setcdr ,tail2 nil)
+ (setq ,list (cdr ,head1)))))
+
+(defun corfu--move-prefix-candidates-to-front (field candidates)
+ "Move CANDIDATES which match prefix of FIELD to the beginning."
+ (let* ((word (replace-regexp-in-string " .*" "" field))
+ (len (length word)))
+ (corfu--partition! candidates
+ (and (>= (length it) len)
+ (eq t (compare-strings word 0 len it 0 len))))))
+
+(defun corfu--filter-files (files)
+ "Filter FILES by `completion-ignored-extensions'."
+ (let ((re (concat "\\(?:\\(?:\\`\\|/\\)\\.\\.?/\\|"
+ (regexp-opt completion-ignored-extensions)
+ "\\)\\'")))
+ (or (seq-remove (lambda (x) (string-match-p re x)) files) files)))
+
+(defun corfu--sort-function ()
+ "Return the sorting function."
+ (or (corfu--metadata-get 'display-sort-function) corfu-sort-function))
+
+(defun corfu--recompute-candidates (str pt table pred)
+ "Recompute candidates from STR, PT, TABLE and PRED."
+ (pcase-let* ((before (substring str 0 pt))
+ (after (substring str pt))
+ (corfu--metadata (completion-metadata before table pred))
+ ;; bug#47678: `completion-boundaries` fails for `partial-completion`
+ ;; if the cursor is moved between the slashes of "~//".
+ ;; See also vertico.el which has the same issue.
+ (bounds (or (condition-case nil
+ (completion-boundaries before table pred after)
+ (t (cons 0 (length after))))))
+ (field (substring str (car bounds) (+ pt (cdr bounds))))
+ (completing-file (eq (corfu--metadata-get 'category) 'file))
+ (`(,all . ,hl) (corfu--all-completions str table pred pt corfu--metadata))
+ (base (or (when-let (z (last all)) (prog1 (cdr z) (setcdr z nil))) 0)))
+ ;; Filter the ignored file extensions. We cannot use modified predicate for this filtering,
+ ;; since this breaks the special casing in the `completion-file-name-table' for `file-exists-p'
+ ;; and `file-directory-p'.
+ (when completing-file (setq all (corfu--filter-files all)))
+ (setq all (funcall (or (corfu--sort-function) #'identity) all))
+ (unless (equal field "")
+ (setq all (corfu--move-prefix-candidates-to-front field all))
+ (when (and completing-file (not (string-suffix-p "/" field)))
+ (setq all (corfu--move-to-front (concat field "/") all)))
+ (setq all (corfu--move-to-front field all)))
+ (list base all (length all) hl corfu--metadata
+ ;; Select the prompt when the input is a valid completion
+ ;; and if it is not equal to the first candidate.
+ (if (or (not corfu-preselect-first) (not all)
+ (and (not (equal field (car all)))
+ (not (and completing-file (equal (concat field "/") (car all))))
+ (test-completion str table pred)))
+ -1 0))))
+
+(defun corfu--update-candidates (str pt table pred)
+ "Update candidates from STR, PT, TABLE and PRED."
+ ;; Redisplay such that the input becomes immediately visible before the
+ ;; expensive candidate recomputation is performed (Issue #48). See also
+ ;; corresponding vertico#89.
+ (redisplay)
+ (pcase (while-no-input (corfu--recompute-candidates str pt table pred))
+ ('nil (keyboard-quit))
+ (`(,base ,candidates ,total ,hl ,metadata ,preselect)
+ (setq corfu--input (cons str pt)
+ corfu--candidates candidates
+ corfu--base base
+ corfu--total total
+ corfu--preselect preselect
+ corfu--index preselect
+ corfu--highlight hl
+ corfu--metadata metadata))))
+
+(defun corfu--match-symbol-p (pattern sym)
+ "Return non-nil if SYM is matching an element of the PATTERN list."
+ (and (symbolp sym)
+ (cl-loop for x in pattern
+ thereis (if (symbolp x)
+ (eq sym x)
+ (string-match-p x (symbol-name sym))))))
+
+(defun corfu-quit ()
+ "Quit Corfu completion."
+ (interactive)
+ (completion-in-region-mode -1))
+
+(defun corfu-reset ()
+ "Reset Corfu completion.
+This command can be executed multiple times by hammering the ESC key. If a
+candidate is selected, unselect the candidate. Otherwise reset the input. If
+there hasn't been any input, then quit."
+ (interactive)
+ (if (/= corfu--index corfu--preselect)
+ (progn
+ (corfu--goto -1)
+ (setq this-command #'corfu-first))
+ ;; Cancel all changes and start new change group.
+ (cancel-change-group corfu--change-group)
+ (activate-change-group (setq corfu--change-group (prepare-change-group)))
+ (when (eq last-command #'corfu-reset) (corfu-quit))))
+
+(defun corfu--affixate (cands)
+ "Annotate CANDS with annotation function."
+ (setq cands
+ (if-let (aff (or (corfu--metadata-get 'affixation-function)
+ (plist-get corfu--extra :affixation-function)))
+ (funcall aff cands)
+ (if-let (ann (or (corfu--metadata-get 'annotation-function)
+ (plist-get corfu--extra :annotation-function)))
+ (cl-loop for cand in cands collect
+ (let ((suffix (or (funcall ann cand) "")))
+ (list cand ""
+ ;; The default completion UI adds the `completions-annotations' face
+ ;; if no other faces are present. We use a custom `corfu-annotations'
+ ;; face to allow further styling which fits better for popups.
+ (if (text-property-not-all 0 (length suffix) 'face nil suffix)
+ suffix
+ (propertize suffix 'face 'corfu-annotations)))))
+ (cl-loop for cand in cands collect (list cand "" "")))))
+ (let* ((dep (plist-get corfu--extra :company-deprecated))
+ (completion-extra-properties corfu--extra)
+ (mf (run-hook-with-args-until-success 'corfu-margin-formatters corfu--metadata)))
+ (cl-loop for x in cands for (c . _) = x do
+ (when mf
+ (setf (cadr x) (funcall mf c)))
+ (when (and dep (funcall dep c))
+ (setcar x (setq c (substring c)))
+ (add-face-text-property 0 (length c) 'corfu-deprecated 'append c)))
+ (cons mf cands)))
+
+(defun corfu--metadata-get (prop)
+ "Return PROP from completion metadata."
+ ;; Note: Do not use `completion-metadata-get' in order to avoid Marginalia.
+ ;; The Marginalia annotators are too heavy for the Corfu popup!
+ (cdr (assq prop corfu--metadata)))
+
+(defun corfu--format-candidates (cands)
+ "Format annotated CANDS."
+ (setq cands
+ (cl-loop for c in cands collect
+ (cl-loop for s in c collect
+ (replace-regexp-in-string "[ \t]*\n[ \t]*" " " s))))
+ (let* ((cw (cl-loop for x in cands maximize (string-width (car x))))
+ (pw (cl-loop for x in cands maximize (string-width (cadr x))))
+ (sw (cl-loop for x in cands maximize (string-width (caddr x))))
+ (width (+ pw cw sw)))
+ (when (< width corfu-min-width)
+ (setq cw (+ cw (- corfu-min-width width))
+ width corfu-min-width))
+ ;; -4 because of margins and some additional safety
+ (setq width (min width corfu-max-width (- (frame-width) 4)))
+ (list pw width
+ (cl-loop for (cand prefix suffix) in cands collect
+ (truncate-string-to-width
+ (concat prefix
+ (make-string (- pw (string-width prefix)) ?\s)
+ cand
+ (when (/= sw 0)
+ (make-string (+ (- cw (string-width cand))
+ (- sw (string-width suffix)))
+ ?\s))
+ suffix)
+ width)))))
+
+(defun corfu--update-scroll ()
+ "Update scroll position."
+ (let ((off (max (min corfu-scroll-margin (/ corfu-count 2)) 0))
+ (corr (if (= corfu-scroll-margin (/ corfu-count 2)) (1- (mod corfu-count 2)) 0)))
+ (setq corfu--scroll (min (max 0 (- corfu--total corfu-count))
+ (max 0 (+ corfu--index off 1 (- corfu-count))
+ (min (- corfu--index off corr) corfu--scroll))))))
+
+(defun corfu--candidates-popup (pos)
+ "Show candidates popup at POS."
+ (corfu--update-scroll)
+ (pcase-let* ((last (min (+ corfu--scroll corfu-count) corfu--total))
+ (bar (ceiling (* corfu-count corfu-count) corfu--total))
+ (lo (min (- corfu-count bar 1) (floor (* corfu-count corfu--scroll) corfu--total)))
+ (`(,mf . ,acands) (corfu--affixate (funcall corfu--highlight
+ (seq-subseq corfu--candidates corfu--scroll last))))
+ (`(,pw ,width ,fcands) (corfu--format-candidates acands))
+ ;; Disable the left margin if a margin formatter is active.
+ (corfu-left-margin-width (if mf 0 corfu-left-margin-width)))
+ ;; Nonlinearity at the end and the beginning
+ (when (/= corfu--scroll 0)
+ (setq lo (max 1 lo)))
+ (when (/= last corfu--total)
+ (setq lo (min (- corfu-count bar 2) lo)))
+ (corfu--popup-show (+ pos corfu--base) pw width fcands (- corfu--index corfu--scroll)
+ (and (> corfu--total corfu-count) lo) bar)))
+
+(defun corfu--preview-current (beg end str)
+ "Show current candidate as overlay given BEG, END and STR."
+ (when-let (cand (and corfu-preview-current (>= corfu--index 0)
+ (/= corfu--index corfu--preselect)
+ (nth corfu--index corfu--candidates)))
+ (setq corfu--preview-ov (make-overlay beg end nil t t))
+ (overlay-put corfu--preview-ov 'priority 1000)
+ (overlay-put corfu--preview-ov 'window (selected-window))
+ (overlay-put corfu--preview-ov
+ (if (= beg end) 'after-string 'display)
+ (concat (substring str 0 corfu--base) cand))))
+
+(defun corfu--echo-refresh ()
+ "Refresh echo message to prevent flicker during redisplay."
+ (when corfu--echo-timer
+ (cancel-timer corfu--echo-timer)
+ (setq corfu--echo-timer nil))
+ (when corfu--echo-message
+ (corfu--echo-show corfu--echo-message)))
+
+(defun corfu--echo-show (msg)
+ "Show MSG in echo area."
+ (let ((message-log-max nil))
+ (setq corfu--echo-message msg)
+ (message "%s" (if (text-property-not-all 0 (length msg) 'face nil msg)
+ msg
+ (propertize msg 'face 'corfu-echo)))))
+
+(defun corfu--echo-documentation ()
+ "Show documentation string of current candidate in echo area."
+ (when corfu-echo-documentation
+ (if-let* ((fun (plist-get corfu--extra :company-docsig))
+ (cand (and (>= corfu--index 0) (nth corfu--index corfu--candidates)))
+ (doc (funcall fun cand)))
+ (if (or (eq corfu-echo-documentation t) corfu--echo-message)
+ (corfu--echo-show doc)
+ (setq corfu--echo-timer (run-with-idle-timer corfu-echo-documentation
+ nil #'corfu--echo-show doc)))
+ (when corfu--echo-message
+ (corfu--echo-show "")))))
+
+(defun corfu--update ()
+ "Refresh Corfu UI."
+ (pcase-let* ((`(,beg ,end ,table ,pred) completion-in-region--data)
+ (pt (- (point) beg))
+ (str (buffer-substring-no-properties beg end))
+ (initializing (not corfu--input))
+ (continue (or (/= beg end)
+ (corfu--match-symbol-p corfu-continue-commands
+ this-command))))
+ (corfu--echo-refresh)
+ (cond
+ ;; XXX Guard against errors during candidate generation.
+ ;; Turn off completion immediately if there are errors
+ ;; For example dabbrev throws error "No dynamic expansion ... found".
+ ;; TODO Report this as a bug? Are completion tables supposed to throw errors?
+ ((condition-case err
+ ;; Only recompute when input changed and when input is non-empty
+ (when (and continue (not (equal corfu--input (cons str pt))))
+ (corfu--update-candidates str pt table pred)
+ nil)
+ (error (corfu-quit)
+ (message "Corfu completion error: %s" (error-message-string err)))))
+ ;; 1) Initializing, no candidates => Quit
+ ((and initializing (not corfu--candidates))
+ (corfu-quit))
+ ;; 2) Single matching candidate and no further completion is possible
+ ((and (not (equal str ""))
+ (equal corfu--candidates (list str))
+ (not (consp (completion-try-completion str table pred pt corfu--metadata))))
+ (corfu--done str 'finished))
+ ;; 3) There exist candidates
+ ;; & Input is non-empty or continue command
+ ;; => Show candidates popup
+ ((and corfu--candidates continue)
+ (corfu--candidates-popup beg)
+ (corfu--echo-documentation)
+ (corfu--preview-current beg end str))
+ ;; 4) There are no candidates & corfu-quit-no-match => Confirmation popup
+ ((not (or corfu--candidates
+ ;; When `corfu-quit-no-match' is a number of seconds and the auto completion wasn't
+ ;; initiated too long ago, quit directly without showing the "No match" popup.
+ (if (and corfu--auto-start (numberp corfu-quit-no-match))
+ (< (- (float-time) corfu--auto-start) corfu-quit-no-match)
+ (eq t corfu-quit-no-match))))
+ (corfu--popup-show beg 0 8 '(#("No match" 0 8 (face italic)))))
+ (t (corfu-quit)))))
+
+(defun corfu--pre-command ()
+ "Insert selected candidate unless command is marked to continue completion."
+ (add-hook 'window-configuration-change-hook #'corfu-quit)
+ (when corfu--preview-ov
+ (delete-overlay corfu--preview-ov)
+ (setq corfu--preview-ov nil))
+ (when (and corfu-commit-predicate
+ (not (corfu--match-symbol-p corfu-continue-commands this-command))
+ (funcall corfu-commit-predicate))
+ (corfu--insert 'exact)))
+
+(defun corfu-candidate-previewed-p ()
+ "Return t if a candidate is selected and previewed."
+ (and corfu-preview-current (/= corfu--index corfu--preselect)))
+
+(defun corfu--post-command ()
+ "Refresh Corfu after last command."
+ (remove-hook 'window-configuration-change-hook #'corfu-quit)
+ (or (pcase completion-in-region--data
+ (`(,beg ,end . ,_)
+ (when (let ((pt (point)))
+ (and (eq (marker-buffer beg) (current-buffer))
+ (<= beg pt end)
+ (save-excursion
+ (goto-char beg)
+ (<= (line-beginning-position) pt (line-end-position)))
+ (or (not corfu-quit-at-boundary)
+ (funcall completion-in-region-mode--predicate))))
+ (corfu--update)
+ t)))
+ (corfu-quit)))
+
+(defun corfu--goto (index)
+ "Go to candidate with INDEX."
+ (setq corfu--index (max corfu--preselect (min index (1- corfu--total)))
+ ;; Reset auto start in order to disable the `corfu-quit-no-match' timer
+ corfu--auto-start nil))
+
+(defun corfu-next (&optional n)
+ "Go forward N candidates."
+ (interactive "p")
+ (let ((index (+ corfu--index (or n 1))))
+ (corfu--goto
+ (cond
+ ((not corfu-cycle) index)
+ ((= corfu--total 0) -1)
+ ((< corfu--preselect 0) (1- (mod (1+ index) (1+ corfu--total))))
+ (t (mod index corfu--total))))))
+
+(defun corfu-previous (&optional n)
+ "Go backward N candidates."
+ (interactive "p")
+ (corfu-next (- (or n 1))))
+
+(defun corfu-scroll-down (&optional n)
+ "Go back by N pages."
+ (interactive "p")
+ (corfu--goto (max 0 (- corfu--index (* (or n 1) corfu-count)))))
+
+(defun corfu-scroll-up (&optional n)
+ "Go forward by N pages."
+ (interactive "p")
+ (corfu-scroll-down (- (or n 1))))
+
+(defun corfu-first ()
+ "Go to first candidate, or to the prompt when the first candidate is selected."
+ (interactive)
+ (corfu--goto (if (> corfu--index 0) 0 -1)))
+
+(defun corfu-last ()
+ "Go to last candidate."
+ (interactive)
+ (corfu--goto (1- corfu--total)))
+
+(defun corfu--restore-on-next-command ()
+ "Restore window configuration before next command."
+ (let ((config (current-window-configuration))
+ (other other-window-scroll-buffer)
+ (restore (make-symbol "corfu--restore")))
+ (fset restore
+ (lambda ()
+ (when (memq this-command '(corfu-quit corfu-reset))
+ (setq this-command #'ignore))
+ (remove-hook 'pre-command-hook restore)
+ (setq other-window-scroll-buffer other)
+ (set-window-configuration config)))
+ (add-hook 'pre-command-hook restore)))
+
+;; Company support, taken from `company.el', see `company-show-doc-buffer'.
+(defun corfu-show-documentation ()
+ "Show documentation of current candidate."
+ (interactive)
+ (when (< corfu--index 0)
+ (user-error "No candidate selected"))
+ (if-let* ((fun (plist-get corfu--extra :company-doc-buffer))
+ (res (funcall fun (nth corfu--index corfu--candidates))))
+ (let ((buf (or (car-safe res) res)))
+ (corfu--restore-on-next-command)
+ (setq other-window-scroll-buffer (get-buffer buf))
+ (set-window-start (display-buffer buf t) (or (cdr-safe res) (point-min))))
+ (user-error "No documentation available")))
+
+;; Company support, taken from `company.el', see `company-show-location'.
+(defun corfu-show-location ()
+ "Show location of current candidate."
+ (interactive)
+ (when (< corfu--index 0)
+ (user-error "No candidate selected"))
+ (if-let* ((fun (plist-get corfu--extra :company-location))
+ (loc (funcall fun (nth corfu--index corfu--candidates))))
+ (let ((buf (or (and (bufferp (car loc)) (car loc)) (find-file-noselect (car loc) t))))
+ (corfu--restore-on-next-command)
+ (setq other-window-scroll-buffer buf)
+ (with-selected-window (display-buffer buf t)
+ (save-restriction
+ (widen)
+ (if (bufferp (car loc))
+ (goto-char (cdr loc))
+ (goto-char (point-min))
+ (forward-line (1- (cdr loc))))
+ (set-window-start nil (point)))))
+ (user-error "No candidate location available")))
+
+(defun corfu-complete ()
+ "Try to complete current input."
+ (interactive)
+ (pcase-let ((`(,beg ,end ,table ,pred) completion-in-region--data))
+ (if completion-cycling
+ ;; Proceed with cycling
+ (let ((completion-extra-properties corfu--extra))
+ (corfu--completion-in-region beg end table pred))
+ (if (>= corfu--index 0)
+ ;; Continue completion with selected candidate
+ (corfu--insert nil)
+ ;; Try to complete the current input string
+ (let* ((pt (max 0 (- (point) beg)))
+ (str (buffer-substring-no-properties beg end))
+ (metadata (completion-metadata (substring str 0 pt) table pred)))
+ (pcase (completion-try-completion str table pred pt metadata)
+ (`(,newstr . ,newpt)
+ (completion--replace beg end newstr)
+ (goto-char (+ beg newpt))))))
+ ;; No further completion is possible and the current string is a valid
+ ;; match, exit with status 'finished.
+ (let* ((pt (max 0 (- (point) beg)))
+ (str (buffer-substring-no-properties beg end))
+ (metadata (completion-metadata (substring str 0 pt) table pred)))
+ (when (and (not (consp (completion-try-completion str table pred pt metadata)))
+ (test-completion str table pred))
+ (corfu--done str 'finished))))))
+
+(defun corfu--insert (status)
+ "Insert current candidate, exit with STATUS if non-nil."
+ (pcase-let* ((`(,beg ,end ,table ,pred) completion-in-region--data)
+ (str (buffer-substring-no-properties beg end)))
+ ;; Replace if candidate is selected or if current input is not valid completion.
+ ;; For example str can be a valid path, e.g., ~/dir/.
+ (when (or (>= corfu--index 0) (equal str "")
+ (not (test-completion str table pred)))
+ ;; XXX There is a small bug here, depending on interpretation.
+ ;; When completing "~/emacs/master/li|/calc" where "|" is the
+ ;; cursor, then the candidate only includes the prefix
+ ;; "~/emacs/master/lisp/", but not the suffix "/calc". Default
+ ;; completion has the same problem when selecting in the
+ ;; *Completions* buffer. See bug#48356.
+ (setq str (concat (substring str 0 corfu--base)
+ (substring-no-properties (nth (max 0 corfu--index) corfu--candidates))))
+ (completion--replace beg end str)
+ (corfu--goto -1)) ;; Reset selection, but continue completion.
+ (when status (corfu--done str status)))) ;; Exit with status
+
+(defun corfu--done (str status)
+ "Call the `:exit-function' with STR and STATUS and exit completion."
+ (let ((exit (plist-get corfu--extra :exit-function)))
+ ;; For successfull completions, amalgamate undo operations,
+ ;; such that completion can be undone in a single step.
+ (undo-amalgamate-change-group corfu--change-group)
+ (corfu-quit)
+ ;; XXX Is the :exit-function handling sufficient?
+ (when exit (funcall exit str status))))
+
+(defun corfu-insert ()
+ "Insert current candidate."
+ (interactive)
+ (if (> corfu--total 0)
+ (corfu--insert 'finished)
+ (corfu-quit)))
+
+(defun corfu--setup ()
+ "Setup Corfu completion state."
+ (setq corfu--extra completion-extra-properties)
+ (activate-change-group (setq corfu--change-group (prepare-change-group)))
+ (setcdr (assq #'completion-in-region-mode minor-mode-overriding-map-alist) corfu-map)
+ (add-hook 'pre-command-hook #'corfu--pre-command nil 'local)
+ (add-hook 'post-command-hook #'corfu--post-command nil 'local)
+ ;; Disable default post-command handling, since we have our own
+ ;; checks in `corfu--post-command'.
+ (remove-hook 'post-command-hook #'completion-in-region--postch)
+ (let ((sym (make-symbol "corfu--teardown"))
+ (buf (current-buffer)))
+ (fset sym (lambda ()
+ ;; Ensure that the teardown runs in the correct buffer, if still alive.
+ (unless completion-in-region-mode
+ (remove-hook 'completion-in-region-mode-hook sym)
+ (with-current-buffer (if (buffer-live-p buf) buf (current-buffer))
+ (corfu--teardown)))))
+ (add-hook 'completion-in-region-mode-hook sym)))
+
+(defun corfu--teardown ()
+ "Teardown Corfu."
+ ;; Redisplay such that the input becomes immediately visible before the popup
+ ;; hiding, which is slow (Issue #48). See also corresponding vertico#89.
+ (redisplay)
+ (corfu--popup-hide)
+ (remove-hook 'window-configuration-change-hook #'corfu-quit)
+ (remove-hook 'pre-command-hook #'corfu--pre-command 'local)
+ (remove-hook 'post-command-hook #'corfu--post-command 'local)
+ (when corfu--preview-ov (delete-overlay corfu--preview-ov))
+ (when corfu--echo-timer (cancel-timer corfu--echo-timer))
+ (when corfu--echo-message (corfu--echo-show ""))
+ (accept-change-group corfu--change-group)
+ (mapc #'kill-local-variable corfu--state-vars))
+
+(defun corfu--completion-message (msg)
+ "Print completion MSG, do not hang like `completion--message'."
+ (when (and completion-show-inline-help
+ (member msg '("No match" "Sole completion")))
+ (message msg)))
+
+(defun corfu--all-sorted-completions (&optional beg end)
+ "Compute all sorted completions for string between BEG and END."
+ (or completion-all-sorted-completions
+ (pcase-let ((`(,base ,all . ,_) (corfu--recompute-candidates
+ (buffer-substring-no-properties beg end)
+ (max 0 (- (point) beg))
+ minibuffer-completion-table
+ minibuffer-completion-predicate)))
+ (when all
+ (completion--cache-all-sorted-completions
+ beg end (nconc all base))))))
+
+(defun corfu--completion-in-region (&rest args)
+ "Corfu completion in region function passing ARGS to `completion--in-region'."
+ (barf-if-buffer-read-only)
+ (if (not (display-graphic-p))
+ ;; XXX Warning this can result in an endless loop when `completion-in-region-function'
+ ;; is set *globally* to `corfu--completion-in-region'. This should never happen.
+ (apply (default-value 'completion-in-region-function) args)
+ ;; Restart the completion. This can happen for example if C-M-/
+ ;; (`dabbrev-completion') is pressed while the Corfu popup is already open.
+ (when (and completion-in-region-mode (not completion-cycling))
+ (corfu-quit))
+ (prog1
+ (cl-letf* ((completion-auto-help nil)
+ ;; Set the predicate to ensure that `completion-in-region-mode' is enabled.
+ (completion-in-region-mode-predicate
+ (or completion-in-region-mode-predicate (lambda () t)))
+ ;; Overwrite to avoid hanging.
+ ((symbol-function #'completion--message)
+ #'corfu--completion-message)
+ ;; Overwrite for performance and consistency.
+ ((symbol-function #'completion-all-sorted-completions)
+ #'corfu--all-sorted-completions))
+ (apply #'completion--in-region args))
+ (when (and completion-in-region-mode
+ ;; Do not show Corfu when "trivially" cycling, i.e.,
+ ;; when the completion is finished after the candidate.
+ (not (and completion-cycling
+ (pcase-let* ((`(,beg ,end ,table ,pred) completion-in-region--data)
+ (pt (max 0 (- (point) beg)))
+ (str (buffer-substring-no-properties beg end))
+ (before (substring str 0 pt))
+ (after (substring str pt)))
+ (equal (completion-boundaries before table pred after) '(0 . 0))))))
+ (corfu--setup)))))
+
+(defun corfu--auto-complete (buffer)
+ "Initiate auto completion after delay in BUFFER."
+ (setq corfu--auto-timer nil)
+ (when (and (not completion-in-region-mode)
+ (eq (current-buffer) buffer))
+ (pcase (run-hook-wrapped 'completion-at-point-functions
+ #'completion--capf-wrapper 'all)
+ ((and `(,fun ,beg ,end ,table . ,plist)
+ (guard (integer-or-marker-p beg))
+ (guard (<= beg (point) end))
+ (guard
+ (let ((len (or (plist-get plist :company-prefix-length) (- (point) beg))))
+ (or (eq len t) (>= len corfu-auto-prefix)))))
+ (let ((completion-extra-properties plist)
+ (completion-in-region-mode-predicate
+ (lambda () (eq beg (car-safe (funcall fun))))))
+ (setq completion-in-region--data `(,(copy-marker beg) ,(copy-marker end t)
+ ,table ,(plist-get plist :predicate))
+ corfu--auto-start (float-time))
+ (undo-boundary) ;; Necessary to support `corfu-reset'
+ (completion-in-region-mode 1)
+ (corfu--setup)
+ (corfu--update))))))
+
+(defun corfu--auto-post-command ()
+ "Post command hook which initiates auto completion."
+ (when corfu--auto-timer
+ (cancel-timer corfu--auto-timer)
+ (setq corfu--auto-timer nil))
+ (when (and (not completion-in-region-mode)
+ (corfu--match-symbol-p corfu-auto-commands this-command)
+ (display-graphic-p))
+ ;; NOTE: Do not use idle timer since this leads to unacceptable slowdowns,
+ ;; in particular if flyspell-mode is enabled.
+ (setq corfu--auto-timer (run-at-time corfu-auto-delay nil
+ #'corfu--auto-complete
+ (current-buffer)))))
+
+;;;###autoload
+(define-minor-mode corfu-mode
+ "Completion Overlay Region FUnction"
+ :global nil :group 'corfu
+ (cond
+ (corfu-mode
+ ;; FIXME: Install advice which fixes `completion--capf-wrapper', such that
+ ;; it respects the completion styles for non-exclusive capfs. See FIXME in
+ ;; the `completion--capf-wrapper' function in minibuffer.el, where the
+ ;; issue has been mentioned. We never uninstall this advice since the
+ ;; advice is active *globally*.
+ (advice-add #'completion--capf-wrapper :around #'corfu--capf-wrapper-advice)
+ (advice-add #'eldoc-display-message-no-interference-p :before-while #'corfu--allow-eldoc)
+ (and corfu-auto (add-hook 'post-command-hook #'corfu--auto-post-command nil 'local))
+ (setq-local completion-in-region-function #'corfu--completion-in-region))
+ (t
+ (remove-hook 'post-command-hook #'corfu--auto-post-command 'local)
+ (kill-local-variable 'completion-in-region-function))))
+
+(defun corfu--capf-wrapper-advice (orig fun which)
+ "Around advice for `completion--capf-wrapper'.
+The ORIG function takes the FUN and WHICH arguments."
+ (if corfu-mode ;; Only enable the advice when Corfu is active
+ (let ((res (funcall fun)))
+ (when (and (consp res) (integer-or-marker-p (car res)) ;; Valid capf result
+ (pcase-let ((`(,beg ,end ,table . ,plist) res))
+ (and (<= beg (point) end) ;; Sanity checking
+ ;; For non-exclusive capfs, check for valid completion.
+ (or (not (eq 'no (plist-get plist :exclusive)))
+ (let* ((str (buffer-substring-no-properties beg end))
+ (pt (- (point) beg))
+ (pred (plist-get plist :predicate))
+ (md (completion-metadata (substring str 0 pt) table pred)))
+ (completion-try-completion str table pred pt md))))))
+ (cons fun res)))
+ (funcall orig fun which)))
+
+;;;###autoload
+(define-globalized-minor-mode corfu-global-mode corfu-mode corfu--on :group 'corfu)
+
+(defun corfu--on ()
+ "Turn `corfu-mode' on."
+ (unless (or noninteractive
+ (eq (aref (buffer-name) 0) ?\s)
+ (memq major-mode corfu-excluded-modes))
+ (corfu-mode 1)))
+
+(defun corfu--allow-eldoc ()
+ "Return non-nil if Corfu is currently not active."
+ (not (and corfu-mode completion-in-region-mode)))
+
+;; Emacs 28: Do not show Corfu commands with M-X
+(dolist (sym '(corfu-next corfu-previous corfu-first corfu-last corfu-quit corfu-reset
+ corfu-complete corfu-insert corfu-scroll-up corfu-scroll-down
+ corfu-show-location corfu-show-documentation))
+ (put sym 'completion-predicate #'ignore))
+
+(provide 'corfu)
+;;; corfu.el ends here
blob - /dev/null
blob + dbb562700f9bfe64cdcb891a880deb442bd8e3a0 (mode 644)
Binary files /dev/null and elpa/corfu-0.16/corfu.elc differ
blob - /dev/null
blob + 359a487174d345beedcc1dca8bb169fd7aea307f (mode 644)
--- /dev/null
+++ elpa/corfu-0.16/corfu.info
+This is corfu.info, produced by makeinfo version 6.7 from corfu.texi.
+
+INFO-DIR-SECTION Emacs
+START-INFO-DIR-ENTRY
+* Corfu: (corfu). Completion Overlay Region FUnction.
+END-INFO-DIR-ENTRY
+
+
+File: corfu.info, Node: Top, Next: Introduction, Up: (dir)
+
+corfu.el - Completion Overlay Region FUnction
+*********************************************
+
+* Menu:
+
+* Introduction::
+* Features::
+* Installation and Configuration::
+* Key bindings::
+* Complementary packages::
+* Caveats::
+* Contributions::
+
+— The Detailed Node Listing —
+
+Installation and Configuration
+
+* TAB-and-Go completion::
+
+
+
+File: corfu.info, Node: Introduction, Next: Features, Prev: Top, Up: Top
+
+1 Introduction
+**************
+
+Corfu enhances the default completion in region function with a
+completion overlay. The current candidates are shown in a popup below
+or above the point. Corfu is the minimalistic ‘completion-in-region’
+counterpart of the Vertico (https://github.com/minad/vertico) minibuffer
+UI.
+
+ Corfu is a minimal package, which relies on the Emacs completion
+facilities and concentrates on providing a polished completion UI.
+Completions are either provided by commands like ‘dabbrev-completion’ or
+by pluggable backends (‘completion-at-point-functions’, Capfs). Most
+programming language major modes implement a Capf. Furthermore the
+language server packages, Eglot (https://github.com/joaotavora/eglot)
+and Lsp-mode (https://github.com/emacs-lsp/lsp-mode), both use Capfs
+which talk to the LSP server to retrieve the completions.
+
+ Corfu does not include custom completion backends. In contrast, the
+complex Company package includes custom completion backends, which
+deviate from the Emacs completion infrastructure. The Emacs built-in
+Capfs are mostly sufficient, but a few additional Capfs and completion
+functions are provided by the Cape (https://github.com/minad/cape)
+package.
+
+ *NOTE*: Corfu uses child frames to show the popup; on non-graphical
+displays it will fall back to the default setting of the
+‘completion-in-region-function’.
+
+ <https://github.com/minad/corfu/blob/screenshots/light.png?raw=true>
+
+ <https://github.com/minad/corfu/blob/screenshots/dark.png?raw=true>
+
+
+File: corfu.info, Node: Features, Next: Installation and Configuration, Prev: Introduction, Up: Top
+
+2 Features
+**********
+
+ • Timer-based auto-completions (_off_ by default, set ‘corfu-auto’).
+ • Popup display with scrollbar indicator and arrow key navigation.
+ • The popup can be summoned explicitly by pressing ‘TAB’ at any time.
+ • The current candidate is inserted with ‘TAB’ and selected with
+ ‘RET’.
+ • Candidates sorting by prefix, string length and alphabetically.
+ • The selected candidate is previewed (configuable via
+ ‘corfu-preview-current’).
+ • The selected candidate automatically committed on further input by
+ default (configurable via ‘corfu-commit-predicate’).
+ • The Orderless (https://github.com/oantolin/orderless) completion
+ style is supported. The filter string can contain arbitrary
+ characters, including spaces, if ‘corfu-quit-at-boundary’ is nil.
+ • Deferred completion style highlighting for performance.
+ • Jumping to location/documentation of current candidate.
+ • Show candidate documentation/signature string in the echo area.
+ • Deprecated candidates are crossed out in the display.
+ • Support for annotations (‘annotation-function’,
+ ‘affixation-function’).
+ • Icons can be provided by an external package via margin formatter
+ functions.
+
+
+File: corfu.info, Node: Installation and Configuration, Next: Key bindings, Prev: Features, Up: Top
+
+3 Installation and Configuration
+********************************
+
+Corfu is available from GNU ELPA
+(http://elpa.gnu.org/packages/corfu.html), such that it can be installed
+directly via ‘package-install’. After installation, the global minor
+mode can be enabled with ‘M-x corfu-global-mode’. In order to configure
+Corfu and other packages in your init.el, you may want to use
+‘use-package’.
+
+ Corfu is highly flexible and customizable via ‘corfu-*’ customization
+variables. For filtering I recommend to give Orderless completion a
+try, which is different from the familiar prefix TAB completion. Corfu
+can be used with the default completion styles, the use of Orderless is
+not a necessity. See also the Corfu Wiki
+(https://github.com/minad/corfu/wiki) for additional configuration tips.
+In particular the Lsp-mode configuration is documented in the Wiki.
+
+ Here is an example configuration:
+
+ (use-package corfu
+ ;; Optional customizations
+ ;; :custom
+ ;; (corfu-cycle t) ;; Enable cycling for `corfu-next/previous'
+ ;; (corfu-auto t) ;; Enable auto completion
+ ;; (corfu-commit-predicate nil) ;; Do not commit selected candidates on next input
+ ;; (corfu-quit-at-boundary t) ;; Automatically quit at word boundary
+ ;; (corfu-quit-no-match t) ;; Automatically quit if there is no match
+ ;; (corfu-preview-current nil) ;; Disable current candidate preview
+ ;; (corfu-preselect-first nil) ;; Disable candidate preselection
+ ;; (corfu-echo-documentation nil) ;; Disable documentation in the echo area
+ ;; (corfu-scroll-margin 5) ;; Use scroll margin
+
+ ;; You may want to enable Corfu only for certain modes.
+ ;; :hook ((prog-mode . corfu-mode)
+ ;; (shell-mode . corfu-mode)
+ ;; (eshell-mode . corfu-mode))
+
+ ;; Recommended: Enable Corfu globally.
+ ;; This is recommended since dabbrev can be used globally (M-/).
+ :init
+ (corfu-global-mode))
+
+ ;; Optionally use the `orderless' completion style. See `+orderless-dispatch'
+ ;; in the Consult wiki for an advanced Orderless style dispatcher.
+ ;; Enable `partial-completion' for files to allow path expansion.
+ ;; You may prefer to use `initials' instead of `partial-completion'.
+ (use-package orderless
+ :init
+ ;; Configure a custom style dispatcher (see the Consult wiki)
+ ;; (setq orderless-style-dispatchers '(+orderless-dispatch)
+ ;; orderless-component-separator #'orderless-escapable-split-on-space)
+ (setq completion-styles '(orderless)
+ completion-category-defaults nil
+ completion-category-overrides '((file (styles . (partial-completion))))))
+
+ ;; Use dabbrev with Corfu!
+ (use-package dabbrev
+ ;; Swap M-/ and C-M-/
+ :bind (("M-/" . dabbrev-completion)
+ ("C-M-/" . dabbrev-expand)))
+
+ ;; A few more useful configurations...
+ (use-package emacs
+ :init
+ ;; TAB cycle if there are only few candidates
+ (setq completion-cycle-threshold 3)
+
+ ;; Emacs 28: Hide commands in M-x which do not apply to the current mode.
+ ;; Corfu commands are hidden, since they are not supposed to be used via M-x.
+ ;; (setq read-extended-command-predicate
+ ;; #'command-completion-default-include-p)
+
+ ;; Enable indentation+completion using the TAB key.
+ ;; `completion-at-point' is often bound to M-TAB.
+ (setq tab-always-indent 'complete))
+
+* Menu:
+
+* TAB-and-Go completion::
+
+
+File: corfu.info, Node: TAB-and-Go completion, Up: Installation and Configuration
+
+3.1 TAB-and-Go completion
+=========================
+
+You may be interested in configuring Corfu in TAB-and-Go style.
+Pressing TAB moves to the next candidate and further input will then
+commit the selection.
+
+ (use-package corfu
+ ;; TAB-and-Go customizations
+ :custom
+ (corfu-cycle t) ;; Enable cycling for `corfu-next/previous'
+ (corfu-preselect-first nil) ;; Disable candidate preselection
+
+ ;; Use TAB for cycling, default is `corfu-complete'.
+ :bind
+ (:map corfu-map
+ ("TAB" . corfu-next)
+ ([tab] . corfu-next)
+ ("S-TAB" . corfu-previous)
+ ([backtab] . corfu-previous))
+
+ :init
+ (corfu-global-mode))
+
+
+File: corfu.info, Node: Key bindings, Next: Complementary packages, Prev: Installation and Configuration, Up: Top
+
+4 Key bindings
+**************
+
+Corfu uses a transient keymap ‘corfu-map’ which is active while the
+popup is shown. The keymap defines the following remappings and
+bindings:
+
+ • ‘beginning-of-buffer’ -> ‘corfu-first’
+ • ‘end-of-buffer’ -> ‘corfu-last’
+ • ‘scroll-down-command’ -> ‘corfu-scroll-down’
+ • ‘scroll-up-command’ -> ‘corfu-scroll-up’
+ • ‘next-line’, ‘down’, ‘M-n’ -> ‘corfu-next’
+ • ‘previous-line’, ‘up’, ‘M-p’ -> ‘corfu-previous’
+ • ‘completion-at-point’, ‘TAB’ -> ‘corfu-complete’
+ • ‘RET’ -> ‘corfu-insert’
+ • ‘M-g’ -> ‘corfu-show-location’
+ • ‘M-h’ -> ‘corfu-show-documentation’
+ • ‘C-g’ -> ‘corfu-quit’
+ • ‘keyboard-escape-quit’ -> ‘corfu-reset’
+
+
+File: corfu.info, Node: Complementary packages, Next: Caveats, Prev: Key bindings, Up: Top
+
+5 Complementary packages
+************************
+
+Corfu works well together with all packages providing code completion
+via the ‘completion-at-point-functions’. Furthermore it supports
+completion styles, including the advanced Orderless
+(https://github.com/oantolin/orderless) completion style, where the
+filtering expressions are separated by spaces (see
+‘corfu-quit-at-boundary’).
+
+ I collect additional Capf backends and ‘completion-in-region’
+commands in my small Cape (https://github.com/minad/cape) package. For
+example the package provides a file name and a dabbrev completion
+backend.
+
+ Icons are supported by Corfu via an external package. For example
+the kind-icon (https://github.com/jdtsmith/kind-icon) package provides
+beautifully styled SVG icons based on monochromatic icon sets like
+material design.
+
+ You may also want to look into my Vertico
+(https://github.com/minad/vertico) package. Vertico is the minibuffer
+counterpart of Corfu.
+
+
+File: corfu.info, Node: Caveats, Next: Contributions, Prev: Complementary packages, Up: Top
+
+6 Caveats
+*********
+
+Corfu is robust in most scenarios. There are a few known technical
+caveats.
+
+ • Corfu falls back to the default Completion buffer on non-graphical
+ displays, since Corfu requires child frames.
+ • No sorting by history, since ‘completion-at-point’ does not
+ maintain a history (See branch ‘history’ for a possible solution).
+ • There is currently no equivalent for ‘company-quickhelp’.
+ Documentation and source can be opened manually in a separate
+ buffer.
+ • Company has the ability to merge/group the candidates of multiple
+ backends in some scenarios. This feature is implemented by the
+ function ‘cape-super-capf’ of the Cape
+ (https://github.com/minad/cape) package.
+
+
+File: corfu.info, Node: Contributions, Prev: Caveats, Up: Top
+
+7 Contributions
+***************
+
+Since this package is part of GNU ELPA
+(http://elpa.gnu.org/packages/corfu.html) contributions require a
+copyright assignment to the FSF.
+
+
+
+Tag Table:
+Node: Top195
+Node: Introduction597
+Node: Features2215
+Node: Installation and Configuration3619
+Node: TAB-and-Go completion7339
+Node: Key bindings8149
+Node: Complementary packages9101
+Node: Caveats10175
+Node: Contributions11030
+
+End Tag Table
+
+
+Local Variables:
+coding: utf-8
+End:
blob - /dev/null
blob + c99df70adfaf1ac22023e18fd1c6fa07a533a435 (mode 644)
--- /dev/null
+++ elpa/corfu-0.16/dir
+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.
+
+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
+* Corfu: (corfu). Completion Overlay Region FUnction.
blob - /dev/null
blob + 4d63d57cf4769ebe28ca04ae80b09ea332219691 (mode 644)
--- /dev/null
+++ elpa/corfu-0.16.signed
+Good signature from 066DAFCB81E42C40 GNU ELPA Signing Agent (2019) <elpasign@elpa.gnu.org> (trust undefined) created at 2021-11-27T11:05:02+0100 using RSA
\ No newline at end of file
blob - 916570fa1a9b2aaaabe63b7c8a15db8fc64449b1
blob + 9be7051b3dfd090148a460c30f0695c66465b962
--- init.el
+++ init.el
(selectrum-prescient-mode 1)
(prescient-persist-mode 1)
(marginalia-mode 1)
-(global-company-mode 1)
+(corfu-global-mode 1)
(global-aggressive-indent-mode 1)
-(diminish 'company-mode)
(diminish 'which-key-mode)
(diminish 'aggressive-indent-mode)
'(backup-by-copying t)
'(column-number-mode t)
'(company-idle-delay 0)
+ '(corfu-auto t)
+ '(corfu-auto-delay 0.0)
+ '(corfu-auto-prefix 1)
+ '(corfu-global-mode t)
+ '(corfu-quit-at-boundary t)
'(cursor-type 'bar)
'(delete-old-versions t)
'(frame-resize-pixelwise t)
("melpa-stable" . "https://stable.melpa.org/packages/")
("melpa" . "https://melpa.org/packages/")))
'(package-selected-packages
- '(sly eglot aggressive-indent project nov nhexl-mode elfeed magit yaml-mode json-mode lua-mode go-mode geiser-guile geiser company-prescient company org-roam org-contrib org ace-window expand-region selectrum-prescient consult marginalia selectrum uuidgen request diminish which-key))
+ '(corfu sly eglot aggressive-indent project nov nhexl-mode elfeed magit yaml-mode json-mode lua-mode go-mode geiser-guile geiser org-roam org-contrib org ace-window expand-region selectrum-prescient consult marginalia selectrum uuidgen request diminish which-key))
'(reb-re-syntax 'string)
'(ring-bell-function 'ignore)
- '(scroll-conservatively 100))
+ '(scroll-conservatively 100)
+ '(tab-always-indent 'complete))
(custom-set-faces
;; custom-set-faces was added by Custom.
;; If you edit it by hand, you could mess it up, so be careful.
