pax_global_header00006660000000000000000000000064124756346520014530gustar00rootroot0000000000000052 comment=e085a333867959a1b36015a3ad8e12e5bd6550d9 company-mode-0.8.12/000077500000000000000000000000001247563465200142105ustar00rootroot00000000000000company-mode-0.8.12/.dir-locals.el000066400000000000000000000002331247563465200166370ustar00rootroot00000000000000((nil . ((indent-tabs-mode . nil) (fill-column . 80) (sentence-end-double-space . t) (emacs-lisp-docstring-fill-column . 75)))) company-mode-0.8.12/.elpaignore000066400000000000000000000000671247563465200163410ustar00rootroot00000000000000.travis.yml .gitignore Makefile test/ company-tests.el company-mode-0.8.12/.gitignore000066400000000000000000000000151247563465200161740ustar00rootroot00000000000000*.elc ert.el company-mode-0.8.12/.travis.yml000066400000000000000000000010671247563465200163250ustar00rootroot00000000000000# https://github.com/rolandwalker/emacs-travis language: emacs-lisp env: matrix: - EMACS=emacs24 - EMACS=emacs-snapshot install: - if [ "$EMACS" = "emacs24" ]; then sudo add-apt-repository -y ppa:cassou/emacs && sudo apt-get update -qq && sudo apt-get install -qq emacs24 emacs24-el; fi - if [ "$EMACS" = "emacs-snapshot" ]; then sudo add-apt-repository -y ppa:ubuntu-elisp/ppa && sudo apt-get update -qq && sudo apt-get install -qq emacs-snapshot; fi script: make test-batch EMACS=${EMACS} company-mode-0.8.12/Makefile000066400000000000000000000016071247563465200156540ustar00rootroot00000000000000EMACS=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 `git ls-files '*.el' | xargs` elpa: *.el @version=`grep -o "Version: .*" company.el | cut -c 10-`; \ dir=company-$$version; \ mkdir -p "$$dir"; \ cp `git ls-files '*.el' | xargs` 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.8.12/NEWS.md000066400000000000000000000316771247563465200153240ustar00rootroot00000000000000# History of user-visible changes ## 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.8.12/README.md000066400000000000000000000005411247563465200154670ustar00rootroot00000000000000See the [homepage](http://company-mode.github.com/). [![githalytics.com alpha](https://cruel-carlota.pagodabox.com/336ef4be2595a7859d52e2c17b7da2b2 "githalytics.com")](http://githalytics.com/company-mode/company-mode) [![Build Status](https://travis-ci.org/company-mode/company-mode.png?branch=master)](https://travis-ci.org/company-mode/company-mode) company-mode-0.8.12/company-abbrev.el000066400000000000000000000031511247563465200174370ustar00rootroot00000000000000;;; company-abbrev.el --- company-mode completion back-end for abbrev ;; Copyright (C) 2009-2011 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 back-end 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)) (require-match t))) (provide 'company-abbrev) ;;; company-abbrev.el ends here company-mode-0.8.12/company-bbdb.el000066400000000000000000000042771247563465200171010ustar00rootroot00000000000000;;; company-bbdb.el --- company-mode completion back-end for BBDB in message-mode ;; Copyright (C) 2013-2014 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 back-end 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 back-end 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.8.12/company-capf.el000066400000000000000000000146351247563465200171200ustar00rootroot00000000000000;;; company-capf.el --- company-mode completion-at-point-functions back-end -*- lexical-binding: t -*- ;; Copyright (C) 2013-2014 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: ;; ;;; Code: (require 'company) (require 'cl-lib) (defvar company--capf-cache nil) (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))) (data (run-hook-wrapped 'completion-at-point-functions ;; Ignore misbehaving functions. #'completion--capf-wrapper 'optimist))) (when (and (consp (cdr data)) (numberp (nth 1 data))) data))) (defun company-capf (command &optional arg &rest _args) "`company-mode' back-end using `completion-at-point-functions'." (interactive (list 'interactive)) (pcase command (`interactive (company-begin-backend 'company-capf)) (`prefix (let ((res (company--capf-data))) (when res (if (> (nth 2 res) (point)) 'stop (buffer-substring-no-properties (nth 1 res) (point)))))) (`candidates (let ((res (company--capf-data))) (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-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 ;; Can't just use 0 when base-size (see above) is non-zero. (let ((start (if (get-text-property 0 'font-lock-face arg) 0 (next-single-property-change 0 'font-lock-face arg)))) (when start ;; completions-common-part comes first, but we can't just look for this ;; value because it can be in a list. (or (let ((value (get-text-property start 'font-lock-face arg))) (text-property-not-all start (length arg) 'font-lock-face value arg)) (length arg))))) (`duplicates t) (`no-cache t) ;Not much can be done here, as long as we handle ;non-prefix matches. (`meta (let ((f (plist-get (nthcdr 4 (company--capf-data)) :company-docsig))) (when f (funcall f arg)))) (`doc-buffer (let ((f (plist-get (nthcdr 4 (company--capf-data)) :company-doc-buffer))) (when f (funcall f arg)))) (`location (let ((f (plist-get (nthcdr 4 (company--capf-data)) :company-location))) (when f (funcall f arg)))) (`annotation (save-excursion ;; FIXME: `company-begin' sets `company-point' after calling ;; `company--begin-new'. We shouldn't rely on `company-point' here, ;; better to cache the capf-data value instead. However: we can't just ;; save the last capf-data value in `prefix', because that command can ;; get called more often than `candidates', and at any point in the ;; buffer (https://github.com/company-mode/company-mode/issues/153). ;; We could try propertizing the returned prefix string, but it's not ;; passed to `annotation', and `company-prefix' is set only after ;; `company--strip-duplicates' is called. (when company-point (goto-char company-point)) (let ((f (plist-get (nthcdr 4 (company--capf-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 (let* ((res (company--capf-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 (if (eq (try-completion arg table pred) t) 'finished 'sole))))) )) (provide 'company-capf) ;;; company-capf.el ends here company-mode-0.8.12/company-clang.el000066400000000000000000000314301247563465200172630ustar00rootroot00000000000000;;; company-clang.el --- company-mode completion back-end for Clang -*- lexical-binding: t -*- ;; Copyright (C) 2009, 2011, 2013-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 . ;;; Commentary: ;; ;;; Code: (require 'company) (require 'company-template) (require 'cl-lib) (defgroup company-clang nil "Completion back-end 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 \":\".") (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))) (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 ((meta (company-clang--meta candidate))) (cond ((null meta) nil) ((string-match "[^:]:[^:]" meta) (substring meta (1+ (match-beginning 0)))) ((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 "")) (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:\n%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)) (with-current-buffer buf (erase-buffer)) (if (get-buffer-process buf) (funcall callback nil) (let ((process (apply #'start-process "company-clang" buf company-clang-executable args))) (set-process-sentinel process (lambda (proc status) (unless (string-match-p "hangup" 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 (- (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 () (< company-clang--version 2.9)) (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\\(?: version \\|-\\)\\([0-9.]+\\)" nil t) (let ((ver (string-to-number (match-string-no-properties 1)))) (if (> ver 100) (/ ver 100) ver)) 0))) (defun company-clang-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) (when (looking-at "([^)]*) ?") (delete-region (match-beginning 0) (match-end 0))) (company-template-add-field templ (point) (format "arg%d" cnt)) (if (< (point) end) (insert " ") (throw 'stop t)) (cl-incf cnt)))) (company-template-move-to-first templ))) (defun company-clang (command &optional arg &rest ignored) "`company-mode' completion back-end 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)) (when (< company-clang--version company-clang-required-version) (error "Company requires clang version 1.1")))) (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-clang-objc-templatify anno) (company-template-c-like-templatify (concat arg anno)))))))) (provide 'company-clang) ;;; company-clang.el ends here company-mode-0.8.12/company-cmake.el000066400000000000000000000163021247563465200172600ustar00rootroot00000000000000;;; company-cmake.el --- company-mode completion back-end for CMake ;; Copyright (C) 2013-2014 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 back-end 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 (command &optional arg &rest ignored) "`company-mode' completion back-end 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) (not (company-in-string-or-comment)) (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.8.12/company-css.el000066400000000000000000000457561247563465200170070ustar00rootroot00000000000000;;; company-css.el --- company-mode completion back-end for css-mode -*- 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 . ;;; Commentary: ;;; Code: (require 'company) (require 'cl-lib) (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 ;; ;;