pax_global_header00006660000000000000000000000064134043075460014520gustar00rootroot0000000000000052 comment=ac82e875e144b227e926c09c53def9b0c059115c company-mode-0.9.9/000077500000000000000000000000001340430754600141275ustar00rootroot00000000000000company-mode-0.9.9/.dir-locals.el000066400000000000000000000002331340430754600165560ustar00rootroot00000000000000((nil . ((indent-tabs-mode . nil) (fill-column . 80) (sentence-end-double-space . t) (emacs-lisp-docstring-fill-column . 75)))) company-mode-0.9.9/.elpaignore000066400000000000000000000000661340430754600162570ustar00rootroot00000000000000.travis.yml .gitignore Makefile test company-tests.el company-mode-0.9.9/.gitignore000066400000000000000000000000151340430754600161130ustar00rootroot00000000000000*.elc ert.el company-mode-0.9.9/.travis.yml000066400000000000000000000010261340430754600162370ustar00rootroot00000000000000language: generic sudo: false env: global: - CURL="curl -fsSkL --retry 9 --retry-delay 9" matrix: - EMACS_VERSION=24.5 - EMACS_VERSION=25.3 - EMACS_VERSION=26.1 - EMACS_VERSION=master allow_failures: - env: EMACS_VERSION=master install: - $CURL -O https://github.com/npostavs/emacs-travis/releases/download/bins/emacs-bin-${EMACS_VERSION}.tar.gz - tar -xaf emacs-bin-${EMACS_VERSION}.tar.gz -C / - export EMACS=/tmp/emacs/bin/emacs - $EMACS --version script: make test-batch EMACS=${EMACS} company-mode-0.9.9/Makefile000066400000000000000000000015711340430754600155730ustar00rootroot00000000000000EMACS=emacs .PHONY: ert test test-batch package: *.el @ver=`grep -o "Version: .*" company.el | cut -c 10-`; \ tar cjvf company-$$ver.tar.bz2 --mode 644 $$(find . -name \*.el) elpa: *.el @version=`grep -o "Version: .*" company.el | cut -c 10-`; \ dir=company-$$version; \ mkdir -p "$$dir"; \ cp $$(find . -name \*.el) company-$$version; \ echo "(define-package \"company\" \"$$version\" \ \"Modular in-buffer completion framework\")" \ > "$$dir"/company-pkg.el; \ tar cvf company-$$version.tar --mode 644 "$$dir" clean: @rm -rf company-*/ company-*.tar company-*.tar.bz2 *.elc ert.el test: ${EMACS} -Q -nw -L . -l test/all.el \ --eval "(let (pop-up-windows) (ert t))" test-batch: ${EMACS} -Q --batch -L . -l test/all.el \ --eval "(ert-run-tests-batch-and-exit '(not (tag interactive)))" compile: ${EMACS} -Q --batch -L . -f batch-byte-compile company.el company-*.el company-mode-0.9.9/NEWS.md000066400000000000000000000467701340430754600152430ustar00rootroot00000000000000# History of user-visible changes ## 2018-12-13 (0.9.9) * Fix for the changes in the previous release. * New hook `company-after-completion-hook`. * `company-clang` removes identity preprocessor #defines from completions ([#841](https://github.com/company-mode/company-mode/issues/841)). ## 2018-12-08 (0.9.8) * CAPF backend fixed to use the right `:exit-function`. It can now safely be a closure with lexical context capturing the buffer state at the moment when the completion table was returned ([#845](https://github.com/company-mode/company-mode/pull/845)). ## 2018-11-06 (0.9.7) * For more sophisticated highlighting in non-prefix completion, a backend may now respond to a `match` request with a list of regions. See `company-backends`. ([#798](https://github.com/company-mode/company-mode/issues/798), [#762](https://github.com/company-mode/company-mode/issues/762)) * The `company-capf` backend will pick up on a `:company-match` metadata element on the capf function (similar to `:company-location` or `:company-doc-buffer`) and use it as a response to aforementioned `match` request. * `company-cmake` supports completion inside string interpolations ([#714](https://github.com/company-mode/company-mode/pull/714)). * Workaround for the conflict between `inferior-python-mode`'s completion code and `company-sort-by-occurrence`. * In Emacs 26 and newer, `company-css` is removed from `company-backends`. `company-capf` is used instead. * Same for `company-nxml`. ## 2018-02-23 (0.9.6) * Workaround for Emacs' ([bug#23980](https://debbugs.gnu.org/23980)) triggered in combination with Flyspell. ## 2018-02-18 (0.9.5) * The most common case of tooltip flickering with asynchronous backends (and disabled built-in cache) is fixed ([#510](https://github.com/company-mode/company-mode/issues/510), [#654](https://github.com/company-mode/company-mode/issues/654)). * `company-keywords` added entries for `go-mode`, `swift-mode` and `kotlin-mode`. * Native line numbers compatibility fixes. * `company-dabbrev` and `company-dabbrev-code` are more responsive when user input is pending ([#720](https://github.com/company-mode/company-mode/pull/720)). * New feature `company-tng`. It contains a frontend and some helper code. The frontend triggers insertion of the candidate as soon as it's selected, so you only need to press TAB. Add `(company-tng-configure-default)` to your init script to give it a try ([#706](https://github.com/company-mode/company-mode/issues/706)). * New user option `company-tooltip-maximum-width`. ## 2017-07-15 (0.9.4) * Compatibility with native line numbers display in Emacs 26. * `company-files` allows completion after `=`. * `company-template` has a new shortcut (`C-d`) for deleting an unmodified template field while cursor is on it. ## 2017-03-29 (0.9.3) * New user option `company-echo-truncate-lines`. * `company-auto-complete` improved compatibility with `electric-pair-mode`. * Use of `overriding-terminal-local-map` does not disable completion. * `company-clang` and `company-gtags` can work over Tramp. * New frontend `company-preview-common-frontend`. * `company-clang` calls Clang using a pipe instead of pty. * The minimum required version of Emacs is now 24.3. ## 2016-11-14 (0.9.2) * Miscellaneous fixes and docstring improvements. ## 2016-11-12 (0.9.1) * `company-indent-or-complete-common` skips trying to indent if `indent-line-function` is `indent-relative` or `indent-relative-maybe`. * Better visualization of search matches. New face `company-tooltip-search-selection`. * New user option `company-files-exclusions`. * `company-next-page` and `company-previous-page` adhere to `company-selection-wrap-around` docstring more closely and only wrap around when the selection is at the start of the end of the list. * `company-pseudo-tooltip-unless-just-one-frontend-with-delay` handles custom frontends derived from `company-preview-frontend` better. * `company-idle-delay` is automatically adjusted to a non-zero value. ## 2016-06-23 (0.9.0) * Group of backends can now contain keyword `:separate`, which makes candidates from different backends sorted separately in the combined list. * New frontend `company-pseudo-tooltip-unless-just-one-frontend-with-delay`. * New transformer `company-sort-prefer-same-case-prefix`. * The value of `company-dabbrev-ignore-buffers` can also be a function. * `company-files` has been moved to right after `company-capf` in `company-backends` ([#463](https://github.com/company-mode/company-mode/issues/463)). * `company-semantic-insert-arguments`: New option. Like in `company-clang`. * `company-semantic-begin-after-member-access`: New option. Similar to the one in `company-clang`. * `company-capf` accepts `:company-prefix-length` property value. * New face `company-tooltip-annotation-selection`, used for the annotation in the selected tooltip line. * `company-clang-objc-templatify` has been renamed to `company-template-objc-templatify`. * New user option `company-etags-everywhere`. * `company-yasnippet` supports `yas-key-syntaxes` better. But we use them in the reverse order, preferring the longest key prefix that matches anything. And we only consider trigger key prefixes that are at least as long as the symbol at point, which effectively means skipping the `"w"` element ([#422](https://github.com/company-mode/company-mode/issues/422)). * New user option `company-search-regexp-function`. * Completion is not started automatically when a keyboard macro is being recorded ([#374](https://github.com/company-mode/company-mode/issues/374)). * New command `company-indent-or-complete-common`. * Backend command `doc-buffer` now can also return a cons of buffer and window start position. * Backend command `ignore-case` has been documented. * `company-template-c-like-templatify` does not replace the default argument values with `argN` anymore ([#336](https://github.com/company-mode/company-mode/issues/336)). This affects `company-clang` and all third-party backends that use this function. * Likewise for `company-clang-objc-templatify`. * `company-template-add-field` calling convention has changed. * New user option `company-dabbrev-ignore-invisible`. * `company-ropemacs` was removed. `ropemacs` supports completion via `completion-at-point-functions` starting with version 0.8. * `company-pysmell` was removed. * `company-select-next`, `company-select-previous`, `company-select-next-or-abort`, `company-select-previous-or-abort` and `company-complete-common-or-cycle` accept a numeric argument. * The documentation buffer window can be scrolled with the mouse wheel. * New command `company-diag`. Use it in bug reports. ## 2015-02-02 (0.8.10) * New variable `company-lighter-base`. * Better tracking of the current selection. * Pressing `M-0`...`M-9` works in the search mode. * Pressing `` or `` doesn't quit the search mode. ## 2015-01-23 (0.8.9) * New commands `company-next-page` and `company-previous-page`, remapping `scroll-up-command` and `scroll-down-command` during completion. ## 2015-01-13 (0.8.8) * Pressing `M-n` or `M-p` doesn't quit the search mode. * New command `company-complete-common-or-cycle`. No default binding. * `company-search-toggle-filtering` replaced `company-search-kill-others`. * Quitting the search mode resets the filtering. * Pressing `backspace` in the search mode deletes the character at the end of the search string. * `company-semantic` displays function arguments as annotations. * New user option, `company-bbdb-modes`. * `company-show-numbers` and `company-complete-number` now use visual numbering of the candidates, taking into account only the ones currently displayed. * `company-complete-number` can be bound to keypad numbers directly, with or without modifiers. * `company-cmake` expands `` and `` placeholders inside variable names. ## 2014-10-15 (0.8.6) * `company-clang` and `company-template-c-like-templatify` support templated functions and arguments. * `company-dabbrev` ignores "uninteresting" buffers by default. Depends on the new user option, `company-dabbrev-ignore-buffers`. * `company-files` checks directory's last modification time. * `company-files` supports relative paths and Windows drive letters. ## 2014-08-13 (0.8.4) * `company-ropemacs` is only used when `ropemacs-mode` is on. * `company-gtags` is enabled in all `prog-mode` derivatives by default. * `company-end-of-buffer-workaround` is not used anymore. * `company-begin-commands` includes some of `cc-mode` commands. ## 2014-08-27 (0.8.3) * On Emacs 24.4 or newer, tooltip positioning takes line-spacing into account. * New face `company-tooltip-search`, used for the search string in the tooltip. * The default value of `company-dabbrev-minimum-length` is set to 4, independent of the `company-minimum-prefix-length` value. ## 2014-07-26 (0.8.2) * New user option `company-occurrence-weight-function`, allowing to tweak the behavior of the transformer `company-sort-by-occurrence`. * Setting `company-idle-delay` to `t` is deprecated. Use the value 0 instead. ## 2014-07-01 (0.8.1) * `company-require-match` is not in effect when the new input doesn't continue the previous prefix, and that prefix was a match. * The meaning of `company-begin-commands` value t has slightly changed. * New transformer, `company-sort-by-backend-importance`. * When grouped back-ends are used, the back-end of the current candidate is indicated in the mode-line, enclosed in angle brackets. * New user option `company-gtags-insert-arguments`, t by default. * `company-css` knows about CSS3. * `company-gtags` supports `meta` and `annotation`. * User option `company-dabbrev-code-other-buffers` can have a new value: `code`. * New user option `company-tooltip-flip-when-above`. * `company-clang` uses the standard header search paths by default. * `C-h` is bound to `company-show-doc-buffer` (like `f1`). ## 2014-04-19 (0.8.0) * `company-capf` is included in `company-backends` in any supported Emacs version (>= 24.1). `company-elisp` goes before it if Emacs version is < 24.4. * New user option `company-clang-insert-arguments`, by default t. * Default value of `company-idle-delay` lowered to `0.5`. * New user option `company-tooltip-minimum-width`, by default 0. * New function `company-grab-symbol-cons`. * `company-clang` fetches completion candidates asynchronously. * Added support for asynchronous back-ends (experimental). * Support for back-end command `crop` dropped (it was never documented). * Support for Emacs 23 dropped. * New user option `company-abort-manual-when-too-short`. ## 2014-03-25 (0.7.3) * New user option `company-etags-ignore-case`. ## 2014-03-19 (0.7.2) * Support for Emacs 22 officially dropped. * `company-clang` supports `indent-tabs-mode` and multibyte chars before point. ## 2014-03-18 (0.7.1) * Group of back-ends can now contain keyword `:with`, which makes all back-ends after it to be skipped for prefix calculation. * New function `company-version`. * New bundled back-end `company-yasnippet`. * Completion candidates returned from grouped back-ends are tagged to remember which back-end each came from. * New user option `company-tooltip-align-annotations`, off by default. * New bundled back-end `company-bbdb`. ## 2014-02-18 (0.7) * New back-end command, `match`, for non-prefix completion. * New user option `company-continue-commands`. The default value aborts completion on buffer saving commands. * New back-end command, `annotation`, for text displayed inline in the popup that's not a part of completion candidate. * `company-capf`, `company-clang` and `company-eclim` use `annotation`. * `company-preview*` faces inherit from `company-tooltip-selection` and `company-tooltip-common-selection` on light themes. * New user option `company-transformers`. * First transformer, `company-sort-by-occurrence`. * New user options controlling `company-dabbrev` and `company-dabbrev-code`. ## 2014-01-25 (0.6.14) * The tooltip front-end is rendered with scrollbar, controlled by the user option `company-tooltip-offset-display`. * The tooltip front-end is rendered with margins, controlled by the user option `company-tooltip-margin`. ## 2014-01-14 (0.6.13) * Experimental support for non-prefix completion. * Starting with Emacs version 24.4, `company-capf` is included in `company-backends` and replaces `company-elisp`. * `company-capf` supports completion tables that return non-default boundaries. * `company-elisp` is enabled in `inferior-emacs-lisp-mode`. ## 2013-09-28 (0.6.12) * Default value of `company-begin-commands` changed to `(self-insert-command)`. * Futher improvement in `org-indent-mode` compatibility. ## 2013-08-18 (0.6.11) * `company-template-c-like-templatify` removes all text after closing paren, for use in backends that display additional info there. * `company-cmake` is now bundled. * Better `linum` compatibility in Emacs <= 24.2. * `company-global-modes`: New option. ## 2013-05-26 (0.6.10) * Plays nicer with `org-indent-mode`. * Works in horizontally scrolled windows. ## 2013-05-10 (0.6.9) * `company-capf` respects `:exit-function` completion property. * `company-backends`: `prefix` command can return `t` in the cdr. * `company-clang-begin-after-member-access`: New option. * Mouse click outside the tooltip aborts completion. * `company-clang` uses standard input to pass the contents of current buffer to Clang 2.9+, otherwise saves the buffer and passes the path to the file. * `company-clang-auto-save` option has been removed. * Better interaction with `outline-minor-mode`. * `company-dabbrev-code` supports all `prog-mode` derivatives. ## 2013-04-16 (0.6.8) * `company-auto-complete` is disabled by default. * `company-auto-complete-chars` default value includes fewer syntax classes. * In expanded function calls, arguments skipped by the user default to "argN". * `company-eclim` and `company-clang` do not strip argument types from fields. * `company-clang` expands function calls for all three modes now. * `company-clang` supports `c++-mode` by default. ## 2013-04-05 (0.6.7) * Two `company-elisp` tweaks. ## 2013-04-01 (0.6.6) * `company-elisp` doesn't offer completions when typing the name and the arguments of a new function or macro definition, allowing to fall back to other back-ends like `company-dabbrev-code`. ## 2013-03-30 (0.6.5) * Fixed keybindings when running in a terminal. * `company-elisp-show-locals-first`: new customizable variable. * `company-elisp` shows more accurate and comprehensive candidates list. ## 2013-03-26 (0.6.4) * `company-eclim` shows valid completions after an opening paren. * Expanded template does not get removed until the point leaves it. After your input the last argument in a method call expanded by `company-eclim`, you can press `` once more, to jump after the closing paren. No other bundled back-ends are affected. ## 2013-03-25 (0.6.3) * New tooltip face colors used on themes with light background. * Pseudo-tooltip stays up-to-date when text is inserted after the point. * Fixed `company-require-match` mechanics. ## 2013-03-24 (0.6.2) * `global-company-mode` is now autoloaded. ## 2013-03-23 (0.6.1) * Documented `init` and `post-completion` back-end commands. * `company-eclim` and `company-clang` only expand the template on explicit user action (such as `company-complete-{selection,number,mouse}`). * `company-template` has some breaking changes. When point is at one of the fields, it's displayed at the beginning, not right after it; `` jumps to the next field, `forward-word` and `subword-forward` remappings are removed; when you jump to the next field, if the current one hasn't been edited, the overlay gets removed but the text remains. * `company-eclim` shows method overloads and expands templates for calls. * `company-clang-objc-templatify` does not insert spaces after colons anymore. * `company-clang` is now only initialized in supported buffers. So, no error messages if you don't have Clang until you open a C file. * `company-clang` recognizes Clang included in recent Xcode. * New commands `company-select-previous-or-abort` and `company-select-next-or-abort`, bound to `` and ``. ## 2013-03-19 (0.6) * Across-the-board bugfixing. * `company-pysmell` is not used by default anymore. * Loading of `nxml`, `semantic`, `pymacs` and `ropemacs` is now deferred. * Candidates from grouped back-ends are merged more conservatively: only back-ends that return the same prefix at point are used. * `company-clang` now shows meta information, too. * Some performance improvements. * Fixed two old tooltip annoyances. * Instead of `overrriding-terminal-local-map`, we're now using `emulation-mode-map-alists` (experimental). This largely means that when the completion keymap is active, other minor modes' keymaps are still used, so, for example, it's not as easy to accidentally circumvent `paredit-mode` when it's enabled. * `company-elisp` has seen some improvements. * Added `company-capf`: completion adapter using `completion-at-point-functions`. (Stefan Monnier) * Clang completions now include macros and are case-sensitive. * Switching between tag files now works correctly with `company-etags`. ## 2010-02-24 (0.5) * `company-ropemacs` now provides location and docs. (Fernando H. Silva) * Added `company-with-candidate-inserted` macro. * Added `company-clang` back-end. * Added new mechanism for non-consecutive insertion. (So far only used by clang for ObjC.) * The semantic back-end now shows meta information for local symbols. * Added compatibility for CEDET in Emacs 23.2 and from CVS. (Oleg Andreev) ## 2009-05-07 (0.4.3) * Added `company-other-backend`. * Idle completion no longer interrupts multi-key command input. * Added `company-ropemacs` and `company-pysmell` back-ends. ## 2009-04-25 (0.4.2) * In C modes . and -> now count towards `company-minimum-prefix-length`. * Reverted default front-end back to `company-preview-if-just-one-frontend`. * The pseudo tooltip will no longer be clipped at the right window edge. * Added `company-tooltip-minimum`. * Windows compatibility fixes. ## 2009-04-19 (0.4.1) * Added `global-company-mode`. * Performance enhancements. * Added `company-eclim` back-end. * Added safer workaround for Emacs `posn-col-row` bug. ## 2009-04-18 (0.4) * Automatic completion is now aborted if the prefix gets too short. * Added option `company-dabbrev-time-limit`. * `company-backends` now supports merging back-ends. * Added back-end `company-dabbrev-code` for generic code. * Fixed `company-begin-with`. ## 2009-04-15 (0.3.1) * Added 'stop prefix to prevent dabbrev from completing inside of symbols. * Fixed issues with tabbar-mode and line-spacing. * Performance enhancements. ## 2009-04-12 (0.3) * Added `company-begin-commands` option. * Added abbrev, tempo and Xcode back-ends. * Back-ends are now interactive. You can start them with M-x backend-name. * Added `company-begin-with` for starting company from elisp-code. * Added hooks. * Added `company-require-match` and `company-auto-complete` options. ## 2009-04-05 (0.2.1) * Improved Emacs Lisp back-end behavior for local variables. * Added `company-elisp-detect-function-context` option. * The mouse can now be used for selection. ## 2009-03-22 (0.2) * Added `company-show-location`. * Added etags back-end. * Added work-around for end-of-buffer bug. * Added `company-filter-candidates`. * More local Lisp variables are now included in the candidates. ## 2009-03-21 (0.1.5) * Fixed elisp documentation buffer always showing the same doc. * Added `company-echo-strip-common-frontend`. * Added `company-show-numbers` option and M-0 ... M-9 default bindings. * Don't hide the echo message if it isn't shown. ## 2009-03-20 (0.1) * Initial release. company-mode-0.9.9/README.md000066400000000000000000000004471340430754600154130ustar00rootroot00000000000000See the [homepage](http://company-mode.github.com/). [![Build Status](https://travis-ci.org/company-mode/company-mode.png?branch=master)](https://travis-ci.org/company-mode/company-mode) [![Melpa Status](http://melpa.milkbox.net/packages/company-badge.svg)](http://melpa.milkbox.net/#/company) company-mode-0.9.9/company-abbrev.el000066400000000000000000000031271340430754600173610ustar00rootroot00000000000000;;; 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 . ;;; 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 company-mode-0.9.9/company-bbdb.el000066400000000000000000000043131340430754600170070ustar00rootroot00000000000000;;; company-bbdb.el --- company-mode completion backend for BBDB in message-mode ;; Copyright (C) 2013-2014, 2016 Free Software Foundation, Inc. ;; Author: Jan Tatarik ;; 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 . (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) (looking-back "^\\(To\\|Cc\\|Bcc\\): *.*? *\\([^,;]*\\)" (line-beginning-position)) (match-string-no-properties 2))) (candidates (company-bbdb--candidates arg)) (sorted t) (no-cache t))) (provide 'company-bbdb) ;;; company-bbdb.el ends here company-mode-0.9.9/company-capf.el000066400000000000000000000210071340430754600170260ustar00rootroot00000000000000;;; company-capf.el --- company-mode completion-at-point-functions backend -*- lexical-binding: t -*- ;; Copyright (C) 2013-2018 Free Software Foundation, Inc. ;; Author: Stefan Monnier ;; 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 . ;;; 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) (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.") (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)) (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 (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)) (sortfun (cdr (assq 'display-sort-function meta))) (candidates (completion-all-completions arg table pred (length arg))) (last (last candidates)) (base-size (and (numberp (cdr last)) (cdr last)))) (when base-size (setcdr last nil)) (when sortfun (setq candidates (funcall sortfun candidates))) (if (not (zerop (or base-size 0))) (let ((before (substring arg 0 base-size))) (mapcar (lambda (candidate) (concat before candidate)) candidates)) candidates))))) (`sorted (let ((res company-capf--current-completion-data)) (when res (let ((meta (completion-metadata (buffer-substring (nth 1 res) (nth 2 res)) (nth 3 res) (plist-get (nthcdr 4 res) :predicate)))) (cdr (assq 'display-sort-function meta)))))) (`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-post-completion (arg) (let* ((res company-capf--current-completion-data) (exit-function (plist-get (nthcdr 4 res) :exit-function)) (table (nth 3 res)) (pred (plist-get (nthcdr 4 res) :predicate))) (if exit-function ;; Follow the example of `completion--done'. (funcall exit-function arg ;; FIXME: Should probably use an additional heuristic: ;; completion-at-point doesn't know when the user picked a ;; particular candidate explicitly (it only checks whether ;; futher completions exist). Whereas company user can press ;; RET (or use implicit completion with company-tng). (if (eq (try-completion arg table pred) t) 'finished 'sole))))) (provide 'company-capf) ;;; company-capf.el ends here company-mode-0.9.9/company-clang.el000066400000000000000000000323611340430754600172060ustar00rootroot00000000000000;;; company-clang.el --- company-mode completion backend for Clang -*- 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 . ;;; 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-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_:]*\\)\\(?: : \\(.*\\)$\\)?$") (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))) (unless (equal match meta) (when 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 (re-search-forward pattern nil t) (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--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))) (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\\) 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 company-mode-0.9.9/company-cmake.el000066400000000000000000000167551340430754600172130ustar00rootroot00000000000000;;; company-cmake.el --- company-mode completion backend for CMake ;; Copyright (C) 2013-2014, 2017-2018 Free Software Foundation, Inc. ;; Author: Chen Bin ;; 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 . ;;; 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\\)?\\)\\(.*\\)" (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 "\\(.*\\)\\(.*\\)" (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_" (match-string 2 candidate)))) ;; C flags ((string-match "^\\(.*_\\)IS_GNU\\(C\\|CXX\\|G77\\)$" candidate) (setq candidate (concat (match-string 1 candidate) "IS_GNU"))) ;; C flags ((string-match "^\\(.*_\\)OVERRIDE_\\(C\\|CXX\\|Fortran\\)$" candidate) (setq candidate (concat (match-string 1 candidate) "OVERRIDE_"))) ((string-match "^\\(.*\\)\\(_DEBUG\\|_RELEASE\\|_RELWITHDEBINFO\\|_MINSIZEREL\\)\\(.*\\)$" candidate) (setq candidate (concat (match-string 1 candidate) "_" (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 company-mode-0.9.9/company-css.el000066400000000000000000000465321340430754600167170ustar00rootroot00000000000000;;; 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 . ;;; 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 ;; ;;